openharmony/third_party_qrcodegen
1
0
Fork 0
mirror of https://gitee.com/openharmony/third_party_qrcodegen synced 2024-11-23 07:10:22 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Description: upgrade qrcode from 1.7.0 to 1.8.0

Browse Source 
IssueNo: https://gitee.com/openharmony/third_party_qrcodegen/issues/I6O20W
Feature or Bugfix: Feature
Binary Source:from third patry
Signed-off-by: guanzengkun <guanzengkun@huawei.com>
This commit is contained in:
guanzengkun 2023-04-25 19:30:23 +08:00
commit 16f7e447e6
43 changed files with 5062 additions and 536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.OpenSource
View File

@ -3,7 +3,7 @@
"Name": "QR-Code-generator",
"License": "MIT License",
"License File": "LICENSE",
"Version Number": " 1.7.0",
"Version Number": " 1.8.0",
"Owner": "guorensong1@huawei.com",
"Upstream URL": "https://www.nayuki.io/page/qr-code-generator-library",
"Description": "QR-Code-generator"

124
Readme.markdown
View File

@ -21,7 +21,7 @@ Core features:
* Output format: Raw modules/pixels of the QR symbol
* Detects finder-like penalty patterns more accurately than other implementations
* Encodes numeric and special-alphanumeric text in less space than general text
* Open source code under the permissive MIT License
* Open-source code under the permissive MIT License
Manual parameters:
@ -41,7 +41,7 @@ More information about QR Code technology and this library's design can be found
Examples
--------
Java language:
The code below is in Java, but the other language ports are designed with essentially the same API naming and behavior.
```java
import java.awt.image.BufferedImage;
@ -65,129 +65,11 @@ for (int y = 0; y < qr1.size; y++) {
}
```
TypeScript/JavaScript languages:
```typescript
// Name abbreviated for the sake of these examples here
const QRC = qrcodegen.QrCode;
// Simple operation
const qr0 = QRC.encodeText("Hello, world!", QRC.Ecc.MEDIUM);
const svg = toSvgString(qr0, 4); // See qrcodegen-input-demo
// Manual operation
const segs = qrcodegen.QrSegment.makeSegments("3141592653589793238462643383");
const qr1 = QRC.encodeSegments(segs, QRC.Ecc.HIGH, 5, 5, 2, false);
for (let y = 0; y < qr1.size; y++) {
for (let x = 0; x < qr1.size; x++) {
(... paint qr1.getModule(x, y) ...)
}
}
```
Python language:
```python
from qrcodegen import *
# Simple operation
qr0 = QrCode.encode_text("Hello, world!", QrCode.Ecc.MEDIUM)
svg = to_svg_str(qr0, 4) # See qrcodegen-demo
# Manual operation
segs = QrSegment.make_segments("3141592653589793238462643383")
qr1 = QrCode.encode_segments(segs, QrCode.Ecc.HIGH, 5, 5, 2, False)
for y in range(qr1.get_size()):
for x in range(qr1.get_size()):
(... paint qr1.get_module(x, y) ...)
```
C++ language:
```c++
#include <string>
#include <vector>
#include "QrCode.hpp"
using namespace qrcodegen;
// Simple operation
QrCode qr0 = QrCode::encodeText("Hello, world!", QrCode::Ecc::MEDIUM);
std::string svg = toSvgString(qr0, 4); // See QrCodeGeneratorDemo
// Manual operation
std::vector<QrSegment> segs =
QrSegment::makeSegments("3141592653589793238462643383");
QrCode qr1 = QrCode::encodeSegments(
segs, QrCode::Ecc::HIGH, 5, 5, 2, false);
for (int y = 0; y < qr1.getSize(); y++) {
for (int x = 0; x < qr1.getSize(); x++) {
(... paint qr1.getModule(x, y) ...)
}
}
```
C language:
```c
#include <stdbool.h>
#include <stdint.h>
#include "qrcodegen.h"
// Text data
uint8_t qr0[qrcodegen_BUFFER_LEN_MAX];
uint8_t tempBuffer[qrcodegen_BUFFER_LEN_MAX];
bool ok = qrcodegen_encodeText("Hello, world!",
tempBuffer, qr0, qrcodegen_Ecc_MEDIUM,
qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX,
qrcodegen_Mask_AUTO, true);
if (!ok)
return;
int size = qrcodegen_getSize(qr0);
for (int y = 0; y < size; y++) {
for (int x = 0; x < size; x++) {
(... paint qrcodegen_getModule(qr0, x, y) ...)
}
}
// Binary data
uint8_t dataAndTemp[qrcodegen_BUFFER_LEN_FOR_VERSION(7)]
= {0xE3, 0x81, 0x82};
uint8_t qr1[qrcodegen_BUFFER_LEN_FOR_VERSION(7)];
ok = qrcodegen_encodeBinary(dataAndTemp, 3, qr1,
qrcodegen_Ecc_HIGH, 2, 7, qrcodegen_Mask_4, false);
```
Rust language:
```rust
extern crate qrcodegen;
use qrcodegen::QrCode;
use qrcodegen::QrCodeEcc;
use qrcodegen::QrSegment;
// Simple operation
let qr = QrCode::encode_text("Hello, world!",
QrCodeEcc::Medium).unwrap();
let svg = to_svg_string(&qr, 4); // See qrcodegen-demo
// Manual operation
let chrs: Vec<char> = "3141592653589793238462643383".chars().collect();
let segs = QrSegment::make_segments(&chrs);
let qr = QrCode::encode_segments_advanced(
&segs, QrCodeEcc::High, 5, 5, Some(Mask::new(2)), false).unwrap();
for y in 0 .. qr.size() {
for x in 0 .. qr.size() {
(... paint qr.get_module(x, y) ...)
}
}
```
License
-------
Copyright © 2021 Project Nayuki. (MIT License)
Copyright © 2022 Project Nayuki. (MIT License)
[https://www.nayuki.io/page/qr-code-generator-library](https://www.nayuki.io/page/qr-code-generator-library)
Permission is hereby granted, free of charge, to any person obtaining a copy of

70
c/Readme.markdown Normal file
View File

@ -0,0 +1,70 @@
QR Code generator library - C
=============================
Introduction
------------
This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
Features
--------
Core features:
* Significantly shorter code but more documentation comments compared to competing libraries
* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
* Output format: Raw modules/pixels of the QR symbol
* Detects finder-like penalty patterns more accurately than other implementations
* Encodes numeric and special-alphanumeric text in less space than general text
* Completely avoids heap allocation (`malloc()`), instead relying on suitably sized buffers from the caller and fixed-size stack allocations
* Coded carefully to prevent memory corruption, integer overflow, platform-dependent inconsistencies, and undefined behavior; tested rigorously to confirm safety
* Open-source code under the permissive MIT License
Manual parameters:
* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
* User can create a list of data segments manually and add ECI segments
More information about QR Code technology and this library's design can be found on the project home page.
Examples
--------
```c
#include <stdbool.h>
#include <stdint.h>
#include "qrcodegen.h"
// Text data
uint8_t qr0[qrcodegen_BUFFER_LEN_MAX];
uint8_t tempBuffer[qrcodegen_BUFFER_LEN_MAX];
bool ok = qrcodegen_encodeText("Hello, world!",
tempBuffer, qr0, qrcodegen_Ecc_MEDIUM,
qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX,
qrcodegen_Mask_AUTO, true);
if (!ok)
return;
int size = qrcodegen_getSize(qr0);
for (int y = 0; y < size; y++) {
for (int x = 0; x < size; x++) {
(... paint qrcodegen_getModule(qr0, x, y) ...)
}
}
// Binary data
uint8_t dataAndTemp[qrcodegen_BUFFER_LEN_FOR_VERSION(7)]
= {0xE3, 0x81, 0x82};
uint8_t qr1[qrcodegen_BUFFER_LEN_FOR_VERSION(7)];
ok = qrcodegen_encodeBinary(dataAndTemp, 3, qr1,
qrcodegen_Ecc_HIGH, 2, 7, qrcodegen_Mask_4, false);
```
More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/c/qrcodegen-demo.c .

24
c/qrcodegen-demo.c
View File

@ -128,6 +128,10 @@ static void doSegmentDemo(void) {
bool ok;
{
char *concat = calloc(strlen(silver0) + strlen(silver1) + 1, sizeof(char));
if (concat == NULL) {
perror("calloc");
exit(EXIT_FAILURE);
}
strcat(concat, silver0);
strcat(concat, silver1);
ok = qrcodegen_encodeText(concat, tempBuffer, qrcode, qrcodegen_Ecc_LOW,
@ -139,6 +143,10 @@ static void doSegmentDemo(void) {
{
uint8_t *segBuf0 = malloc(qrcodegen_calcSegmentBufferSize(qrcodegen_Mode_ALPHANUMERIC, strlen(silver0)) * sizeof(uint8_t));
uint8_t *segBuf1 = malloc(qrcodegen_calcSegmentBufferSize(qrcodegen_Mode_NUMERIC, strlen(silver1)) * sizeof(uint8_t));
if (segBuf0 == NULL || segBuf1 == NULL) {
perror("malloc");
exit(EXIT_FAILURE);
}
struct qrcodegen_Segment segs[] = {
qrcodegen_makeAlphanumeric(silver0, segBuf0),
qrcodegen_makeNumeric(silver1, segBuf1),
@ -160,6 +168,10 @@ static void doSegmentDemo(void) {
bool ok;
{
char *concat = calloc(strlen(golden0) + strlen(golden1) + strlen(golden2) + 1, sizeof(char));
if (concat == NULL) {
perror("calloc");
exit(EXIT_FAILURE);
}
strcat(concat, golden0);
strcat(concat, golden1);
strcat(concat, golden2);
@ -171,11 +183,19 @@ static void doSegmentDemo(void) {
}
{
uint8_t *bytes = malloc(strlen(golden0) * sizeof(uint8_t));
if (bytes == NULL) {
perror("malloc");
exit(EXIT_FAILURE);
}
for (size_t i = 0, len = strlen(golden0); i < len; i++)
bytes[i] = (uint8_t)golden0[i];
uint8_t *segBuf0 = malloc(qrcodegen_calcSegmentBufferSize(qrcodegen_Mode_BYTE, strlen(golden0)) * sizeof(uint8_t));
uint8_t *segBuf1 = malloc(qrcodegen_calcSegmentBufferSize(qrcodegen_Mode_NUMERIC, strlen(golden1)) * sizeof(uint8_t));
uint8_t *segBuf2 = malloc(qrcodegen_calcSegmentBufferSize(qrcodegen_Mode_ALPHANUMERIC, strlen(golden2)) * sizeof(uint8_t));
if (segBuf0 == NULL || segBuf1 == NULL || segBuf2 == NULL) {
perror("malloc");
exit(EXIT_FAILURE);
}
struct qrcodegen_Segment segs[] = {
qrcodegen_makeBytes(bytes, strlen(golden0), segBuf0),
qrcodegen_makeNumeric(golden1, segBuf1),
@ -222,6 +242,10 @@ static void doSegmentDemo(void) {
};
size_t len = sizeof(kanjiChars) / sizeof(kanjiChars[0]);
uint8_t *segBuf = calloc(qrcodegen_calcSegmentBufferSize(qrcodegen_Mode_KANJI, len), sizeof(uint8_t));
if (segBuf == NULL) {
perror("calloc");
exit(EXIT_FAILURE);
}
struct qrcodegen_Segment seg;
seg.mode = qrcodegen_Mode_KANJI;
seg.numChars = (int)len;

59
c/qrcodegen-test.c
View File

@ -54,9 +54,9 @@ void reedSolomonComputeRemainder(const uint8_t data[], int dataLen, const uint8_
uint8_t reedSolomonMultiply(uint8_t x, uint8_t y);
void initializeFunctionModules(int version, uint8_t qrcode[]);
int getAlignmentPatternPositions(int version, uint8_t result[7]);
bool getModule(const uint8_t qrcode[], int x, int y);
void setModule(uint8_t qrcode[], int x, int y, bool isDark);
bool getModuleBounded(const uint8_t qrcode[], int x, int y);
void setModuleBounded(uint8_t qrcode[], int x, int y, bool isDark);
void setModuleUnbounded(uint8_t qrcode[], int x, int y, bool isDark);
int calcSegmentBitLength(enum qrcodegen_Mode mode, size_t numChars);
int getTotalBits(const struct qrcodegen_Segment segs[], size_t len, int version);
@ -116,9 +116,17 @@ static uint8_t *addEccAndInterleaveReference(const uint8_t *data, int version, e
// Split data into blocks and append ECC to each block
uint8_t **blocks = malloc(numBlocks * sizeof(uint8_t*));
uint8_t *generator = malloc(blockEccLen * sizeof(uint8_t));
if (blocks == NULL || generator == NULL) {
perror("malloc");
exit(EXIT_FAILURE);
}
reedSolomonComputeDivisor((int)blockEccLen, generator);
for (size_t i = 0, k = 0; i < numBlocks; i++) {
uint8_t *block = malloc((shortBlockLen + 1) * sizeof(uint8_t));
if (block == NULL) {
perror("malloc");
exit(EXIT_FAILURE);
}
size_t datLen = shortBlockLen - blockEccLen + (i < numShortBlocks ? 0 : 1);
memcpy(block, &data[k], datLen * sizeof(uint8_t));
reedSolomonComputeRemainder(&data[k], (int)datLen, generator, (int)blockEccLen, &block[shortBlockLen + 1 - blockEccLen]);
@ -129,6 +137,10 @@ static uint8_t *addEccAndInterleaveReference(const uint8_t *data, int version, e
// Interleave (not concatenate) the bytes from every block into a single sequence
uint8_t *result = malloc(rawCodewords * sizeof(uint8_t));
if (result == NULL) {
perror("malloc");
exit(EXIT_FAILURE);
}
for (size_t i = 0, k = 0; i < shortBlockLen + 1; i++) {
for (size_t j = 0; j < numBlocks; j++) {
// Skip the padding byte in short blocks
@ -150,14 +162,26 @@ static void testAddEccAndInterleave(void) {
for (int ecl = 0; ecl < 4; ecl++) {
size_t dataLen = (size_t)getNumDataCodewords(version, (enum qrcodegen_Ecc)ecl);
uint8_t *pureData = malloc(dataLen * sizeof(uint8_t));
if (pureData == NULL) {
perror("malloc");
exit(EXIT_FAILURE);
}
for (size_t i = 0; i < dataLen; i++)
pureData[i] = (uint8_t)(rand() % 256);
uint8_t *expectOutput = addEccAndInterleaveReference(pureData, version, (enum qrcodegen_Ecc)ecl);
size_t dataAndEccLen = (size_t)getNumRawDataModules(version) / 8;
uint8_t *paddedData = malloc(dataAndEccLen * sizeof(uint8_t));
if (paddedData == NULL) {
perror("malloc");
exit(EXIT_FAILURE);
}
memcpy(paddedData, pureData, dataLen * sizeof(uint8_t));
uint8_t *actualOutput = malloc(dataAndEccLen * sizeof(uint8_t));
if (actualOutput == NULL) {
perror("malloc");
exit(EXIT_FAILURE);
}
addEccAndInterleave(paddedData, version, (enum qrcodegen_Ecc)ecl, actualOutput);
assert(memcmp(actualOutput, expectOutput, dataAndEccLen * sizeof(uint8_t)) == 0);
@ -363,7 +387,10 @@ static void testReedSolomonMultiply(void) {
static void testInitializeFunctionModulesEtc(void) {
for (int ver = 1; ver <= 40; ver++) {
uint8_t *qrcode = malloc((size_t)qrcodegen_BUFFER_LEN_FOR_VERSION(ver) * sizeof(uint8_t));
assert(qrcode != NULL);
if (qrcode == NULL) {
perror("malloc");
exit(EXIT_FAILURE);
}
initializeFunctionModules(ver, qrcode);
int size = qrcodegen_getSize(qrcode);
@ -426,7 +453,7 @@ static void testGetSetModule(void) {
for (int y = 0; y < size; y++) { // Clear all to light
for (int x = 0; x < size; x++)
setModule(qrcode, x, y, false);
setModuleBounded(qrcode, x, y, false);
}
for (int y = 0; y < size; y++) { // Check all light
for (int x = 0; x < size; x++)
@ -434,7 +461,7 @@ static void testGetSetModule(void) {
}
for (int y = 0; y < size; y++) { // Set all to dark
for (int x = 0; x < size; x++)
setModule(qrcode, x, y, true);
setModuleBounded(qrcode, x, y, true);
}
for (int y = 0; y < size; y++) { // Check all dark
for (int x = 0; x < size; x++)
@ -442,20 +469,20 @@ static void testGetSetModule(void) {
}
// Set some out of bounds modules to light
setModuleBounded(qrcode, -1, -1, false);
setModuleBounded(qrcode, -1, 0, false);
setModuleBounded(qrcode, 0, -1, false);
setModuleBounded(qrcode, size, 5, false);
setModuleBounded(qrcode, 72, size, false);
setModuleBounded(qrcode, size, size, false);
setModuleUnbounded(qrcode, -1, -1, false);
setModuleUnbounded(qrcode, -1, 0, false);
setModuleUnbounded(qrcode, 0, -1, false);
setModuleUnbounded(qrcode, size, 5, false);
setModuleUnbounded(qrcode, 72, size, false);
setModuleUnbounded(qrcode, size, size, false);
for (int y = 0; y < size; y++) { // Check all dark
for (int x = 0; x < size; x++)
assert(qrcodegen_getModule(qrcode, x, y) == true);
}
// Set some modules to light
setModule(qrcode, 3, 8, false);
setModule(qrcode, 61, 49, false);
setModuleBounded(qrcode, 3, 8, false);
setModuleBounded(qrcode, 61, 49, false);
for (int y = 0; y < size; y++) { // Check most dark
for (int x = 0; x < size; x++) {
bool light = (x == 3 && y == 8) || (x == 61 && y == 49);
@ -484,16 +511,16 @@ static void testGetSetModuleRandomly(void) {
bool isInBounds = 0 <= x && x < size && 0 <= y && y < size;
bool oldColor = isInBounds && modules[y][x];
if (isInBounds)
assert(getModule(qrcode, x, y) == oldColor);
assert(getModuleBounded(qrcode, x, y) == oldColor);
assert(qrcodegen_getModule(qrcode, x, y) == oldColor);
bool newColor = rand() % 2 == 0;
if (isInBounds)
modules[y][x] = newColor;
if (isInBounds && rand() % 2 == 0)
setModule(qrcode, x, y, newColor);
else
setModuleBounded(qrcode, x, y, newColor);
else
setModuleUnbounded(qrcode, x, y, newColor);
}
numTestCases++;
}

100
c/qrcodegen.c
View File

@ -76,9 +76,9 @@ static int finderPenaltyCountPatterns(const int runHistory[7], int qrsize);
static int finderPenaltyTerminateAndCount(bool currentRunColor, int currentRunLength, int runHistory[7], int qrsize);
static void finderPenaltyAddHistory(int currentRunLength, int runHistory[7], int qrsize);
testable bool getModule(const uint8_t qrcode[], int x, int y);
testable void setModule(uint8_t qrcode[], int x, int y, bool isDark);
testable bool getModuleBounded(const uint8_t qrcode[], int x, int y);
testable void setModuleBounded(uint8_t qrcode[], int x, int y, bool isDark);
testable void setModuleUnbounded(uint8_t qrcode[], int x, int y, bool isDark);
static bool getBit(int x, int i);
testable int calcSegmentBitLength(enum qrcodegen_Mode mode, size_t numChars);
@ -255,14 +255,14 @@ bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], siz
for (uint8_t padByte = 0xEC; bitLen < dataCapacityBits; padByte ^= 0xEC ^ 0x11)
appendBitsToBuffer(padByte, 8, qrcode, &bitLen);
// Draw function and data codeword modules
// Compute ECC, draw modules
addEccAndInterleave(qrcode, version, ecl, tempBuffer);
initializeFunctionModules(version, qrcode);
drawCodewords(tempBuffer, getNumRawDataModules(version) / 8, qrcode);
drawLightFunctionModules(qrcode, version);
initializeFunctionModules(version, tempBuffer);
// Handle masking
// Do masking
if (mask == qrcodegen_Mask_AUTO) { // Automatically choose best mask
long minPenalty = LONG_MAX;
for (int i = 0; i < 8; i++) {
@ -278,8 +278,8 @@ bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], siz
}
}
assert(0 <= (int)mask && (int)mask <= 7);
applyMask(tempBuffer, qrcode, mask);
drawFormatBits(ecl, mask, qrcode);
applyMask(tempBuffer, qrcode, mask); // Apply the final choice of mask
drawFormatBits(ecl, mask, qrcode); // Overwrite old format bits
return true;
}
@ -456,8 +456,8 @@ static void drawLightFunctionModules(uint8_t qrcode[], int version) {
// Draw horizontal and vertical timing patterns
int qrsize = qrcodegen_getSize(qrcode);
for (int i = 7; i < qrsize - 7; i += 2) {
setModule(qrcode, 6, i, false);
setModule(qrcode, i, 6, false);
setModuleBounded(qrcode, 6, i, false);
setModuleBounded(qrcode, i, 6, false);
}
// Draw 3 finder patterns (all corners except bottom right; overwrites some timing modules)
@ -467,9 +467,9 @@ static void drawLightFunctionModules(uint8_t qrcode[], int version) {
if (abs(dy) > dist)
dist = abs(dy);
if (dist == 2 || dist == 4) {
setModuleBounded(qrcode, 3 + dx, 3 + dy, false);
setModuleBounded(qrcode, qrsize - 4 + dx, 3 + dy, false);
setModuleBounded(qrcode, 3 + dx, qrsize - 4 + dy, false);
setModuleUnbounded(qrcode, 3 + dx, 3 + dy, false);
setModuleUnbounded(qrcode, qrsize - 4 + dx, 3 + dy, false);
setModuleUnbounded(qrcode, 3 + dx, qrsize - 4 + dy, false);
}
}
}
@ -483,7 +483,7 @@ static void drawLightFunctionModules(uint8_t qrcode[], int version) {
continue; // Don't draw on the three finder corners
for (int dy = -1; dy <= 1; dy++) {
for (int dx = -1; dx <= 1; dx++)
setModule(qrcode, alignPatPos[i] + dx, alignPatPos[j] + dy, dx == 0 && dy == 0);
setModuleBounded(qrcode, alignPatPos[i] + dx, alignPatPos[j] + dy, dx == 0 && dy == 0);
}
}
}
@ -501,8 +501,8 @@ static void drawLightFunctionModules(uint8_t qrcode[], int version) {
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 3; j++) {
int k = qrsize - 11 + j;
setModule(qrcode, k, i, (bits & 1) != 0);
setModule(qrcode, i, k, (bits & 1) != 0);
setModuleBounded(qrcode, k, i, (bits & 1) != 0);
setModuleBounded(qrcode, i, k, (bits & 1) != 0);
bits >>= 1;
}
}
@ -526,20 +526,20 @@ static void drawFormatBits(enum qrcodegen_Ecc ecl, enum qrcodegen_Mask mask, uin
// Draw first copy
for (int i = 0; i <= 5; i++)
setModule(qrcode, 8, i, getBit(bits, i));
setModule(qrcode, 8, 7, getBit(bits, 6));
setModule(qrcode, 8, 8, getBit(bits, 7));
setModule(qrcode, 7, 8, getBit(bits, 8));
setModuleBounded(qrcode, 8, i, getBit(bits, i));
setModuleBounded(qrcode, 8, 7, getBit(bits, 6));
setModuleBounded(qrcode, 8, 8, getBit(bits, 7));
setModuleBounded(qrcode, 7, 8, getBit(bits, 8));
for (int i = 9; i < 15; i++)
setModule(qrcode, 14 - i, 8, getBit(bits, i));
setModuleBounded(qrcode, 14 - i, 8, getBit(bits, i));
// Draw second copy
int qrsize = qrcodegen_getSize(qrcode);
for (int i = 0; i < 8; i++)
setModule(qrcode, qrsize - 1 - i, 8, getBit(bits, i));
setModuleBounded(qrcode, qrsize - 1 - i, 8, getBit(bits, i));
for (int i = 8; i < 15; i++)
setModule(qrcode, 8, qrsize - 15 + i, getBit(bits, i));
setModule(qrcode, 8, qrsize - 8, true); // Always dark
setModuleBounded(qrcode, 8, qrsize - 15 + i, getBit(bits, i));
setModuleBounded(qrcode, 8, qrsize - 8, true); // Always dark
}
@ -560,11 +560,11 @@ testable int getAlignmentPatternPositions(int version, uint8_t result[7]) {
}
// Sets every pixel in the range [left : left + width] * [top : top + height] to dark.
// Sets every module in the range [left : left + width] * [top : top + height] to dark.
static void fillRectangle(int left, int top, int width, int height, uint8_t qrcode[]) {
for (int dy = 0; dy < height; dy++) {
for (int dx = 0; dx < width; dx++)
setModule(qrcode, left + dx, top + dy, true);
setModuleBounded(qrcode, left + dx, top + dy, true);
}
}
@ -586,9 +586,9 @@ static void drawCodewords(const uint8_t data[], int dataLen, uint8_t qrcode[]) {
int x = right - j; // Actual x coordinate
bool upward = ((right + 1) & 2) == 0;
int y = upward ? qrsize - 1 - vert : vert; // Actual y coordinate
if (!getModule(qrcode, x, y) && i < dataLen * 8) {
if (!getModuleBounded(qrcode, x, y) && i < dataLen * 8) {
bool dark = getBit(data[i >> 3], 7 - (i & 7));
setModule(qrcode, x, y, dark);
setModuleBounded(qrcode, x, y, dark);
i++;
}
// If this QR Code has any remainder bits (0 to 7), they were assigned as
@ -600,8 +600,8 @@ static void drawCodewords(const uint8_t data[], int dataLen, uint8_t qrcode[]) {
}
// XORs the codeword modules in this QR Code with the given mask pattern.
// The function modules must be marked and the codeword bits must be drawn
// XORs the codeword modules in this QR Code with the given mask pattern
// and given pattern of function modules. The codeword bits must be drawn
// before masking. Due to the arithmetic of XOR, calling applyMask() with
// the same mask value a second time will undo the mask. A final well-formed
// QR Code needs exactly one (not zero, two, etc.) mask applied.
@ -610,7 +610,7 @@ static void applyMask(const uint8_t functionModules[], uint8_t qrcode[], enum qr
int qrsize = qrcodegen_getSize(qrcode);
for (int y = 0; y < qrsize; y++) {
for (int x = 0; x < qrsize; x++) {
if (getModule(functionModules, x, y))
if (getModuleBounded(functionModules, x, y))
continue;
bool invert;
switch ((int)mask) {
@ -624,8 +624,8 @@ static void applyMask(const uint8_t functionModules[], uint8_t qrcode[], enum qr
case 7: invert = ((x + y) % 2 + x * y % 3) % 2 == 0; break;
default: assert(false); return;
}
bool val = getModule(qrcode, x, y);
setModule(qrcode, x, y, val ^ invert);
bool val = getModuleBounded(qrcode, x, y);
setModuleBounded(qrcode, x, y, val ^ invert);
}
}
}
@ -643,7 +643,7 @@ static long getPenaltyScore(const uint8_t qrcode[]) {
int runX = 0;
int runHistory[7] = {0};
for (int x = 0; x < qrsize; x++) {
if (getModule(qrcode, x, y) == runColor) {
if (getModuleBounded(qrcode, x, y) == runColor) {
runX++;
if (runX == 5)
result += PENALTY_N1;
@ -653,7 +653,7 @@ static long getPenaltyScore(const uint8_t qrcode[]) {
finderPenaltyAddHistory(runX, runHistory, qrsize);
if (!runColor)
result += finderPenaltyCountPatterns(runHistory, qrsize) * PENALTY_N3;
runColor = getModule(qrcode, x, y);
runColor = getModuleBounded(qrcode, x, y);
runX = 1;
}
}
@ -665,7 +665,7 @@ static long getPenaltyScore(const uint8_t qrcode[]) {
int runY = 0;
int runHistory[7] = {0};
for (int y = 0; y < qrsize; y++) {
if (getModule(qrcode, x, y) == runColor) {
if (getModuleBounded(qrcode, x, y) == runColor) {
runY++;
if (runY == 5)
result += PENALTY_N1;
@ -675,7 +675,7 @@ static long getPenaltyScore(const uint8_t qrcode[]) {
finderPenaltyAddHistory(runY, runHistory, qrsize);
if (!runColor)
result += finderPenaltyCountPatterns(runHistory, qrsize) * PENALTY_N3;
runColor = getModule(qrcode, x, y);
runColor = getModuleBounded(qrcode, x, y);
runY = 1;
}
}
@ -685,10 +685,10 @@ static long getPenaltyScore(const uint8_t qrcode[]) {
// 2*2 blocks of modules having same color
for (int y = 0; y < qrsize - 1; y++) {
for (int x = 0; x < qrsize - 1; x++) {
bool color = getModule(qrcode, x, y);
if ( color == getModule(qrcode, x + 1, y) &&
color == getModule(qrcode, x, y + 1) &&
color == getModule(qrcode, x + 1, y + 1))
bool color = getModuleBounded(qrcode, x, y);
if ( color == getModuleBounded(qrcode, x + 1, y) &&
color == getModuleBounded(qrcode, x, y + 1) &&
color == getModuleBounded(qrcode, x + 1, y + 1))
result += PENALTY_N2;
}
}
@ -697,14 +697,16 @@ static long getPenaltyScore(const uint8_t qrcode[]) {
int dark = 0;
for (int y = 0; y < qrsize; y++) {
for (int x = 0; x < qrsize; x++) {
if (getModule(qrcode, x, y))
if (getModuleBounded(qrcode, x, y))
dark++;
}
}
int total = qrsize * qrsize; // Note that size is odd, so dark/total != 1/2
// Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
int k = (int)((labs(dark * 20L - total * 10L) + total - 1) / total) - 1;
assert(0 <= k && k <= 9);
result += k * PENALTY_N4;
assert(0 <= result && result <= 2568888L); // Non-tight upper bound based on default values of PENALTY_N1, ..., N4
return result;
}
@ -713,7 +715,7 @@ static long getPenaltyScore(const uint8_t qrcode[]) {
// returns either 0, 1, or 2. A helper function for getPenaltyScore().
static int finderPenaltyCountPatterns(const int runHistory[7], int qrsize) {
int n = runHistory[1];
assert(n <= qrsize * 3);
assert(n <= qrsize * 3); (void)qrsize;
bool core = n > 0 && runHistory[2] == n && runHistory[3] == n * 3 && runHistory[4] == n && runHistory[5] == n;
// The maximum QR Code size is 177, hence the dark run length n <= 177.
// Arithmetic is promoted to int, so n*4 will not overflow.
@ -760,12 +762,12 @@ int qrcodegen_getSize(const uint8_t qrcode[]) {
bool qrcodegen_getModule(const uint8_t qrcode[], int x, int y) {
assert(qrcode != NULL);
int qrsize = qrcode[0];
return (0 <= x && x < qrsize && 0 <= y && y < qrsize) && getModule(qrcode, x, y);
return (0 <= x && x < qrsize && 0 <= y && y < qrsize) && getModuleBounded(qrcode, x, y);
}
// Gets the module at the given coordinates, which must be in bounds.
testable bool getModule(const uint8_t qrcode[], int x, int y) {
// Returns the color of the module at the given coordinates, which must be in bounds.
testable bool getModuleBounded(const uint8_t qrcode[], int x, int y) {
int qrsize = qrcode[0];
assert(21 <= qrsize && qrsize <= 177 && 0 <= x && x < qrsize && 0 <= y && y < qrsize);
int index = y * qrsize + x;
@ -773,8 +775,8 @@ testable bool getModule(const uint8_t qrcode[], int x, int y) {
}
// Sets the module at the given coordinates, which must be in bounds.
testable void setModule(uint8_t qrcode[], int x, int y, bool isDark) {
// Sets the color of the module at the given coordinates, which must be in bounds.
testable void setModuleBounded(uint8_t qrcode[], int x, int y, bool isDark) {
int qrsize = qrcode[0];
assert(21 <= qrsize && qrsize <= 177 && 0 <= x && x < qrsize && 0 <= y && y < qrsize);
int index = y * qrsize + x;
@ -787,11 +789,11 @@ testable void setModule(uint8_t qrcode[], int x, int y, bool isDark) {
}
// Sets the module at the given coordinates, doing nothing if out of bounds.
testable void setModuleBounded(uint8_t qrcode[], int x, int y, bool isDark) {
// Sets the color of the module at the given coordinates, doing nothing if out of bounds.
testable void setModuleUnbounded(uint8_t qrcode[], int x, int y, bool isDark) {
int qrsize = qrcode[0];
if (0 <= x && x < qrsize && 0 <= y && y < qrsize)
setModule(qrcode, x, y, isDark);
setModuleBounded(qrcode, x, y, isDark);
}

142
c/qrcodegen.h
View File

@ -148,22 +148,40 @@ struct qrcodegen_Segment {
/*---- Functions (high level) to generate QR Codes ----*/
/*
* Encodes the given text string to a QR Code, returning true if encoding succeeded.
* Encodes the given text string to a QR Code, returning true if successful.
* If the data is too long to fit in any version in the given range
* at the given ECC level, then false is returned.
* - The input text must be encoded in UTF-8 and contain no NULs.
* - The variables ecl and mask must correspond to enum constant values.
* - Requires 1 <= minVersion <= maxVersion <= 40.
* - The arrays tempBuffer and qrcode must each have a length of at least
* qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion), and cannot overlap.
* - After the function returns, tempBuffer contains no useful data.
* - If successful, the resulting QR Code may use numeric,
*
* The input text must be encoded in UTF-8 and contain no NULs.
* Requires 1 <= minVersion <= maxVersion <= 40.
*
* The smallest possible QR Code version within the given range is automatically
* chosen for the output. Iff boostEcl is true, then the ECC level of the result
* may be higher than the ecl argument if it can be done without increasing the
* version. The mask is either between qrcodegen_Mask_0 to 7 to force that mask, or
* qrcodegen_Mask_AUTO to automatically choose an appropriate mask (which may be slow).
*
* About the arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion):
* - Before calling the function:
* - The array ranges tempBuffer[0 : len] and qrcode[0 : len] must allow
* reading and writing; hence each array must have a length of at least len.
* - The two ranges must not overlap (aliasing).
* - The initial state of both ranges can be uninitialized
* because the function always writes before reading.
* - After the function returns:
* - Both ranges have no guarantee on which elements are initialized and what values are stored.
* - tempBuffer contains no useful data and should be treated as entirely uninitialized.
* - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
*
* If successful, the resulting QR Code may use numeric,
* alphanumeric, or byte mode to encode the text.
* - In the most optimistic case, a QR Code at version 40 with low ECC
*
* In the most optimistic case, a QR Code at version 40 with low ECC
* can hold any UTF-8 string up to 2953 bytes, or any alphanumeric string
* up to 4296 characters, or any digit string up to 7089 characters.
* These numbers represent the hard upper limit of the QR Code standard.
* - Please consult the QR Code specification for information on
*
* Please consult the QR Code specification for information on
* data capacities per version, ECC level, and text encoding mode.
*/
bool qrcodegen_encodeText(const char *text, uint8_t tempBuffer[], uint8_t qrcode[],
@ -171,21 +189,38 @@ bool qrcodegen_encodeText(const char *text, uint8_t tempBuffer[], uint8_t qrcode
/*
* Encodes the given binary data to a QR Code, returning true if encoding succeeded.
* Encodes the given binary data to a QR Code, returning true if successful.
* If the data is too long to fit in any version in the given range
* at the given ECC level, then false is returned.
*
* Requires 1 <= minVersion <= maxVersion <= 40.
*
* The smallest possible QR Code version within the given range is automatically
* chosen for the output. Iff boostEcl is true, then the ECC level of the result
* may be higher than the ecl argument if it can be done without increasing the
* version. The mask is either between qrcodegen_Mask_0 to 7 to force that mask, or
* qrcodegen_Mask_AUTO to automatically choose an appropriate mask (which may be slow).
*
* About the arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion):
* - Before calling the function:
* - The array ranges dataAndTemp[0 : len] and qrcode[0 : len] must allow
* reading and writing; hence each array must have a length of at least len.
* - The two ranges must not overlap (aliasing).
* - The input array range dataAndTemp[0 : dataLen] should normally be
* valid UTF-8 text, but is not required by the QR Code standard.
* - The variables ecl and mask must correspond to enum constant values.
* - Requires 1 <= minVersion <= maxVersion <= 40.
* - The arrays dataAndTemp and qrcode must each have a length of at least
* qrcodegen_BUFFER_LEN_FOR_VERSION(maxVersion), and cannot overlap.
* - After the function returns, the contents of dataAndTemp may have changed,
* and does not represent useful data anymore.
* - If successful, the resulting QR Code will use byte mode to encode the data.
* - In the most optimistic case, a QR Code at version 40 with low ECC can hold any byte
* - The initial state of dataAndTemp[dataLen : len] and qrcode[0 : len]
* can be uninitialized because the function always writes before reading.
* - After the function returns:
* - Both ranges have no guarantee on which elements are initialized and what values are stored.
* - dataAndTemp contains no useful data and should be treated as entirely uninitialized.
* - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
*
* If successful, the resulting QR Code will use byte mode to encode the data.
*
* In the most optimistic case, a QR Code at version 40 with low ECC can hold any byte
* sequence up to length 2953. This is the hard upper limit of the QR Code standard.
* - Please consult the QR Code specification for information on
*
* Please consult the QR Code specification for information on
* data capacities per version, ECC level, and text encoding mode.
*/
bool qrcodegen_encodeBinary(uint8_t dataAndTemp[], size_t dataLen, uint8_t qrcode[],
@ -195,35 +230,74 @@ bool qrcodegen_encodeBinary(uint8_t dataAndTemp[], size_t dataLen, uint8_t qrcod
/*---- Functions (low level) to generate QR Codes ----*/
/*
* Renders a QR Code representing the given segments at the given error correction level.
* The smallest possible QR Code version is automatically chosen for the output. Returns true if
* QR Code creation succeeded, or false if the data is too long to fit in any version. The ECC level
* of the result may be higher than the ecl argument if it can be done without increasing the version.
* Encodes the given segments to a QR Code, returning true if successful.
* If the data is too long to fit in any version at the given ECC level,
* then false is returned.
*
* The smallest possible QR Code version is automatically chosen for
* the output. The ECC level of the result may be higher than the
* ecl argument if it can be done without increasing the version.
*
* About the byte arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX):
* - Before calling the function:
* - The array ranges tempBuffer[0 : len] and qrcode[0 : len] must allow
* reading and writing; hence each array must have a length of at least len.
* - The two ranges must not overlap (aliasing).
* - The initial state of both ranges can be uninitialized
* because the function always writes before reading.
* - The input array segs can contain segments whose data buffers overlap with tempBuffer.
* - After the function returns:
* - Both ranges have no guarantee on which elements are initialized and what values are stored.
* - tempBuffer contains no useful data and should be treated as entirely uninitialized.
* - Any segment whose data buffer overlaps with tempBuffer[0 : len]
* must be treated as having invalid values in that array.
* - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
*
* Please consult the QR Code specification for information on
* data capacities per version, ECC level, and text encoding mode.
*
* This function allows the user to create a custom sequence of segments that switches
* between modes (such as alphanumeric and byte) to encode text in less space.
* This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
* To save memory, the segments' data buffers can alias/overlap tempBuffer, and will
* result in them being clobbered, but the QR Code output will still be correct.
* But the qrcode array must not overlap tempBuffer or any segment's data buffer.
*/
bool qrcodegen_encodeSegments(const struct qrcodegen_Segment segs[], size_t len,
enum qrcodegen_Ecc ecl, uint8_t tempBuffer[], uint8_t qrcode[]);
/*
* Renders a QR Code representing the given segments with the given encoding parameters.
* Returns true if QR Code creation succeeded, or false if the data is too long to fit in the range of versions.
* Encodes the given segments to a QR Code, returning true if successful.
* If the data is too long to fit in any version in the given range
* at the given ECC level, then false is returned.
*
* Requires 1 <= minVersion <= maxVersion <= 40.
*
* The smallest possible QR Code version within the given range is automatically
* chosen for the output. Iff boostEcl is true, then the ECC level of the result
* may be higher than the ecl argument if it can be done without increasing the
* version. The mask is either between qrcodegen_Mask_0 to 7 to force that mask, or
* qrcodegen_Mask_AUTO to automatically choose an appropriate mask (which may be slow).
*
* About the byte arrays, letting len = qrcodegen_BUFFER_LEN_FOR_VERSION(qrcodegen_VERSION_MAX):
* - Before calling the function:
* - The array ranges tempBuffer[0 : len] and qrcode[0 : len] must allow
* reading and writing; hence each array must have a length of at least len.
* - The two ranges must not overlap (aliasing).
* - The initial state of both ranges can be uninitialized
* because the function always writes before reading.
* - The input array segs can contain segments whose data buffers overlap with tempBuffer.
* - After the function returns:
* - Both ranges have no guarantee on which elements are initialized and what values are stored.
* - tempBuffer contains no useful data and should be treated as entirely uninitialized.
* - Any segment whose data buffer overlaps with tempBuffer[0 : len]
* must be treated as having invalid values in that array.
* - If successful, qrcode can be passed into qrcodegen_getSize() and qrcodegen_getModule().
*
* Please consult the QR Code specification for information on
* data capacities per version, ECC level, and text encoding mode.
*
* This function allows the user to create a custom sequence of segments that switches
* between modes (such as alphanumeric and byte) to encode text in less space.
* This is a low-level API; the high-level API is qrcodegen_encodeText() and qrcodegen_encodeBinary().
* To save memory, the segments' data buffers can alias/overlap tempBuffer, and will
* result in them being clobbered, but the QR Code output will still be correct.
* But the qrcode array must not overlap tempBuffer or any segment's data buffer.
*/
bool qrcodegen_encodeSegmentsAdvanced(const struct qrcodegen_Segment segs[], size_t len, enum qrcodegen_Ecc ecl,
int minVersion, int maxVersion, enum qrcodegen_Mask mask, bool boostEcl, uint8_t tempBuffer[], uint8_t qrcode[]);
@ -247,8 +321,8 @@ bool qrcodegen_isAlphanumeric(const char *text);
/*
* Returns the number of bytes (uint8_t) needed for the data buffer of a segment
* containing the given number of characters using the given mode. Notes:
* - Returns SIZE_MAX on failure, i.e. numChars > INT16_MAX or
* the number of needed bits exceeds INT16_MAX (i.e. 32767).
* - Returns SIZE_MAX on failure, i.e. numChars > INT16_MAX or the internal
* calculation of the number of needed bits exceeds INT16_MAX (i.e. 32767).
* - Otherwise, all valid results are in the range [0, ceil(INT16_MAX / 8)], i.e. at most 4096.
* - It is okay for the user to allocate more bytes for the buffer than needed.
* - For byte mode, numChars measures the number of bytes, not Unicode code points.

61
cpp/Readme.markdown Normal file
View File

@ -0,0 +1,61 @@
QR Code generator library - C++
===============================
Introduction
------------
This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
Features
--------
Core features:
* Significantly shorter code but more documentation comments compared to competing libraries
* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
* Output format: Raw modules/pixels of the QR symbol
* Detects finder-like penalty patterns more accurately than other implementations
* Encodes numeric and special-alphanumeric text in less space than general text
* Coded carefully to prevent memory corruption, integer overflow, platform-dependent inconsistencies, and undefined behavior; tested rigorously to confirm safety
* Open-source code under the permissive MIT License
Manual parameters:
* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
* User can create a list of data segments manually and add ECI segments
More information about QR Code technology and this library's design can be found on the project home page.
Examples
--------
```c++
#include <string>
#include <vector>
#include "QrCode.hpp"
using namespace qrcodegen;
// Simple operation
QrCode qr0 = QrCode::encodeText("Hello, world!", QrCode::Ecc::MEDIUM);
std::string svg = toSvgString(qr0, 4); // See QrCodeGeneratorDemo
// Manual operation
std::vector<QrSegment> segs =
QrSegment::makeSegments("3141592653589793238462643383");
QrCode qr1 = QrCode::encodeSegments(
segs, QrCode::Ecc::HIGH, 5, 5, 2, false);
for (int y = 0; y < qr1.getSize(); y++) {
for (int x = 0; x < qr1.getSize(); x++) {
(... paint qr1.getModule(x, y) ...)
}
}
```
More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/cpp/QrCodeGeneratorDemo.cpp .

50
cpp/qrcodegen.cpp
View File

@ -22,12 +22,12 @@
*/
#include <algorithm>
#include <cassert>
#include <climits>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <stdexcept>
#include <utility>
#include "qrcodegen.hpp"
@ -39,6 +39,8 @@ using std::vector;
namespace qrcodegen {
/*---- Class QrSegment ----*/
QrSegment::Mode::Mode(int mode, int cc0, int cc1, int cc2) :
modeBits(mode) {
numBitsCharCount[0] = cc0;
@ -229,13 +231,15 @@ const char *QrSegment::ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVW
/*---- Class QrCode ----*/
int QrCode::getFormatBits(Ecc ecl) {
switch (ecl) {
case Ecc::LOW : return 1;
case Ecc::MEDIUM : return 0;
case Ecc::QUARTILE: return 3;
case Ecc::HIGH : return 2;
default: throw std::logic_error("Assertion error");
default: throw std::logic_error("Unreachable");
}
}
@ -275,8 +279,7 @@ QrCode QrCode::encodeSegments(const vector<QrSegment> &segs, Ecc ecl,
throw data_too_long(sb.str());
}
}
if (dataUsedBits == -1)
throw std::logic_error("Assertion error");
assert(dataUsedBits != -1);
// Increase the error correction level while the data still fits in the current version number
for (Ecc newEcl : {Ecc::MEDIUM, Ecc::QUARTILE, Ecc::HIGH}) { // From low to high
@ -291,17 +294,14 @@ QrCode QrCode::encodeSegments(const vector<QrSegment> &segs, Ecc ecl,
bb.appendBits(static_cast<uint32_t>(seg.getNumChars()), seg.getMode().numCharCountBits(version));
bb.insert(bb.end(), seg.getData().begin(), seg.getData().end());
}
if (bb.size() != static_cast<unsigned int>(dataUsedBits))
throw std::logic_error("Assertion error");
assert(bb.size() == static_cast<unsigned int>(dataUsedBits));
// Add terminator and pad up to a byte if applicable
size_t dataCapacityBits = static_cast<size_t>(getNumDataCodewords(version, ecl)) * 8;
if (bb.size() > dataCapacityBits)
throw std::logic_error("Assertion error");
assert(bb.size() <= dataCapacityBits);
bb.appendBits(0, std::min(4, static_cast<int>(dataCapacityBits - bb.size())));
bb.appendBits(0, (8 - static_cast<int>(bb.size() % 8)) % 8);
if (bb.size() % 8 != 0)
throw std::logic_error("Assertion error");
assert(bb.size() % 8 == 0);
// Pad with alternating bytes until data capacity is reached
for (uint8_t padByte = 0xEC; bb.size() < dataCapacityBits; padByte ^= 0xEC ^ 0x11)
@ -349,8 +349,7 @@ QrCode::QrCode(int ver, Ecc ecl, const vector<uint8_t> &dataCodewords, int msk)
applyMask(i); // Undoes the mask due to XOR
}
}
if (msk < 0 || msk > 7)
throw std::logic_error("Assertion error");
assert(0 <= msk && msk <= 7);
mask = msk;
applyMask(msk); // Apply the final choice of mask
drawFormatBits(msk); // Overwrite old format bits
@ -421,8 +420,7 @@ void QrCode::drawFormatBits(int msk) {
for (int i = 0; i < 10; i++)
rem = (rem << 1) ^ ((rem >> 9) * 0x537);
int bits = (data << 10 | rem) ^ 0x5412; // uint15
if (bits >> 15 != 0)
throw std::logic_error("Assertion error");
assert(bits >> 15 == 0);
// Draw first copy
for (int i = 0; i <= 5; i++)
@ -451,8 +449,7 @@ void QrCode::drawVersion() {
for (int i = 0; i < 12; i++)
rem = (rem << 1) ^ ((rem >> 11) * 0x1F25);
long bits = static_cast<long>(version) << 12 | rem; // uint18
if (bits >> 18 != 0)
throw std::logic_error("Assertion error");
assert(bits >> 18 == 0);
// Draw two copies
for (int i = 0; i < 18; i++) {
@ -531,8 +528,7 @@ vector<uint8_t> QrCode::addEccAndInterleave(const vector<uint8_t> &data) const {
result.push_back(blocks.at(j).at(i));
}
}
if (result.size() != static_cast<unsigned int>(rawCodewords))
throw std::logic_error("Assertion error");
assert(result.size() == static_cast<unsigned int>(rawCodewords));
return result;
}
@ -560,8 +556,7 @@ void QrCode::drawCodewords(const vector<uint8_t> &data) {
}
}
}
if (i != data.size() * 8)
throw std::logic_error("Assertion error");
assert(i == data.size() * 8);
}
@ -581,7 +576,7 @@ void QrCode::applyMask(int msk) {
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 std::logic_error("Assertion error");
default: throw std::logic_error("Unreachable");
}
modules.at(y).at(x) = modules.at(y).at(x) ^ (invert & !isFunction.at(y).at(x));
}
@ -659,7 +654,9 @@ long QrCode::getPenaltyScore() const {
int total = size * size; // Note that size is odd, so dark/total != 1/2
// Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
int k = static_cast<int>((std::abs(dark * 20L - total * 10L) + total - 1) / total) - 1;
assert(0 <= k && k <= 9);
result += k * PENALTY_N4;
assert(0 <= result && result <= 2568888L); // Non-tight upper bound based on default values of PENALTY_N1, ..., N4
return result;
}
@ -690,8 +687,7 @@ int QrCode::getNumRawDataModules(int ver) {
if (ver >= 7)
result -= 36;
}
if (!(208 <= result && result <= 29648))
throw std::logic_error("Assertion error");
assert(208 <= result && result <= 29648);
return result;
}
@ -748,16 +744,14 @@ uint8_t QrCode::reedSolomonMultiply(uint8_t x, uint8_t y) {
z = (z << 1) ^ ((z >> 7) * 0x11D);
z ^= ((y >> i) & 1) * x;
}
if (z >> 8 != 0)
throw std::logic_error("Assertion error");
assert(z >> 8 == 0);
return static_cast<uint8_t>(z);
}
int QrCode::finderPenaltyCountPatterns(const std::array<int,7> &runHistory) const {
int n = runHistory.at(1);
if (n > size * 3)
throw std::logic_error("Assertion error");
assert(n <= size * 3);
bool core = n > 0 && runHistory.at(2) == n && runHistory.at(3) == n * 3 && runHistory.at(4) == n && runHistory.at(5) == n;
return (core && runHistory.at(0) >= n * 4 && runHistory.at(6) >= n ? 1 : 0)
+ (core && runHistory.at(6) >= n * 4 && runHistory.at(0) >= n ? 1 : 0);
@ -820,6 +814,8 @@ data_too_long::data_too_long(const std::string &msg) :
/*---- Class BitBuffer ----*/
BitBuffer::BitBuffer()
: std::vector<bool>() {}

65
java-fast/Readme.markdown Normal file
View File

@ -0,0 +1,65 @@
QR Code generator library - Java, fast
======================================
Introduction
------------
This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
Home page for this fast library with design explanation and benchmarks: https://www.nayuki.io/page/fast-qr-code-generator-library
Home page for the main project with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
Features
--------
Core features:
* Approximately 1.5× to 10× faster than other Java implementation
* Shorter code but more documentation comments compared to competing libraries
* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
* Output format: Raw modules/pixels of the QR symbol
* Detects finder-like penalty patterns more accurately than other implementations
* Encodes numeric and special-alphanumeric text in less space than general text
* Encodes Japanese Unicode text in kanji mode to save a lot of space compared to UTF-8 bytes
* Computes optimal segment mode switching for text with mixed numeric/alphanumeric/general/kanji parts
* Open-source code under the permissive MIT License
Manual parameters:
* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
* User can create a list of data segments manually and add ECI segments
More information about QR Code technology and this library's design can be found on the project home page.
Examples
--------
```java
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.List;
import javax.imageio.ImageIO;
import io.nayuki.fastqrcodegen.*;
// Simple operation
QrCode qr0 = QrCode.encodeText("Hello, world!", QrCode.Ecc.MEDIUM);
BufferedImage img = toImage(qr0, 4, 10); // See QrCodeGeneratorDemo
ImageIO.write(img, "png", new File("qr-code.png"));
// Manual operation
List<QrSegment> segs = QrSegment.makeSegments("3141592653589793238462643383");
QrCode qr1 = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, 5, 5, 2, false);
for (int y = 0; y < qr1.size; y++) {
for (int x = 0; x < qr1.size; x++) {
(... paint qr1.getModule(x, y) ...)
}
}
```
More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/java-fast/io/nayuki/fastqrcodegen/QrCodeGeneratorDemo.java .

134
java-fast/io/nayuki/fastqrcodegen/BitBuffer.java Normal file
View File

@ -0,0 +1,134 @@
/*
* Fast QR Code generator library
*
* Copyright (c) Project Nayuki. (MIT License)
* https://www.nayuki.io/page/fast-qr-code-generator-library
*
* 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.
*/
package io.nayuki.fastqrcodegen;
import java.util.Arrays;
import java.util.Objects;
// An appendable sequence of bits (0s and 1s), mainly used by QrSegment.
final class BitBuffer {
/*---- Fields ----*/
int[] data; // In each 32-bit word, bits are filled from top down.
int bitLength; // Always non-negative.
/*---- Constructor ----*/
// Creates an empty bit buffer.
public BitBuffer() {
data = new int[64];
bitLength = 0;
}
/*---- Methods ----*/
// Returns the bit at the given index, yielding 0 or 1.
public int getBit(int index) {
if (index < 0 || index >= bitLength)
throw new IndexOutOfBoundsException();
return (data[index >>> 5] >>> ~index) & 1;
}
// Returns a new array representing this buffer's bits packed into
// bytes in big endian. The current bit length must be a multiple of 8.
public byte[] getBytes() {
if (bitLength % 8 != 0)
throw new IllegalStateException("Data is not a whole number of bytes");
byte[] result = new byte[bitLength / 8];
for (int i = 0; i < result.length; i++)
result[i] = (byte)(data[i >>> 2] >>> (~i << 3));
return result;
}
// Appends the given number of low-order bits of the given value
// to this buffer. Requires 0 <= len <= 31 and 0 <= val < 2^len.
public void appendBits(int val, int len) {
if (len < 0 || len > 31 || val >>> len != 0)
throw new IllegalArgumentException("Value out of range");
if (len > Integer.MAX_VALUE - bitLength)
throw new IllegalStateException("Maximum length reached");
if (bitLength + len + 1 > data.length << 5)
data = Arrays.copyOf(data, data.length * 2);
assert bitLength + len <= data.length << 5;
int remain = 32 - (bitLength & 0x1F);
assert 1 <= remain && remain <= 32;
if (remain < len) {
data[bitLength >>> 5] |= val >>> (len - remain);
bitLength += remain;
assert (bitLength & 0x1F) == 0;
len -= remain;
val &= (1 << len) - 1;
remain = 32;
}
data[bitLength >>> 5] |= val << (remain - len);
bitLength += len;
}
// Appends to this buffer the sequence of bits represented by the given
// word array and given bit length. Requires 0 <= len <= 32 * vals.length.
public void appendBits(int[] vals, int len) {
Objects.requireNonNull(vals);
if (len == 0)
return;
if (len < 0 || len > vals.length * 32L)
throw new IllegalArgumentException("Value out of range");
int wholeWords = len / 32;
int tailBits = len % 32;
if (tailBits > 0 && vals[wholeWords] << tailBits != 0)
throw new IllegalArgumentException("Last word must have low bits clear");
if (len > Integer.MAX_VALUE - bitLength)
throw new IllegalStateException("Maximum length reached");
while (bitLength + len > data.length * 32)
data = Arrays.copyOf(data, data.length * 2);
int shift = bitLength % 32;
if (shift == 0) {
System.arraycopy(vals, 0, data, bitLength / 32, (len + 31) / 32);
bitLength += len;
} else {
for (int i = 0; i < wholeWords; i++) {
int word = vals[i];
data[bitLength >>> 5] |= word >>> shift;
bitLength += 32;
data[bitLength >>> 5] = word << (32 - shift);
}
if (tailBits > 0)
appendBits(vals[wholeWords] >>> (32 - tailBits), tailBits);
}
}
}

57
java-fast/io/nayuki/fastqrcodegen/DataTooLongException.java Normal file
View File

@ -0,0 +1,57 @@
/*
* Fast QR Code generator library
*
* Copyright (c) Project Nayuki. (MIT License)
* https://www.nayuki.io/page/fast-qr-code-generator-library
*
* 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.
*/
package io.nayuki.fastqrcodegen;
/**
* Thrown when the supplied data does not fit any QR Code version. Ways to handle this exception include:
* <ul>
* <li><p>Decrease the error correction level if it was greater than {@code Ecc.LOW}.</p></li>
* <li><p>If the advanced {@code encodeSegments()} function with 6 arguments or the
* {@code makeSegmentsOptimally()} function was called, then increase the maxVersion argument
* if it was less than {@link QrCode#MAX_VERSION}. (This advice does not apply to the other
* factory functions because they search all versions up to {@code QrCode.MAX_VERSION}.)</p></li>
* <li><p>Split the text data into better or optimal segments in order to reduce the number of
* bits required. (See {@link QrSegmentAdvanced#makeSegmentsOptimally(String,QrCode.Ecc,int,int)
* QrSegmentAdvanced.makeSegmentsOptimally()}.)</p></li>
* <li><p>Change the text or binary data to be shorter.</p></li>
* <li><p>Change the text to fit the character set of a particular segment mode (e.g. alphanumeric).</p></li>
* <li><p>Propagate the error upward to the caller/user.</p></li>
* </ul>
* @see QrCode#encodeText(String, QrCode.Ecc)
* @see QrCode#encodeBinary(byte[], QrCode.Ecc)
* @see QrCode#encodeSegments(java.util.List, QrCode.Ecc)
* @see QrCode#encodeSegments(java.util.List, QrCode.Ecc, int, int, int, boolean)
* @see QrSegmentAdvanced#makeSegmentsOptimally(String, QrCode.Ecc, int, int)
*/
public class DataTooLongException extends IllegalArgumentException {
public DataTooLongException() {}
public DataTooLongException(String msg) {
super(msg);
}
}

95
java-fast/io/nayuki/fastqrcodegen/Memoizer.java Normal file
View File

@ -0,0 +1,95 @@
/*
* Fast QR Code generator library
*
* Copyright (c) Project Nayuki. (MIT License)
* https://www.nayuki.io/page/fast-qr-code-generator-library
*
* 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.
*/
package io.nayuki.fastqrcodegen;
import java.lang.ref.SoftReference;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
// A thread-safe cache based on soft references.
final class Memoizer<T,R> {
private final Function<T,R> function;
Map<T,SoftReference<R>> cache = new ConcurrentHashMap<>();
private Set<T> pending = new HashSet<>();
// Creates a memoizer based on the given function that takes one input to compute an output.
public Memoizer(Function<T,R> func) {
function = func;
}
// Computes function.apply(arg) or returns a cached copy of a previous call.
public R get(T arg) {
// Non-blocking fast path
{
SoftReference<R> ref = cache.get(arg);
if (ref != null) {
R result = ref.get();
if (result != null)
return result;
}
}
// Sequential slow path
while (true) {
synchronized(this) {
SoftReference<R> ref = cache.get(arg);
if (ref != null) {
R result = ref.get();
if (result != null)
return result;
cache.remove(arg);
}
assert !cache.containsKey(arg);
if (pending.add(arg))
break;
try {
this.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
try {
R result = function.apply(arg);
cache.put(arg, new SoftReference<>(result));
return result;
} finally {
synchronized(this) {
pending.remove(arg);
this.notifyAll();
}
}
}
}

595
java-fast/io/nayuki/fastqrcodegen/QrCode.java Normal file
View File

@ -0,0 +1,595 @@
/*
* Fast QR Code generator library
*
* Copyright (c) Project Nayuki. (MIT License)
* https://www.nayuki.io/page/fast-qr-code-generator-library
*
* 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.
*/
package io.nayuki.fastqrcodegen;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
/**
* A QR Code symbol, which is a type of two-dimension barcode.
* Invented by Denso Wave and described in the ISO/IEC 18004 standard.
* <p>Instances of this class represent an immutable square grid of dark and light cells.
* The class provides static factory functions to create a QR Code from text or binary data.
* The class covers the QR Code Model 2 specification, supporting all versions (sizes)
* from 1 to 40, all 4 error correction levels, and 4 character encoding modes.</p>
* <p>Ways to create a QR Code object:</p>
* <ul>
* <li><p>High level: Take the payload data and call {@link QrCode#encodeText(String,Ecc)}
* or {@link QrCode#encodeBinary(byte[],Ecc)}.</p></li>
* <li><p>Mid level: Custom-make the list of {@link QrSegment segments}
* and call {@link QrCode#encodeSegments(List,Ecc)} or
* {@link QrCode#encodeSegments(List,Ecc,int,int,int,boolean)}</p></li>
* <li><p>Low level: Custom-make the array of data codeword bytes (including segment headers and
* final padding, excluding error correction codewords), supply the appropriate version number,
* and call the {@link QrCode#QrCode(int,Ecc,byte[],int) constructor}.</p></li>
* </ul>
* <p>(Note that all ways require supplying the desired error correction level.)</p>
* @see QrSegment
*/
public final class QrCode {
/*---- Static factory functions (high level) ----*/
/**
* Returns a QR Code representing the specified Unicode text string at the specified 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) if the low error correction level is used. The smallest possible
* QR Code version is automatically chosen for the output. The ECC level of the result may be higher than the
* ecl argument if it can be done without increasing the version.
* @param text the text to be encoded (not {@code null}), which can be any Unicode string
* @param ecl the error correction level to use (not {@code null}) (boostable)
* @return a QR Code (not {@code null}) representing the text
* @throws NullPointerException if the text or error correction level is {@code null}
* @throws DataTooLongException if the text fails to fit in the
* largest version QR Code at the ECL, which means it is too long
*/
public static QrCode encodeText(String text, Ecc ecl) {
Objects.requireNonNull(text);
Objects.requireNonNull(ecl);
List<QrSegment> segs = QrSegment.makeSegments(text);
return encodeSegments(segs, ecl);
}
/**
* Returns a QR Code representing the specified binary data at the specified 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.
* The ECC level of the result may be higher than the ecl argument if it can be done without increasing the version.
* @param data the binary data to encode (not {@code null})
* @param ecl the error correction level to use (not {@code null}) (boostable)
* @return a QR Code (not {@code null}) representing the data
* @throws NullPointerException if the data or error correction level is {@code null}
* @throws DataTooLongException if the data fails to fit in the
* largest version QR Code at the ECL, which means it is too long
*/
public static QrCode encodeBinary(byte[] data, Ecc ecl) {
Objects.requireNonNull(data);
Objects.requireNonNull(ecl);
QrSegment seg = QrSegment.makeBytes(data);
return encodeSegments(Arrays.asList(seg), ecl);
}
/*---- Static factory functions (mid level) ----*/
/**
* Returns a QR Code representing the specified segments at the specified error correction
* level. The smallest possible QR Code version is automatically chosen for the output. The ECC level
* of the result may be higher than the ecl argument if it can be done without increasing the version.
* <p>This function allows the user to create a custom sequence of segments that switches
* between modes (such as alphanumeric and byte) to encode text in less space.
* This is a mid-level API; the high-level API is {@link #encodeText(String,Ecc)}
* and {@link #encodeBinary(byte[],Ecc)}.</p>
* @param segs the segments to encode
* @param ecl the error correction level to use (not {@code null}) (boostable)
* @return a QR Code (not {@code null}) representing the segments
* @throws NullPointerException if the list of segments, any segment, or the error correction level is {@code null}
* @throws DataTooLongException if the segments fail to fit in the
* largest version QR Code at the ECL, which means they are too long
*/
public static QrCode encodeSegments(List<QrSegment> segs, Ecc ecl) {
return encodeSegments(segs, ecl, MIN_VERSION, MAX_VERSION, -1, true);
}
/**
* Returns a QR Code representing the specified segments with the specified encoding parameters.
* The smallest possible QR Code version within the specified range is automatically
* chosen for the output. Iff boostEcl is {@code true}, then the ECC level of the
* result may be higher than the ecl argument if it can be done without increasing
* the version. The mask number is either between 0 to 7 (inclusive) to force that
* mask, or &#x2212;1 to automatically choose an appropriate mask (which may be slow).
* <p>This function allows the user to create a custom sequence of segments that switches
* between modes (such as alphanumeric and byte) to encode text in less space.
* This is a mid-level API; the high-level API is {@link #encodeText(String,Ecc)}
* and {@link #encodeBinary(byte[],Ecc)}.</p>
* @param segs the segments to encode
* @param ecl the error correction level to use (not {@code null}) (boostable)
* @param minVersion the minimum allowed version of the QR Code (at least 1)
* @param maxVersion the maximum allowed version of the QR Code (at most 40)
* @param mask the mask number to use (between 0 and 7 (inclusive)), or &#x2212;1 for automatic mask
* @param boostEcl increases the ECC level as long as it doesn't increase the version number
* @return a QR Code (not {@code null}) representing the segments
* @throws NullPointerException if the list of segments, any segment, or the error correction level is {@code null}
* @throws IllegalArgumentException if 1 &#x2264; minVersion &#x2264; maxVersion &#x2264; 40
* or &#x2212;1 &#x2264; mask &#x2264; 7 is violated
* @throws DataTooLongException if the segments fail to fit in
* the maxVersion QR Code at the ECL, which means they are too long
*/
public static QrCode encodeSegments(List<QrSegment> segs, Ecc ecl, int minVersion, int maxVersion, int mask, boolean boostEcl) {
Objects.requireNonNull(segs);
Objects.requireNonNull(ecl);
if (!(MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= MAX_VERSION) || mask < -1 || mask > 7)
throw new IllegalArgumentException("Invalid value");
// Find the minimal version number to use
int version, dataUsedBits;
for (version = minVersion; ; version++) {
int dataCapacityBits = getNumDataCodewords(version, ecl) * 8; // Number of data bits available
dataUsedBits = QrSegment.getTotalBits(segs, version);
if (dataUsedBits != -1 && dataUsedBits <= dataCapacityBits)
break; // This version number is found to be suitable
if (version >= maxVersion) { // All versions in the range could not fit the given data
String msg = "Segment too long";
if (dataUsedBits != -1)
msg = String.format("Data length = %d bits, Max capacity = %d bits", dataUsedBits, dataCapacityBits);
throw new DataTooLongException(msg);
}
}
assert dataUsedBits != -1;
// Increase the error correction level while the data still fits in the current version number
for (Ecc newEcl : Ecc.values()) { // From low to high
if (boostEcl && dataUsedBits <= getNumDataCodewords(version, newEcl) * 8)
ecl = newEcl;
}
// Concatenate all segments to create the data bit string
BitBuffer bb = new BitBuffer();
for (QrSegment seg : segs) {
bb.appendBits(seg.mode.modeBits, 4);
bb.appendBits(seg.numChars, seg.mode.numCharCountBits(version));
bb.appendBits(seg.data, seg.bitLength);
}
assert bb.bitLength == dataUsedBits;
// Add terminator and pad up to a byte if applicable
int dataCapacityBits = getNumDataCodewords(version, ecl) * 8;
assert bb.bitLength <= dataCapacityBits;
bb.appendBits(0, Math.min(4, dataCapacityBits - bb.bitLength));
bb.appendBits(0, (8 - bb.bitLength % 8) % 8);
assert bb.bitLength % 8 == 0;
// Pad with alternating bytes until data capacity is reached
for (int padByte = 0xEC; bb.bitLength < dataCapacityBits; padByte ^= 0xEC ^ 0x11)
bb.appendBits(padByte, 8);
// Create the QR Code object
return new QrCode(version, ecl, bb.getBytes(), mask);
}
/*---- Instance fields ----*/
// Public immutable scalar parameters:
/** The version number of this QR Code, which is between 1 and 40 (inclusive).
* This determines the size of this barcode. */
public final int version;
/** The width and height of this QR Code, measured in modules, between
* 21 and 177 (inclusive). This is equal to version &#xD7; 4 + 17. */
public final int size;
/** The error correction level used in this QR Code, which is not {@code null}. */
public final Ecc errorCorrectionLevel;
/** The index of the mask pattern used in this QR Code, which is between 0 and 7 (inclusive).
* <p>Even if a QR Code is created with automatic masking requested (mask =
* &#x2212;1), the resulting object still has a mask value between 0 and 7. */
public final int mask;
// Private grid of modules of this QR Code, packed tightly into bits.
// Immutable after constructor finishes. Accessed through getModule().
private final int[] modules;
/*---- Constructor (low level) ----*/
/**
* Constructs a QR Code with the specified version number,
* error correction level, data codeword bytes, and mask number.
* <p>This is a low-level API that most users should not use directly. A mid-level
* API is the {@link #encodeSegments(List,Ecc,int,int,int,boolean)} function.</p>
* @param ver the version number to use, which must be in the range 1 to 40 (inclusive)
* @param ecl the error correction level to use
* @param dataCodewords the bytes representing segments to encode (without ECC)
* @param msk the mask pattern to use, which is either &#x2212;1 for automatic choice or from 0 to 7 for fixed choice
* @throws NullPointerException if the byte array or error correction level is {@code null}
* @throws IllegalArgumentException if the version or mask value is out of range,
* or if the data is the wrong length for the specified version and error correction level
*/
public QrCode(int ver, Ecc ecl, byte[] dataCodewords, int msk) {
// Check arguments and initialize fields
if (ver < MIN_VERSION || ver > MAX_VERSION)
throw new IllegalArgumentException("Version value out of range");
if (msk < -1 || msk > 7)
throw new IllegalArgumentException("Mask value out of range");
version = ver;
size = ver * 4 + 17;
errorCorrectionLevel = Objects.requireNonNull(ecl);
Objects.requireNonNull(dataCodewords);
QrTemplate tpl = QrTemplate.MEMOIZER.get(ver);
modules = tpl.template.clone();
// Compute ECC, draw modules, do masking
byte[] allCodewords = addEccAndInterleave(dataCodewords);
drawCodewords(tpl.dataOutputBitIndexes, allCodewords);
mask = handleConstructorMasking(tpl.masks, msk);
}
/*---- Public instance methods ----*/
/**
* Returns the color of the module (pixel) at the specified coordinates, which is {@code false}
* for light or {@code true} for dark. The top left corner has the coordinates (x=0, y=0).
* If the specified coordinates are out of bounds, then {@code false} (light) is returned.
* @param x the x coordinate, where 0 is the left edge and size&#x2212;1 is the right edge
* @param y the y coordinate, where 0 is the top edge and size&#x2212;1 is the bottom edge
* @return {@code true} if the coordinates are in bounds and the module
* at that location is dark, or {@code false} (light) otherwise
*/
public boolean getModule(int x, int y) {
if (0 <= x && x < size && 0 <= y && y < size) {
int i = y * size + x;
return getBit(modules[i >>> 5], i) != 0;
} else
return false;
}
/*---- Private helper methods for constructor: Drawing function modules ----*/
// 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.
private void drawFormatBits(int msk) {
// Calculate error correction code and pack bits
int data = errorCorrectionLevel.formatBits << 3 | msk; // errCorrLvl is uint2, mask is uint3
int rem = data;
for (int i = 0; i < 10; i++)
rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
int bits = (data << 10 | rem) ^ 0x5412; // uint15
assert bits >>> 15 == 0;
// Draw first copy
for (int i = 0; i <= 5; i++)
setModule(8, i, getBit(bits, i));
setModule(8, 7, getBit(bits, 6));
setModule(8, 8, getBit(bits, 7));
setModule(7, 8, getBit(bits, 8));
for (int i = 9; i < 15; i++)
setModule(14 - i, 8, getBit(bits, i));
// Draw second copy
for (int i = 0; i < 8; i++)
setModule(size - 1 - i, 8, getBit(bits, i));
for (int i = 8; i < 15; i++)
setModule(8, size - 15 + i, getBit(bits, i));
setModule(8, size - 8, 1); // Always dark
}
// Sets the module at the given coordinates to the given color.
// Only used by the constructor. Coordinates must be in bounds.
private void setModule(int x, int y, int dark) {
assert 0 <= x && x < size;
assert 0 <= y && y < size;
assert dark == 0 || dark == 1;
int i = y * size + x;
modules[i >>> 5] &= ~(1 << i);
modules[i >>> 5] |= dark << i;
}
/*---- Private helper methods for constructor: Codewords and masking ----*/
// 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.
private byte[] addEccAndInterleave(byte[] data) {
Objects.requireNonNull(data);
if (data.length != getNumDataCodewords(version, errorCorrectionLevel))
throw new IllegalArgumentException();
// Calculate parameter numbers
int numBlocks = NUM_ERROR_CORRECTION_BLOCKS[errorCorrectionLevel.ordinal()][version];
int blockEccLen = ECC_CODEWORDS_PER_BLOCK [errorCorrectionLevel.ordinal()][version];
int rawCodewords = QrTemplate.getNumRawDataModules(version) / 8;
int numShortBlocks = numBlocks - rawCodewords % numBlocks;
int shortBlockDataLen = rawCodewords / numBlocks - blockEccLen;
// Split data into blocks, calculate ECC, and interleave
// (not concatenate) the bytes into a single sequence
byte[] result = new byte[rawCodewords];
ReedSolomonGenerator rs = ReedSolomonGenerator.MEMOIZER.get(blockEccLen);
byte[] ecc = new byte[blockEccLen]; // Temporary storage per iteration
for (int i = 0, k = 0; i < numBlocks; i++) {
int datLen = shortBlockDataLen + (i < numShortBlocks ? 0 : 1);
rs.getRemainder(data, k, datLen, ecc);
for (int j = 0, l = i; j < datLen; j++, k++, l += numBlocks) { // Copy data
if (j == shortBlockDataLen)
l -= numShortBlocks;
result[l] = data[k];
}
for (int j = 0, l = data.length + i; j < blockEccLen; j++, l += numBlocks) // Copy ECC
result[l] = ecc[j];
}
return result;
}
// Draws the given sequence of 8-bit codewords (data and error correction)
// onto the entire data area of this QR Code, based on the given bit indexes.
private void drawCodewords(int[] dataOutputBitIndexes, byte[] allCodewords) {
Objects.requireNonNull(dataOutputBitIndexes);
Objects.requireNonNull(allCodewords);
if (allCodewords.length * 8 != dataOutputBitIndexes.length)
throw new IllegalArgumentException();
for (int i = 0; i < dataOutputBitIndexes.length; i++) {
int j = dataOutputBitIndexes[i];
int bit = getBit(allCodewords[i >>> 3], ~i & 7);
modules[j >>> 5] |= bit << j;
}
}
// XORs the codeword modules in this QR Code with the given mask pattern.
// The function modules must be marked and the codeword bits must be drawn
// before masking. Due to the arithmetic of XOR, calling applyMask() with
// the same mask value a second time will undo the mask. A final well-formed
// QR Code needs exactly one (not zero, two, etc.) mask applied.
private void applyMask(int[] msk) {
if (msk.length != modules.length)
throw new IllegalArgumentException();
for (int i = 0; i < msk.length; i++)
modules[i] ^= msk[i];
}
// A messy helper function for the constructor. This QR Code must be in an unmasked state when this
// method is called. The 'mask' 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.
private int handleConstructorMasking(int[][] masks, int msk) {
if (msk == -1) { // Automatically choose best mask
int minPenalty = Integer.MAX_VALUE;
for (int i = 0; i < 8; i++) {
applyMask(masks[i]);
drawFormatBits(i);
int penalty = getPenaltyScore();
if (penalty < minPenalty) {
msk = i;
minPenalty = penalty;
}
applyMask(masks[i]); // Undoes the mask due to XOR
}
}
assert 0 <= msk && msk <= 7;
applyMask(masks[msk]); // Apply the final choice of mask
drawFormatBits(msk); // Overwrite old format bits
return msk; // The caller shall assign this value to the final-declared field
}
// 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.
private int getPenaltyScore() {
int result = 0;
int dark = 0;
int[] runHistory = new int[7];
// Iterate over adjacent pairs of rows
for (int index = 0, downIndex = size, end = size * size; index < end; ) {
int runColor = 0;
int runX = 0;
Arrays.fill(runHistory, 0);
int curRow = 0;
int nextRow = 0;
for (int x = 0; x < size; x++, index++, downIndex++) {
int c = getBit(modules[index >>> 5], index);
if (c == runColor) {
runX++;
if (runX == 5)
result += PENALTY_N1;
else if (runX > 5)
result++;
} else {
finderPenaltyAddHistory(runX, runHistory);
if (runColor == 0)
result += finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
runColor = c;
runX = 1;
}
dark += c;
if (downIndex < end) {
curRow = ((curRow << 1) | c) & 3;
nextRow = ((nextRow << 1) | getBit(modules[downIndex >>> 5], downIndex)) & 3;
// 2*2 blocks of modules having same color
if (x >= 1 && (curRow == 0 || curRow == 3) && curRow == nextRow)
result += PENALTY_N2;
}
}
result += finderPenaltyTerminateAndCount(runColor, runX, runHistory) * PENALTY_N3;
}
// Iterate over single columns
for (int x = 0; x < size; x++) {
int runColor = 0;
int runY = 0;
Arrays.fill(runHistory, 0);
for (int y = 0, index = x; y < size; y++, index += size) {
int c = getBit(modules[index >>> 5], index);
if (c == runColor) {
runY++;
if (runY == 5)
result += PENALTY_N1;
else if (runY > 5)
result++;
} else {
finderPenaltyAddHistory(runY, runHistory);
if (runColor == 0)
result += finderPenaltyCountPatterns(runHistory) * PENALTY_N3;
runColor = c;
runY = 1;
}
}
result += finderPenaltyTerminateAndCount(runColor, runY, runHistory) * PENALTY_N3;
}
// Balance of dark and light modules
int total = size * size; // Note that size is odd, so dark/total != 1/2
// Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
int k = (Math.abs(dark * 20 - total * 10) + total - 1) / total - 1;
result += k * PENALTY_N4;
return result;
}
/*---- Private helper functions ----*/
// 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, Ecc ecl) {
return QrTemplate.getNumRawDataModules(ver) / 8
- ECC_CODEWORDS_PER_BLOCK [ecl.ordinal()][ver]
* NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal()][ver];
}
// Can only be called immediately after a light run is added, and
// returns either 0, 1, or 2. A helper function for getPenaltyScore().
private int finderPenaltyCountPatterns(int[] runHistory) {
int n = runHistory[1];
assert n <= size * 3;
boolean core = n > 0 && runHistory[2] == n && runHistory[3] == n * 3 && runHistory[4] == n && runHistory[5] == n;
return (core && runHistory[0] >= n * 4 && runHistory[6] >= n ? 1 : 0)
+ (core && runHistory[6] >= n * 4 && runHistory[0] >= n ? 1 : 0);
}
// Must be called at the end of a line (row or column) of modules. A helper function for getPenaltyScore().
private int finderPenaltyTerminateAndCount(int currentRunColor, int currentRunLength, int[] runHistory) {
if (currentRunColor == 1) { // Terminate dark run
finderPenaltyAddHistory(currentRunLength, runHistory);
currentRunLength = 0;
}
currentRunLength += size; // Add light border to final run
finderPenaltyAddHistory(currentRunLength, runHistory);
return finderPenaltyCountPatterns(runHistory);
}
// Pushes the given value to the front and drops the last value. A helper function for getPenaltyScore().
private void finderPenaltyAddHistory(int currentRunLength, int[] runHistory) {
if (runHistory[0] == 0)
currentRunLength += size; // Add light border to initial run
System.arraycopy(runHistory, 0, runHistory, 1, runHistory.length - 1);
runHistory[0] = currentRunLength;
}
// Returns 0 or 1 based on the (i mod 32)'th bit of x.
static int getBit(int x, int i) {
return (x >>> i) & 1;
}
/*---- Constants and tables ----*/
/** The minimum version number (1) supported in the QR Code Model 2 standard. */
public static final int MIN_VERSION = 1;
/** The maximum version number (40) supported in the QR Code Model 2 standard. */
public static final int MAX_VERSION = 40;
// For use in getPenaltyScore(), when evaluating which mask is best.
private static final int PENALTY_N1 = 3;
private static final int PENALTY_N2 = 3;
private static final int PENALTY_N3 = 40;
private static final int PENALTY_N4 = 10;
private static final byte[][] ECC_CODEWORDS_PER_BLOCK = {
// 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, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30}, // Low
{-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28}, // Medium
{-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30}, // Quartile
{-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30}, // High
};
private static final byte[][] NUM_ERROR_CORRECTION_BLOCKS = {
// 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
};
/*---- Public helper enumeration ----*/
/**
* The error correction level in a QR Code symbol.
*/
public enum Ecc {
// Must be declared in ascending order of error protection
// so that the implicit ordinal() and values() work properly
/** The QR Code can tolerate about 7% erroneous codewords. */ LOW(1),
/** The QR Code can tolerate about 15% erroneous codewords. */ MEDIUM(0),
/** The QR Code can tolerate about 25% erroneous codewords. */ QUARTILE(3),
/** The QR Code can tolerate about 30% erroneous codewords. */ HIGH(2);
// In the range 0 to 3 (unsigned 2-bit integer).
final int formatBits;
// Constructor.
private Ecc(int fb) {
formatBits = fb;
}
}
}

255
java-fast/io/nayuki/fastqrcodegen/QrCodeGeneratorDemo.java Normal file
View File

@ -0,0 +1,255 @@
/*
* Fast QR Code generator demo
*
* Run this command-line program with no arguments. The program creates/overwrites a bunch of
* PNG and SVG files in the current working directory to demonstrate the creation of QR Codes.
*
* Copyright (c) Project Nayuki. (MIT License)
* https://www.nayuki.io/page/fast-qr-code-generator-library
*
* 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.
*/
package io.nayuki.fastqrcodegen;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import javax.imageio.ImageIO;
public final class QrCodeGeneratorDemo {
// The main application program.
public static void main(String[] args) throws IOException {
doBasicDemo();
doVarietyDemo();
doSegmentDemo();
doMaskDemo();
}
/*---- Demo suite ----*/
// Creates a single QR Code, then writes it to a PNG file and an SVG file.
private static void doBasicDemo() throws IOException {
String text = "Hello, world!"; // User-supplied Unicode text
QrCode.Ecc errCorLvl = QrCode.Ecc.LOW; // Error correction level
QrCode qr = QrCode.encodeText(text, errCorLvl); // Make the QR Code symbol
BufferedImage img = toImage(qr, 10, 4); // Convert to bitmap image
File imgFile = new File("hello-world-QR.png"); // File path for output
ImageIO.write(img, "png", imgFile); // Write image to file
String svg = toSvgString(qr, 4, "#FFFFFF", "#000000"); // Convert to SVG XML code
File svgFile = new File("hello-world-QR.svg"); // File path for output
Files.write(svgFile.toPath(), // Write image to file
svg.getBytes(StandardCharsets.UTF_8));
}
// Creates a variety of QR Codes that exercise different features of the library, and writes each one to file.
private static void doVarietyDemo() throws IOException {
QrCode qr;
// Numeric mode encoding (3.33 bits per digit)
qr = QrCode.encodeText("314159265358979323846264338327950288419716939937510", QrCode.Ecc.MEDIUM);
writePng(toImage(qr, 13, 1), "pi-digits-QR.png");
// Alphanumeric mode encoding (5.5 bits per character)
qr = QrCode.encodeText("DOLLAR-AMOUNT:$39.87 PERCENTAGE:100.00% OPERATIONS:+-*/", QrCode.Ecc.HIGH);
writePng(toImage(qr, 10, 2), "alphanumeric-QR.png");
// Unicode text as UTF-8
qr = QrCode.encodeText("こんにちwa、世界！ αβγδ", QrCode.Ecc.QUARTILE);
writePng(toImage(qr, 10, 3), "unicode-QR.png");
// Moderately large QR Code using longer text (from Lewis Carroll's Alice in Wonderland)
qr = 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.", QrCode.Ecc.HIGH);
writePng(toImage(qr, 6, 10), "alice-wonderland-QR.png");
}
// Creates QR Codes with manually specified segments for better compactness.
private static void doSegmentDemo() throws IOException {
QrCode qr;
List<QrSegment> segs;
// Illustration "silver"
String silver0 = "THE SQUARE ROOT OF 2 IS 1.";
String silver1 = "41421356237309504880168872420969807856967187537694807317667973799";
qr = QrCode.encodeText(silver0 + silver1, QrCode.Ecc.LOW);
writePng(toImage(qr, 10, 3), "sqrt2-monolithic-QR.png");
segs = Arrays.asList(
QrSegment.makeAlphanumeric(silver0),
QrSegment.makeNumeric(silver1));
qr = QrCode.encodeSegments(segs, QrCode.Ecc.LOW);
writePng(toImage(qr, 10, 3), "sqrt2-segmented-QR.png");
// Illustration "golden"
String golden0 = "Golden ratio φ = 1.";
String golden1 = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374";
String golden2 = "......";
qr = QrCode.encodeText(golden0 + golden1 + golden2, QrCode.Ecc.LOW);
writePng(toImage(qr, 8, 5), "phi-monolithic-QR.png");
segs = Arrays.asList(
QrSegment.makeBytes(golden0.getBytes(StandardCharsets.UTF_8)),
QrSegment.makeNumeric(golden1),
QrSegment.makeAlphanumeric(golden2));
qr = QrCode.encodeSegments(segs, QrCode.Ecc.LOW);
writePng(toImage(qr, 8, 5), "phi-segmented-QR.png");
// Illustration "Madoka": kanji, kana, Cyrillic, full-width Latin, Greek characters
String madoka = "「魔法少女まどか☆マギカ」って、　ИАИ　ｄｅｓｕ　κα？";
qr = QrCode.encodeText(madoka, QrCode.Ecc.LOW);
writePng(toImage(qr, 9, 4, 0xFFFFE0, 0x303080), "madoka-utf8-QR.png");
segs = Arrays.asList(QrSegmentAdvanced.makeKanji(madoka));
qr = QrCode.encodeSegments(segs, QrCode.Ecc.LOW);
writePng(toImage(qr, 9, 4, 0xE0F0FF, 0x404040), "madoka-kanji-QR.png");
}
// Creates QR Codes with the same size and contents but different mask patterns.
private static void doMaskDemo() throws IOException {
QrCode qr;
List<QrSegment> segs;
// Project Nayuki URL
segs = QrSegment.makeSegments("https://www.nayuki.io/");
qr = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, QrCode.MIN_VERSION, QrCode.MAX_VERSION, -1, true); // Automatic mask
writePng(toImage(qr, 8, 6, 0xE0FFE0, 0x206020), "project-nayuki-automask-QR.png");
qr = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 3, true); // Force mask 3
writePng(toImage(qr, 8, 6, 0xFFE0E0, 0x602020), "project-nayuki-mask3-QR.png");
// Chinese text as UTF-8
segs = QrSegment.makeSegments("維基百科（Wikipedia，聆聽i/ˌwɪkᵻˈpiːdi.ə/）是一個自由內容、公開編輯且多語言的網路百科全書協作計畫");
qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 0, true); // Force mask 0
writePng(toImage(qr, 10, 3), "unicode-mask0-QR.png");
qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 1, true); // Force mask 1
writePng(toImage(qr, 10, 3), "unicode-mask1-QR.png");
qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 5, true); // Force mask 5
writePng(toImage(qr, 10, 3), "unicode-mask5-QR.png");
qr = QrCode.encodeSegments(segs, QrCode.Ecc.MEDIUM, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 7, true); // Force mask 7
writePng(toImage(qr, 10, 3), "unicode-mask7-QR.png");
}
/*---- Utilities ----*/
private static BufferedImage toImage(QrCode qr, int scale, int border) {
return toImage(qr, scale, border, 0xFFFFFF, 0x000000);
}
/**
* Returns a raster image depicting the specified QR Code, with
* the specified module scale, border modules, and module colors.
* <p>For example, scale=10 and border=4 means to pad the QR Code with 4 light border
* modules on all four sides, and use 10&#xD7;10 pixels to represent each module.
* @param qr the QR Code to render (not {@code null})
* @param scale the side length (measured in pixels, must be positive) of each module
* @param border the number of border modules to add, which must be non-negative
* @param lightColor the color to use for light modules, in 0xRRGGBB format
* @param darkColor the color to use for dark modules, in 0xRRGGBB format
* @return a new image representing the QR Code, with padding and scaling
* @throws NullPointerException if the QR Code is {@code null}
* @throws IllegalArgumentException if the scale or border is out of range, or if
* {scale, border, size} cause the image dimensions to exceed Integer.MAX_VALUE
*/
private static BufferedImage toImage(QrCode qr, int scale, int border, int lightColor, int darkColor) {
Objects.requireNonNull(qr);
if (scale <= 0 || border < 0)
throw new IllegalArgumentException("Value out of range");
if (border > Integer.MAX_VALUE / 2 || qr.size + border * 2L > Integer.MAX_VALUE / scale)
throw new IllegalArgumentException("Scale or border too large");
BufferedImage result = new BufferedImage((qr.size + border * 2) * scale, (qr.size + border * 2) * scale, BufferedImage.TYPE_INT_RGB);
for (int y = 0; y < result.getHeight(); y++) {
for (int x = 0; x < result.getWidth(); x++) {
boolean color = qr.getModule(x / scale - border, y / scale - border);
result.setRGB(x, y, color ? darkColor : lightColor);
}
}
return result;
}
// Helper function to reduce code duplication.
private static void writePng(BufferedImage img, String filepath) throws IOException {
ImageIO.write(img, "png", new File(filepath));
}
/**
* Returns a string of SVG code for an image depicting the specified QR Code, with the specified
* number of border modules. The string always uses Unix newlines (\n), regardless of the platform.
* @param qr the QR Code to render (not {@code null})
* @param border the number of border modules to add, which must be non-negative
* @param lightColor the color to use for light modules, in any format supported by CSS, not {@code null}
* @param darkColor the color to use for dark modules, in any format supported by CSS, not {@code null}
* @return a string representing the QR Code as an SVG XML document
* @throws NullPointerException if any object is {@code null}
* @throws IllegalArgumentException if the border is negative
*/
private static String toSvgString(QrCode qr, int border, String lightColor, String darkColor) {
Objects.requireNonNull(qr);
Objects.requireNonNull(lightColor);
Objects.requireNonNull(darkColor);
if (border < 0)
throw new IllegalArgumentException("Border must be non-negative");
long brd = border;
StringBuilder sb = new StringBuilder()
.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
.append("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n")
.append(String.format("<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 %1$d %1$d\" stroke=\"none\">\n",
qr.size + brd * 2))
.append("\t<rect width=\"100%\" height=\"100%\" fill=\"" + lightColor + "\"/>\n")
.append("\t<path d=\"");
for (int y = 0; y < qr.size; y++) {
for (int x = 0; x < qr.size; x++) {
if (qr.getModule(x, y)) {
if (x != 0 || y != 0)
sb.append(" ");
sb.append(String.format("M%d,%dh1v1h-1z", x + brd, y + brd));
}
}
}
return sb
.append("\" fill=\"" + darkColor + "\"/>\n")
.append("</svg>\n")
.toString();
}
}

338
java-fast/io/nayuki/fastqrcodegen/QrSegment.java Normal file
View File

@ -0,0 +1,338 @@
/*
* Fast QR Code generator library
*
* Copyright (c) Project Nayuki. (MIT License)
* https://www.nayuki.io/page/fast-qr-code-generator-library
*
* 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.
*/
package io.nayuki.fastqrcodegen;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
/**
* A segment of character/binary/control data in a QR Code symbol.
* Instances of this class are immutable.
* <p>The mid-level way to create a segment is to take the payload data and call a
* static factory function such as {@link QrSegment#makeNumeric(String)}. The low-level
* way to create a segment is to custom-make the bit buffer and call the {@link
* QrSegment#QrSegment(Mode,int,int[],int) constructor} with appropriate values.</p>
* <p>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.
* This class can represent kanji mode segments, but provides no help in encoding them
* - see {@link QrSegmentAdvanced} for full kanji support.</p>
*/
public final class QrSegment {
/*---- Static factory functions (mid level) ----*/
/**
* Returns a segment representing the specified binary data
* encoded in byte mode. All input byte arrays are acceptable.
* <p>Any text string can be converted to UTF-8 bytes ({@code
* s.getBytes(StandardCharsets.UTF_8)}) and encoded as a byte mode segment.</p>
* @param data the binary data (not {@code null})
* @return a segment (not {@code null}) containing the data
* @throws NullPointerException if the array is {@code null}
*/
public static QrSegment makeBytes(byte[] data) {
Objects.requireNonNull(data);
if (data.length * 8L > Integer.MAX_VALUE)
throw new IllegalArgumentException("Data too long");
int[] bits = new int[(data.length + 3) / 4];
for (int i = 0; i < data.length; i++)
bits[i >>> 2] |= (data[i] & 0xFF) << (~i << 3);
return new QrSegment(Mode.BYTE, data.length, bits, data.length * 8);
}
/**
* Returns a segment representing the specified string of decimal digits encoded in numeric mode.
* @param digits the text (not {@code null}), with only digits from 0 to 9 allowed
* @return a segment (not {@code null}) containing the text
* @throws NullPointerException if the string is {@code null}
* @throws IllegalArgumentException if the string contains non-digit characters
*/
public static QrSegment makeNumeric(String digits) {
Objects.requireNonNull(digits);
BitBuffer bb = new BitBuffer();
int accumData = 0;
int accumCount = 0;
for (int i = 0; i < digits.length(); i++) {
char c = digits.charAt(i);
if (c < '0' || c > '9')
throw new IllegalArgumentException("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 new QrSegment(Mode.NUMERIC, digits.length(), bb.data, bb.bitLength);
}
/**
* Returns a segment representing the specified 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.
* @param text the text (not {@code null}), with only certain characters allowed
* @return a segment (not {@code null}) containing the text
* @throws NullPointerException if the string is {@code null}
* @throws IllegalArgumentException if the string contains non-encodable characters
*/
public static QrSegment makeAlphanumeric(String text) {
Objects.requireNonNull(text);
BitBuffer bb = new BitBuffer();
int accumData = 0;
int accumCount = 0;
for (int i = 0; i < text.length(); i++) {
char c = text.charAt(i);
if (c >= ALPHANUMERIC_MAP.length || ALPHANUMERIC_MAP[c] == -1)
throw new IllegalArgumentException("String contains unencodable characters in alphanumeric mode");
accumData = accumData * 45 + ALPHANUMERIC_MAP[c];
accumCount++;
if (accumCount == 2) {
bb.appendBits(accumData, 11);
accumData = 0;
accumCount = 0;
}
}
if (accumCount > 0) // 1 character remaining
bb.appendBits(accumData, 6);
return new QrSegment(Mode.ALPHANUMERIC, text.length(), bb.data, bb.bitLength);
}
/**
* Returns a list of zero or more segments to represent the specified Unicode text string.
* The result may use various segment modes and switch modes to optimize the length of the bit stream.
* @param text the text to be encoded, which can be any Unicode string
* @return a new mutable list (not {@code null}) of segments (not {@code null}) containing the text
* @throws NullPointerException if the text is {@code null}
*/
public static List<QrSegment> makeSegments(String text) {
Objects.requireNonNull(text);
// Select the most efficient segment encoding automatically
List<QrSegment> result = new ArrayList<>();
if (text.equals("")); // Leave result empty
else if (isNumeric(text))
result.add(makeNumeric(text));
else if (isAlphanumeric(text))
result.add(makeAlphanumeric(text));
else
result.add(makeBytes(text.getBytes(StandardCharsets.UTF_8)));
return result;
}
/**
* Returns a segment representing an Extended Channel Interpretation
* (ECI) designator with the specified assignment value.
* @param assignVal the ECI assignment number (see the AIM ECI specification)
* @return a segment (not {@code null}) containing the data
* @throws IllegalArgumentException if the value is outside the range [0, 10<sup>6</sup>)
*/
public static QrSegment makeEci(int assignVal) {
BitBuffer bb = new BitBuffer();
if (assignVal < 0)
throw new IllegalArgumentException("ECI assignment value out of range");
else if (assignVal < (1 << 7))
bb.appendBits(assignVal, 8);
else if (assignVal < (1 << 14)) {
bb.appendBits(2, 2);
bb.appendBits(assignVal, 14);
} else if (assignVal < 1_000_000) {
bb.appendBits(6, 3);
bb.appendBits(assignVal, 21);
} else
throw new IllegalArgumentException("ECI assignment value out of range");
return new QrSegment(Mode.ECI, 0, bb.data, bb.bitLength);
}
/**
* Tests whether the specified string can be encoded as a segment in numeric mode.
* A string is encodable iff each character is in the range 0 to 9.
* @param text the string to test for encodability (not {@code null})
* @return {@code true} iff each character is in the range 0 to 9.
* @throws NullPointerException if the string is {@code null}
* @see #makeNumeric(String)
*/
public static boolean isNumeric(String text) {
for (int i = 0; i < text.length(); i++) {
char c = text.charAt(i);
if (c < '0' || c > '9')
return false;
}
return true;
}
/**
* Tests whether the specified string can be encoded as a segment in alphanumeric mode.
* A string is encodable iff each character is in the following set: 0 to 9, A to Z
* (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
* @param text the string to test for encodability (not {@code null})
* @return {@code true} iff each character is in the alphanumeric mode character set
* @throws NullPointerException if the string is {@code null}
* @see #makeAlphanumeric(String)
*/
public static boolean isAlphanumeric(String text) {
for (int i = 0; i < text.length(); i++) {
char c = text.charAt(i);
if (c >= ALPHANUMERIC_MAP.length || ALPHANUMERIC_MAP[c] == -1)
return false;
}
return true;
}
/*---- Instance fields ----*/
/** The mode indicator of this segment. Not {@code null}. */
public final Mode mode;
/** The length of this segment's unencoded data. Measured in characters for
* numeric/alphanumeric/kanji mode, bytes for byte mode, and 0 for ECI mode.
* Always zero or positive. Not the same as the data's bit length. */
public final int numChars;
// The data bits of this segment. Not null.
final int[] data;
// Requires 0 <= bitLength <= data.length * 32.
final int bitLength;
/*---- Constructor (low level) ----*/
/**
* Constructs a QR Code segment with the specified attributes and data.
* The character count (numCh) must agree with the mode and the bit buffer length,
* but the constraint isn't checked. The specified bit buffer is cloned and stored.
* @param md the mode (not {@code null})
* @param numCh the data length in characters or bytes, which is non-negative
* @param data the data bits (not {@code null})
* @param bitLen the number of valid prefix bits in the data array
* @throws NullPointerException if the mode or data is {@code null}
* @throws IllegalArgumentException if the character count is negative
*/
public QrSegment(Mode md, int numCh, int[] data, int bitLen) {
mode = Objects.requireNonNull(md);
this.data = Objects.requireNonNull(data);
if (numCh < 0 || bitLen < 0 || bitLen > data.length * 32L)
throw new IllegalArgumentException("Invalid value");
numChars = numCh;
bitLength = bitLen;
}
// Calculates the number of bits needed to encode the given segments at the given version.
// Returns a non-negative number if successful. Otherwise returns -1 if a segment has too
// many characters to fit its length field, or the total bits exceeds Integer.MAX_VALUE.
static int getTotalBits(List<QrSegment> segs, int version) {
Objects.requireNonNull(segs);
long result = 0;
for (QrSegment seg : segs) {
Objects.requireNonNull(seg);
int ccbits = seg.mode.numCharCountBits(version);
if (seg.numChars >= (1 << ccbits))
return -1; // The segment's length doesn't fit the field's bit width
result += 4L + ccbits + seg.bitLength;
if (result > Integer.MAX_VALUE)
return -1; // The sum will overflow an int type
}
return (int)result;
}
/*---- Constants ----*/
static final int[] ALPHANUMERIC_MAP;
static {
final String ALPHANUMERIC_CHARSET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
int maxCh = -1;
for (int i = 0; i < ALPHANUMERIC_CHARSET.length(); i++)
maxCh = Math.max(ALPHANUMERIC_CHARSET.charAt(i), maxCh);
ALPHANUMERIC_MAP = new int[maxCh + 1];
Arrays.fill(ALPHANUMERIC_MAP, -1);
for (int i = 0; i < ALPHANUMERIC_CHARSET.length(); i++)
ALPHANUMERIC_MAP[ALPHANUMERIC_CHARSET.charAt(i)] = i;
}
/*---- Public helper enumeration ----*/
/**
* Describes how a segment's data bits are interpreted.
*/
public enum Mode {
/*-- Constants --*/
NUMERIC (0x1, 10, 12, 14),
ALPHANUMERIC(0x2, 9, 11, 13),
BYTE (0x4, 8, 16, 16),
KANJI (0x8, 8, 10, 12),
ECI (0x7, 0, 0, 0);
/*-- Fields --*/
// The mode indicator bits, which is a uint4 value (range 0 to 15).
final int modeBits;
// Number of character count bits for three different version ranges.
private final int[] numBitsCharCount;
/*-- Constructor --*/
private Mode(int mode, int... ccbits) {
modeBits = mode;
numBitsCharCount = ccbits;
}
/*-- Method --*/
// Returns the bit width of the character count field for a segment in this mode
// in a QR Code at the given version number. The result is in the range [0, 16].
int numCharCountBits(int ver) {
assert QrCode.MIN_VERSION <= ver && ver <= QrCode.MAX_VERSION;
return numBitsCharCount[(ver + 7) / 17];
}
}
}

424
java-fast/io/nayuki/fastqrcodegen/QrSegmentAdvanced.java Normal file
View File

@ -0,0 +1,424 @@
/*
* Fast QR Code generator library
*
* Copyright (c) Project Nayuki. (MIT License)
* https://www.nayuki.io/page/fast-qr-code-generator-library
*
* 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.
*/
package io.nayuki.fastqrcodegen;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Base64;
import java.util.List;
import java.util.Objects;
import io.nayuki.fastqrcodegen.QrSegment.Mode;
/**
* Splits text into optimal segments and encodes kanji segments.
* Provides static functions only; not instantiable.
* @see QrSegment
* @see QrCode
*/
public final class QrSegmentAdvanced {
/*---- Optimal list of segments encoder ----*/
/**
* Returns a list of zero or more segments to represent the specified Unicode text string.
* The resulting list optimally minimizes the total encoded bit length, subjected to the constraints
* in the specified {error correction level, minimum version number, maximum version number}.
* <p>This function can utilize all four text encoding modes: numeric, alphanumeric, byte (UTF-8),
* and kanji. This can be considered as a sophisticated but slower replacement for {@link
* QrSegment#makeSegments(String)}. This requires more input parameters because it searches a
* range of versions, like {@link QrCode#encodeSegments(List,QrCode.Ecc,int,int,int,boolean)}.</p>
* @param text the text to be encoded (not {@code null}), which can be any Unicode string
* @param ecl the error correction level to use (not {@code null})
* @param minVersion the minimum allowed version of the QR Code (at least 1)
* @param maxVersion the maximum allowed version of the QR Code (at most 40)
* @return a new mutable list (not {@code null}) of segments (not {@code null})
* containing the text, minimizing the bit length with respect to the constraints
* @throws NullPointerException if the text or error correction level is {@code null}
* @throws IllegalArgumentException if 1 &#x2264; minVersion &#x2264; maxVersion &#x2264; 40 is violated
* @throws DataTooLongException if the text fails to fit in the maxVersion QR Code at the ECL
*/
public static List<QrSegment> makeSegmentsOptimally(String text, QrCode.Ecc ecl, int minVersion, int maxVersion) {
// Check arguments
Objects.requireNonNull(text);
Objects.requireNonNull(ecl);
if (!(QrCode.MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= QrCode.MAX_VERSION))
throw new IllegalArgumentException("Invalid value");
// Iterate through version numbers, and make tentative segments
List<QrSegment> segs = null;
int[] codePoints = toCodePoints(text);
for (int version = minVersion; ; version++) {
if (version == minVersion || version == 10 || version == 27)
segs = makeSegmentsOptimally(codePoints, version);
assert segs != null;
// Check if the segments fit
int dataCapacityBits = QrCode.getNumDataCodewords(version, ecl) * 8; // Number of data bits available
int dataUsedBits = QrSegment.getTotalBits(segs, version);
if (dataUsedBits != -1 && dataUsedBits <= dataCapacityBits)
return segs; // This version number is found to be suitable
if (version >= maxVersion) { // All versions in the range could not fit the given text
String msg = "Segment too long";
if (dataUsedBits != -1)
msg = String.format("Data length = %d bits, Max capacity = %d bits", dataUsedBits, dataCapacityBits);
throw new DataTooLongException(msg);
}
}
}
// Returns a new list of segments that is optimal for the given text at the given version number.
private static List<QrSegment> makeSegmentsOptimally(int[] codePoints, int version) {
if (codePoints.length == 0)
return new ArrayList<>();
Mode[] charModes = computeCharacterModes(codePoints, version);
return splitIntoSegments(codePoints, charModes);
}
// Returns a new array representing the optimal mode per code point based on the given text and version.
private static Mode[] computeCharacterModes(int[] codePoints, int version) {
if (codePoints.length == 0)
throw new IllegalArgumentException();
final Mode[] modeTypes = {Mode.BYTE, Mode.ALPHANUMERIC, Mode.NUMERIC, Mode.KANJI}; // Do not modify
final int numModes = modeTypes.length;
// Segment header sizes, measured in 1/6 bits
final int[] headCosts = new int[numModes];
for (int i = 0; i < numModes; i++)
headCosts[i] = (4 + modeTypes[i].numCharCountBits(version)) * 6;
// charModes[i][j] represents the mode to encode the code point at
// index i such that the final segment ends in modeTypes[j] and the
// total number of bits is minimized over all possible choices
Mode[][] charModes = new Mode[codePoints.length][numModes];
// At the beginning of each iteration of the loop below,
// prevCosts[j] is the exact minimum number of 1/6 bits needed to
// encode the entire string prefix of length i, and end in modeTypes[j]
int[] prevCosts = headCosts.clone();
// Calculate costs using dynamic programming
for (int i = 0; i < codePoints.length; i++) {
int c = codePoints[i];
int[] curCosts = new int[numModes];
{ // Always extend a byte mode segment
curCosts[0] = prevCosts[0] + countUtf8Bytes(c) * 8 * 6;
charModes[i][0] = modeTypes[0];
}
// Extend a segment if possible
if (QrSegment.ALPHANUMERIC_MAP[c] != -1) { // Is alphanumeric
curCosts[1] = prevCosts[1] + 33; // 5.5 bits per alphanumeric char
charModes[i][1] = modeTypes[1];
}
if ('0' <= c && c <= '9') { // Is numeric
curCosts[2] = prevCosts[2] + 20; // 3.33 bits per digit
charModes[i][2] = modeTypes[2];
}
if (isKanji(c)) {
curCosts[3] = prevCosts[3] + 78; // 13 bits per Shift JIS char
charModes[i][3] = modeTypes[3];
}
// Start new segment at the end to switch modes
for (int j = 0; j < numModes; j++) { // To mode
for (int k = 0; k < numModes; k++) { // From mode
int newCost = (curCosts[k] + 5) / 6 * 6 + headCosts[j];
if (charModes[i][k] != null && (charModes[i][j] == null || newCost < curCosts[j])) {
curCosts[j] = newCost;
charModes[i][j] = modeTypes[k];
}
}
}
prevCosts = curCosts;
}
// Find optimal ending mode
Mode curMode = null;
for (int i = 0, minCost = 0; i < numModes; i++) {
if (curMode == null || prevCosts[i] < minCost) {
minCost = prevCosts[i];
curMode = modeTypes[i];
}
}
// Get optimal mode for each code point by tracing backwards
Mode[] result = new Mode[charModes.length];
for (int i = result.length - 1; i >= 0; i--) {
for (int j = 0; j < numModes; j++) {
if (modeTypes[j] == curMode) {
curMode = charModes[i][j];
result[i] = curMode;
break;
}
}
}
return result;
}
// Returns a new list of segments based on the given text and modes, such that
// consecutive code points in the same mode are put into the same segment.
private static List<QrSegment> splitIntoSegments(int[] codePoints, Mode[] charModes) {
if (codePoints.length == 0)
throw new IllegalArgumentException();
List<QrSegment> result = new ArrayList<>();
// Accumulate run of modes
Mode curMode = charModes[0];
int start = 0;
for (int i = 1; ; i++) {
if (i < codePoints.length && charModes[i] == curMode)
continue;
String s = new String(codePoints, start, i - start);
if (curMode == Mode.BYTE)
result.add(QrSegment.makeBytes(s.getBytes(StandardCharsets.UTF_8)));
else if (curMode == Mode.NUMERIC)
result.add(QrSegment.makeNumeric(s));
else if (curMode == Mode.ALPHANUMERIC)
result.add(QrSegment.makeAlphanumeric(s));
else if (curMode == Mode.KANJI)
result.add(makeKanji(s));
else
throw new AssertionError();
if (i >= codePoints.length)
return result;
curMode = charModes[i];
start = i;
}
}
// Returns a new array of Unicode code points (effectively
// UTF-32 / UCS-4) representing the given UTF-16 string.
private static int[] toCodePoints(String s) {
int[] result = s.codePoints().toArray();
for (int c : result) {
if (Character.isSurrogate((char)c))
throw new IllegalArgumentException("Invalid UTF-16 string");
}
return result;
}
// Returns the number of UTF-8 bytes needed to encode the given Unicode code point.
private static int countUtf8Bytes(int cp) {
if (cp < 0) throw new IllegalArgumentException("Invalid code point");
else if (cp < 0x80) return 1;
else if (cp < 0x800) return 2;
else if (cp < 0x10000) return 3;
else if (cp < 0x110000) return 4;
else throw new IllegalArgumentException("Invalid code point");
}
/*---- Kanji mode segment encoder ----*/
/**
* Returns a segment representing the specified text string encoded in kanji mode.
* Broadly speaking, the set of encodable characters are {kanji used in Japan,
* hiragana, katakana, East Asian punctuation, full-width ASCII, Greek, Cyrillic}.
* Examples of non-encodable characters include {ordinary ASCII, half-width katakana,
* more extensive Chinese hanzi}.
* @param text the text (not {@code null}), with only certain characters allowed
* @return a segment (not {@code null}) containing the text
* @throws NullPointerException if the string is {@code null}
* @throws IllegalArgumentException if the string contains non-encodable characters
* @see #isEncodableAsKanji(String)
*/
public static QrSegment makeKanji(String text) {
Objects.requireNonNull(text);
BitBuffer bb = new BitBuffer();
text.chars().forEachOrdered(c -> {
int val = UNICODE_TO_QR_KANJI[c];
if (val == -1)
throw new IllegalArgumentException("String contains non-kanji-mode characters");
bb.appendBits(val, 13);
});
return new QrSegment(Mode.KANJI, text.length(), bb.data, bb.bitLength);
}
/**
* Tests whether the specified string can be encoded as a segment in kanji mode.
* Broadly speaking, the set of encodable characters are {kanji used in Japan,
* hiragana, katakana, East Asian punctuation, full-width ASCII, Greek, Cyrillic}.
* Examples of non-encodable characters include {ordinary ASCII, half-width katakana,
* more extensive Chinese hanzi}.
* @param text the string to test for encodability (not {@code null})
* @return {@code true} iff each character is in the kanji mode character set
* @throws NullPointerException if the string is {@code null}
* @see #makeKanji(String)
*/
public static boolean isEncodableAsKanji(String text) {
Objects.requireNonNull(text);
return text.chars().allMatch(
c -> isKanji((char)c));
}
private static boolean isKanji(int c) {
return c < UNICODE_TO_QR_KANJI.length && UNICODE_TO_QR_KANJI[c] != -1;
}
// Data derived from ftp://ftp.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/JIS/SHIFTJIS.TXT
private static final String PACKED_QR_KANJI_TO_UNICODE =
"MAAwATAC/wz/DjD7/xr/G/8f/wEwmzCcALT/QACo/z7/4/8/MP0w/jCdMJ4wA07dMAUwBjAHMPwgFSAQ/w8AXDAcIBb/XCAmICUgGCAZIBwgHf8I/wkwFDAV/zv/Pf9b/10wCDAJMAowCzAMMA0wDjAPMBAwEf8LIhIAsQDX//8A9/8dImD/HP8eImYiZyIeIjQmQiZA" +
"ALAgMiAzIQP/5f8EAKIAo/8F/wP/Bv8K/yAApyYGJgUlyyXPJc4lxyXGJaEloCWzJbIlvSW8IDswEiGSIZAhkSGTMBP/////////////////////////////IggiCyKGIocigiKDIioiKf////////////////////8iJyIoAKwh0iHUIgAiA///////////////////" +
"//////////8iICKlIxIiAiIHImEiUiJqImsiGiI9Ih0iNSIrIiz//////////////////yErIDAmbyZtJmogICAhALb//////////yXv/////////////////////////////////////////////////xD/Ef8S/xP/FP8V/xb/F/8Y/xn///////////////////8h" +
"/yL/I/8k/yX/Jv8n/yj/Kf8q/yv/LP8t/y7/L/8w/zH/Mv8z/zT/Nf82/zf/OP85/zr///////////////////9B/0L/Q/9E/0X/Rv9H/0j/Sf9K/0v/TP9N/07/T/9Q/1H/Uv9T/1T/Vf9W/1f/WP9Z/1r//////////zBBMEIwQzBEMEUwRjBHMEgwSTBKMEswTDBN" +
"ME4wTzBQMFEwUjBTMFQwVTBWMFcwWDBZMFowWzBcMF0wXjBfMGAwYTBiMGMwZDBlMGYwZzBoMGkwajBrMGwwbTBuMG8wcDBxMHIwczB0MHUwdjB3MHgweTB6MHswfDB9MH4wfzCAMIEwgjCDMIQwhTCGMIcwiDCJMIowizCMMI0wjjCPMJAwkTCSMJP/////////////" +
"////////////////////////MKEwojCjMKQwpTCmMKcwqDCpMKowqzCsMK0wrjCvMLAwsTCyMLMwtDC1MLYwtzC4MLkwujC7MLwwvTC+ML8wwDDBMMIwwzDEMMUwxjDHMMgwyTDKMMswzDDNMM4wzzDQMNEw0jDTMNQw1TDWMNcw2DDZMNow2zDcMN0w3jDf//8w4DDh" +
"MOIw4zDkMOUw5jDnMOgw6TDqMOsw7DDtMO4w7zDwMPEw8jDzMPQw9TD2/////////////////////wORA5IDkwOUA5UDlgOXA5gDmQOaA5sDnAOdA54DnwOgA6EDowOkA6UDpgOnA6gDqf////////////////////8DsQOyA7MDtAO1A7YDtwO4A7kDugO7A7wDvQO+" +
"A78DwAPBA8MDxAPFA8YDxwPIA8n/////////////////////////////////////////////////////////////////////////////////////////////////////////////BBAEEQQSBBMEFAQVBAEEFgQXBBgEGQQaBBsEHAQdBB4EHwQgBCEEIgQjBCQEJQQm" +
"BCcEKAQpBCoEKwQsBC0ELgQv////////////////////////////////////////BDAEMQQyBDMENAQ1BFEENgQ3BDgEOQQ6BDsEPAQ9//8EPgQ/BEAEQQRCBEMERARFBEYERwRIBEkESgRLBEwETQROBE///////////////////////////////////yUAJQIlDCUQ" +
"JRglFCUcJSwlJCU0JTwlASUDJQ8lEyUbJRclIyUzJSslOyVLJSAlLyUoJTclPyUdJTAlJSU4JUL/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
"/////////////////////////////////////06cVRZaA5Y/VMBhG2MoWfaQIoR1gxx6UGCqY+FuJWXthGaCppv1aJNXJ2WhYnFbm1nQhnuY9H1ifb6bjmIWfJ+It1uJXrVjCWaXaEiVx5eNZ09O5U8KT01PnVBJVvJZN1nUWgFcCWDfYQ9hcGYTaQVwunVPdXB5+32t" +
"fe+Aw4QOiGOLApBVkHpTO06VTqVX34CykMF4704AWPFuopA4ejKDKIKLnC9RQVNwVL1U4VbgWftfFZjybeuA5IUt////////lmKWcJagl/tUC1PzW4dwz3+9j8KW6FNvnVx6uk4ReJOB/G4mVhhVBGsdhRqcO1nlU6ltZnTclY9WQk6RkEuW8oNPmQxT4VW2WzBfcWYg" +
"ZvNoBGw4bPNtKXRbdsh6Tpg0gvGIW4pgku1tsnWrdsqZxWCmiwGNipWyaY5TrVGG//9XElgwWURbtF72YChjqWP0bL9vFHCOcRRxWXHVcz9+AYJ2gtGFl5BgkludG1hpZbxsWnUlUflZLlllX4Bf3GK8ZfpqKmsna7Rzi3/BiVadLJ0OnsRcoWyWg3tRBFxLYbaBxmh2" +
"cmFOWU/6U3hgaW4pek+X804LUxZO7k9VTz1PoU9zUqBT71YJWQ9awVu2W+F50WaHZ5xntmtMbLNwa3PCeY15vno8e4eCsYLbgwSDd4Pvg9OHZoqyVimMqI/mkE6XHoaKT8Rc6GIRcll1O4Hlgr2G/ozAlsWZE5nVTstPGonjVt5YSljKXvtf62AqYJRgYmHQYhJi0GU5" +
"////////m0FmZmiwbXdwcHVMdoZ9dYKlh/mVi5aOjJ1R8VK+WRZUs1uzXRZhaGmCba94jYTLiFeKcpOnmrhtbJmohtlXo2f/hs6SDlKDVodUBF7TYuFkuWg8aDhru3NyeLp6a4maidKNa48DkO2Vo5aUl2lbZlyzaX2YTZhOY5t7IGor//9qf2i2nA1vX1JyVZ1gcGLs" +
"bTtuB27RhFuJEI9EThScOVP2aRtqOpeEaCpRXHrDhLKR3JOMVludKGgigwWEMXylUgiCxXTmTn5Pg1GgW9JSClLYUudd+1WaWCpZ5luMW5hb215yXnlgo2EfYWNhvmPbZWJn0WhTaPprPmtTbFdvIm+Xb0V0sHUYduN3C3r/e6F8IX3pfzZ/8ICdgmaDnomzisyMq5CE" +
"lFGVk5WRlaKWZZfTmSiCGE44VCtcuF3Mc6l2THc8XKl/640LlsGYEZhUmFhPAU8OU3FVnFZoV/pZR1sJW8RckF4MXn5fzGPuZzpl12XiZx9oy2jE////////al9eMGvFbBdsfXV/eUhbY3oAfQBfvYmPihiMtI13jsyPHZjimg6bPE6AUH1RAFmTW5xiL2KAZOxrOnKg" +
"dZF5R3+ph/uKvItwY6yDypegVAlUA1WraFRqWIpweCdndZ7NU3RbooEahlCQBk4YTkVOx08RU8pUOFuuXxNgJWVR//9nPWxCbHJs43B4dAN6dnquewh9Gnz+fWZl53JbU7tcRV3oYtJi4GMZbiCGWooxjd2S+G8BeaabWk6oTqtOrE+bT6BQ0VFHevZRcVH2U1RTIVN/" +
"U+tVrFiDXOFfN19KYC9gUGBtYx9lWWpLbMFywnLtd++A+IEFggiFTpD3k+GX/5lXmlpO8FHdXC1mgWltXEBm8ml1c4loUHyBUMVS5FdHXf6TJmWkayNrPXQ0eYF5vXtLfcqCuYPMiH+JX4s5j9GR0VQfkoBOXVA2U+VTOnLXc5Z36YLmjq+ZxpnImdJRd2Eahl5VsHp6" +
"UHZb05BHloVOMmrbkedcUVxI////////Y5h6n2yTl3SPYXqqcYqWiHyCaBd+cGhRk2xS8lQbhauKE3+kjs2Q4VNmiIh5QU/CUL5SEVFEVVNXLXPqV4tZUV9iX4RgdWF2YWdhqWOyZDplbGZvaEJuE3Vmej18+31MfZl+S39rgw6DSobNigiKY4tmjv2YGp2PgriPzpvo" +
"//9Sh2IfZINvwJaZaEFQkWsgbHpvVHp0fVCIQIojZwhO9lA5UCZQZVF8UjhSY1WnVw9YBVrMXvphsmH4YvNjcmkcailyfXKscy54FHhvfXl3DICpiYuLGYzijtKQY5N1lnqYVZoTnnhRQ1OfU7Nee18mbhtukHOEc/59Q4I3igCK+pZQTk5QC1PkVHxW+lnRW2Rd8V6r" +
"XydiOGVFZ69uVnLQfMqItIChgOGD8IZOioeN6JI3lseYZ58TTpROkk8NU0hUSVQ+Wi9fjF+hYJ9op2qOdFp4gYqeiqSLd5GQTl6byU6kT3xPr1AZUBZRSVFsUp9SuVL+U5pT41QR////////VA5ViVdRV6JZfVtUW11bj13lXedd9154XoNeml63XxhgUmFMYpdi2GOn" +
"ZTtmAmZDZvRnbWghaJdpy2xfbSptaW4vbp11MnaHeGx6P3zgfQV9GH1efbGAFYADgK+AsYFUgY+CKoNSiEyIYYsbjKKM/JDKkXWScXg/kvyVpJZN//+YBZmZmtidO1JbUqtT91QIWNVi92/gjGqPX565UUtSO1RKVv16QJF3nWCe0nNEbwmBcHURX/1g2pqoctuPvGtk" +
"mANOylbwV2RYvlpaYGhhx2YPZgZoOWixbfd11X06gm6bQk6bT1BTyVUGXW9d5l3uZ/tsmXRzeAKKUJOWiN9XUF6nYytQtVCsUY1nAFTJWF5Zu1uwX2liTWOhaD1rc24IcH2Rx3KAeBV4JnltZY59MIPciMGPCZabUmRXKGdQf2qMoVG0V0KWKlg6aYqAtFSyXQ5X/HiV" +
"nfpPXFJKVItkPmYoZxRn9XqEe1Z9IpMvaFybrXs5UxlRilI3////////W99i9mSuZOZnLWu6hamW0XaQm9ZjTJMGm6t2v2ZSTglQmFPCXHFg6GSSZWNoX3Hmc8p1I3uXfoKGlYuDjNuReJkQZaxmq2uLTtVO1E86T39SOlP4U/JV41bbWOtZy1nJWf9bUFxNXgJeK1/X" +
"YB1jB2UvW1xlr2W9ZehnnWti//9re2wPc0V5SXnBfPh9GX0rgKKBAoHziZaKXoppimaKjIrujMeM3JbMmPxrb06LTzxPjVFQW1db+mFIYwFmQmshbstsu3I+dL111HjBeTqADIAzgeqElI+ebFCef18Pi1idK3r6jvhbjZbrTgNT8Vf3WTFayVukYIluf28Gdb6M6luf" +
"hQB74FByZ/SCnVxhhUp+HoIOUZlcBGNojWZlnHFueT59F4AFix2OypBuhseQqlAfUvpcOmdTcHxyNZFMkciTK4LlW8JfMWD5TjtT1luIYktnMWuKculz4HougWuNo5FSmZZRElPXVGpb/2OIajl9rJcAVtpTzlRo////////W5dcMV3eT+5hAWL+bTJ5wHnLfUJ+TX/S" +
"ge2CH4SQiEaJcouQjnSPL5AxkUuRbJbGkZxOwE9PUUVTQV+TYg5n1GxBbgtzY34mkc2Sg1PUWRlbv23ReV1+LnybWH5xn1H6iFOP8E/KXPtmJXeseuOCHJn/UcZfqmXsaW9riW3z//9ulm9kdv59FF3hkHWRh5gGUeZSHWJAZpFm2W4aXrZ90n9yZviFr4X3ivhSqVPZ" +
"WXNej1+QYFWS5JZkULdRH1LdUyBTR1PsVOhVRlUxVhdZaFm+WjxbtVwGXA9cEVwaXoReil7gX3Bif2KEYttjjGN3ZgdmDGYtZnZnfmiiah9qNWy8bYhuCW5YcTxxJnFndcd3AXhdeQF5ZXnweuB7EXynfTmAloPWhIuFSYhdiPOKH4o8ilSKc4xhjN6RpJJmk36UGJac" +
"l5hOCk4ITh5OV1GXUnBXzlg0WMxbIl44YMVk/mdhZ1ZtRHK2dXN6Y4S4i3KRuJMgVjFX9Jj+////////Yu1pDWuWce1+VIB3gnKJ5pjfh1WPsVw7TzhP4U+1VQdaIFvdW+lfw2FOYy9lsGZLaO5pm214bfF1M3W5dx95XnnmfTOB44KvhaqJqoo6jquPm5Aykd2XB066" +
"TsFSA1h1WOxcC3UaXD2BTooKj8WWY5dteyWKz5gIkWJW81Oo//+QF1Q5V4JeJWOobDRwindhfIt/4IhwkEKRVJMQkxiWj3RemsRdB11pZXBnoo2olttjbmdJaRmDxZgXlsCI/m+EZHpb+E4WcCx1XWYvUcRSNlLiWdNfgWAnYhBlP2V0Zh9mdGjyaBZrY24FcnJ1H3bb" +
"fL6AVljwiP2Jf4qgipOKy5AdkZKXUpdZZYl6DoEGlrteLWDcYhplpWYUZ5B383pNfE1+PoEKjKyNZI3hjl94qVIHYtljpWRCYpiKLXqDe8CKrJbqfXaCDIdJTtlRSFNDU2Bbo1wCXBZd3WImYkdksGgTaDRsyW1FbRdn029ccU5xfWXLen97rX3a////////fkp/qIF6" +
"ghuCOYWmim6Mzo31kHiQd5KtkpGVg5uuUk1VhG84cTZRaHmFflWBs3zOVkxYUVyoY6pm/mb9aVpy2XWPdY55DnlWed98l30gfUSGB4o0ljuQYZ8gUOdSdVPMU+JQCVWqWO5ZT3I9W4tcZFMdYONg82NcY4NjP2O7//9kzWXpZvld42nNaf1vFXHlTol16Xb4epN8333P" +
"fZyAYYNJg1iEbIS8hfuIxY1wkAGQbZOXlxyaElDPWJdhjoHThTWNCJAgT8NQdFJHU3Ngb2NJZ19uLI2zkB9P11xejMplz32aU1KIllF2Y8NbWFtrXApkDWdRkFxO1lkaWSpscIpRVT5YFVmlYPBiU2fBgjVpVZZAmcSaKE9TWAZb/oAQXLFeL1+FYCBhS2I0Zv9s8G7e" +
"gM6Bf4LUiIuMuJAAkC6Wip7bm9tO41PwWSd7LJGNmEyd+W7dcCdTU1VEW4ViWGKeYtNsom/vdCKKF5Q4b8GK/oM4UeeG+FPq////////U+lPRpBUj7BZaoExXf166o+/aNqMN3L4nEhqPYqwTjlTWFYGV2ZixWOiZeZrTm3hbltwrXfteu97qn27gD2AxobLipWTW1bj" +
"WMdfPmWtZpZqgGu1dTeKx1Akd+VXMF8bYGVmemxgdfR6Gn9ugfSHGJBFmbN7yXVcevl7UYTE//+QEHnpepKDNlrhd0BOLU7yW5lf4GK9Zjxn8WzohmuId4o7kU6S85nQahdwJnMqgueEV4yvTgFRRlHLVYtb9V4WXjNegV8UXzVfa1+0YfJjEWaiZx1vbnJSdTp3OoB0" +
"gTmBeId2ir+K3I2FjfOSmpV3mAKc5VLFY1d29GcVbIhzzYzDk66Wc20lWJxpDmnMj/2TmnXbkBpYWmgCY7Rp+09Dbyxn2I+7hSZ9tJNUaT9vcFdqWPdbLH0scipUCpHjnbROrU9OUFxQdVJDjJ5USFgkW5peHV6VXq1e918fYIxitWM6Y9Bor2xAeId5jnoLfeCCR4oC" +
"iuaORJAT////////kLiRLZHYnw5s5WRYZOJldW70doR7G5Bpk9FuulTyX7lkpI9Nj+2SRFF4WGtZKVxVXpdt+36PdRyMvI7imFtwuU8da79vsXUwlvtRTlQQWDVYV1msXGBfkmWXZ1xuIXZ7g9+M7ZAUkP2TTXgleDpSql6mVx9ZdGASUBJRWlGs//9RzVIAVRBYVFhY" +
"WVdblVz2XYtgvGKVZC1ncWhDaLxo33bXbdhub22bcG9xyF9Tddh5d3tJe1R7UnzWfXFSMIRjhWmF5IoOiwSMRo4PkAOQD5QZlnaYLZowldhQzVLVVAxYAlwOYadknm0ed7N65YD0hASQU5KFXOCdB1M/X5dfs22ccnl3Y3m/e+Rr0nLsiq1oA2phUfh6gWk0XEqc9oLr" +
"W8WRSXAeVnhcb2DHZWZsjIxakEGYE1RRZseSDVlIkKNRhU5NUeqFmYsOcFhjepNLaWKZtH4EdXdTV2lgjt+W42xdToxcPF8Qj+lTAozRgImGeV7/ZeVOc1Fl////////WYJcP5fuTvtZil/Nio1v4XmweWJb54RxcytxsV50X/Vje2SaccN8mE5DXvxOS1fcVqJgqW/D" +
"fQ2A/YEzgb+PsomXhqRd9GKKZK2Jh2d3bOJtPnQ2eDRaRn91gq2ZrE/zXsNi3WOSZVdnb3bDckyAzIC6jymRTVANV/lakmiF//9pc3Fkcv2Mt1jyjOCWapAZh3955HfnhClPL1JlU1pizWfPbMp2fXuUfJWCNoWEj+tm3W8gcgZ+G4OrmcGeplH9e7F4cnu4gId7SGro" +
"XmGAjHVRdWBRa5Jibox2epGXmupPEH9wYpx7T5WlnOlWelhZhuSWvE80UiRTSlPNU9teBmQsZZFnf2w+bE5ySHKvc+11VH5BgiyF6Yype8SRxnFpmBKY72M9Zml1anbkeNCFQ4buUypTUVQmWYNeh198YLJiSWJ5YqtlkGvUbMx1snaueJF52H3Lf3eApYirirmMu5B/" +
"l16Y22oLfDhQmVw+X65nh2vYdDV3CX+O////////nztnynoXUzl1i5rtX2aBnYPxgJhfPF/FdWJ7RpA8aGdZ61qbfRB2fossT/VfamoZbDdvAnTieWiIaIpVjHle32PPdcV50oLXkyiS8oSchu2cLVTBX2xljG1ccBWMp4zTmDtlT3T2Tg1O2FfgWStaZlvMUaheA16c" +
"YBZidmV3//9lp2ZubW5yNnsmgVCBmoKZi1yMoIzmjXSWHJZET65kq2tmgh6EYYVqkOhcAWlTmKiEeoVXTw9Sb1+pXkVnDXmPgXmJB4mGbfVfF2JVbLhOz3Jpm5JSBlQ7VnRYs2GkYm5xGllufIl83n0blvBlh4BeThlPdVF1WEBeY15zXwpnxE4mhT2ViZZbfHOYAVD7" +
"WMF2VninUiV3pYURe4ZQT1kJckd7x33oj7qP1JBNT79SyVopXwGXrU/dgheS6lcDY1VraXUriNyPFHpCUt9Yk2FVYgpmrmvNfD+D6VAjT/hTBVRGWDFZSVudXPBc710pXpZisWNnZT5luWcL////////bNVs4XD5eDJ+K4DegrOEDITshwKJEooqjEqQppLSmP2c851s" +
"Tk9OoVCNUlZXSlmoXj1f2F/ZYj9mtGcbZ9Bo0lGSfSGAqoGoiwCMjIy/kn6WMlQgmCxTF1DVU1xYqGSyZzRyZ3dmekaR5lLDbKFrhlgAXkxZVGcsf/tR4XbG//9kaXjom1Seu1fLWblmJ2eaa85U6WnZXlWBnGeVm6pn/pxSaF1Opk/jU8hiuWcrbKuPxE+tfm2ev04H" +
"YWJugG8rhRNUc2cqm0Vd83uVXKxbxoccbkqE0XoUgQhZmXyNbBF3IFLZWSJxIXJfd9uXJ51haQtaf1oYUaVUDVR9Zg5234/3kpic9Fnqcl1uxVFNaMl9v33sl2KeumR4aiGDAlmEW19r23MbdvJ9soAXhJlRMmcontl27mdiUv+ZBVwkYjt8foywVU9gtn0LlYBTAU5f" +
"UbZZHHI6gDaRzl8ld+JThF95fQSFrIozjo2XVmfzha6UU2EJYQhsuXZS////////iu2POFUvT1FRKlLHU8tbpV59YKBhgmPWZwln2m5nbYxzNnM3dTF5UIjVipiQSpCRkPWWxIeNWRVOiE9ZTg6KiY8/mBBQrV58WZZbuV64Y9pj+mTBZtxpSmnYbQtutnGUdSh6r3+K" +
"gACESYTJiYGLIY4KkGWWfZkKYX5ikWsy//9sg210f8x//G3Af4WHuoj4Z2WDsZg8lvdtG31hhD2Rak5xU3VdUGsEb+uFzYYtiadSKVQPXGVnTmiodAZ0g3XiiM+I4ZHMluKWeF+Lc4d6y4ROY6B1ZVKJbUFunHQJdVl4a3ySloZ63J+NT7ZhbmXFhlxOhk6uUNpOIVHM" +
"W+5lmWiBbbxzH3ZCd616HHzngm+K0pB8kc+WdZgYUpt90VArU5hnl23LcdB0M4HojyqWo5xXnp90YFhBbZl9L5heTuRPNk+LUbdSsV26YBxzsnk8gtOSNJa3lvaXCp6Xn2Jmpmt0UhdSo3DIiMJeyWBLYZBvI3FJfD599IBv////////hO6QI5MsVEKbb2rTcImMwo3v" +
"lzJStFpBXspfBGcXaXxplG1qbw9yYnL8e+2AAYB+h0uQzlFtnpN5hICLkzKK1lAtVIyKcWtqjMSBB2DRZ6Cd8k6ZTpicEIprhcGFaGkAbn54l4FV////////////////////////////////////////////////////////////////////////////////////////" +
"/////////////////////////////18MThBOFU4qTjFONk48Tj9OQk5WTlhOgk6FjGtOioISXw1Ojk6eTp9OoE6iTrBOs062Ts5OzU7ETsZOwk7XTt5O7U7fTvdPCU9aTzBPW09dT1dPR092T4hPj0+YT3tPaU9wT5FPb0+GT5ZRGE/UT99Pzk/YT9tP0U/aT9BP5E/l" +
"UBpQKFAUUCpQJVAFTxxP9lAhUClQLE/+T+9QEVAGUENQR2cDUFVQUFBIUFpQVlBsUHhQgFCaUIVQtFCy////////UMlQylCzUMJQ1lDeUOVQ7VDjUO5Q+VD1UQlRAVECURZRFVEUURpRIVE6UTdRPFE7UT9RQFFSUUxRVFFievhRaVFqUW5RgFGCVthRjFGJUY9RkVGT" +
"UZVRllGkUaZRolGpUapRq1GzUbFRslGwUbVRvVHFUclR21HghlVR6VHt//9R8FH1Uf5SBFILUhRSDlInUipSLlIzUjlST1JEUktSTFJeUlRSalJ0UmlSc1J/Un1SjVKUUpJScVKIUpGPqI+nUqxSrVK8UrVSwVLNUtdS3lLjUuaY7VLgUvNS9VL4UvlTBlMIdThTDVMQ" +
"Uw9TFVMaUyNTL1MxUzNTOFNAU0ZTRU4XU0lTTVHWU15TaVNuWRhTe1N3U4JTllOgU6ZTpVOuU7BTtlPDfBKW2VPfZvxx7lPuU+hT7VP6VAFUPVRAVCxULVQ8VC5UNlQpVB1UTlSPVHVUjlRfVHFUd1RwVJJUe1SAVHZUhFSQVIZUx1SiVLhUpVSsVMRUyFSo////////" +
"VKtUwlSkVL5UvFTYVOVU5lUPVRRU/VTuVO1U+lTiVTlVQFVjVUxVLlVcVUVVVlVXVThVM1VdVZlVgFSvVYpVn1V7VX5VmFWeVa5VfFWDValVh1WoVdpVxVXfVcRV3FXkVdRWFFX3VhZV/lX9VhtV+VZOVlBx31Y0VjZWMlY4//9Wa1ZkVi9WbFZqVoZWgFaKVqBWlFaP" +
"VqVWrla2VrRWwla8VsFWw1bAVshWzlbRVtNW11buVvlXAFb/VwRXCVcIVwtXDVcTVxhXFlXHVxxXJlc3VzhXTlc7V0BXT1dpV8BXiFdhV39XiVeTV6BXs1ekV6pXsFfDV8ZX1FfSV9NYClfWV+NYC1gZWB1YclghWGJYS1hwa8BYUlg9WHlYhVi5WJ9Yq1i6WN5Yu1i4" +
"WK5YxVjTWNFY11jZWNhY5VjcWORY31jvWPpY+Vj7WPxY/VkCWQpZEFkbaKZZJVksWS1ZMlk4WT560llVWVBZTllaWVhZYllgWWdZbFlp////////WXhZgVmdT15Pq1mjWbJZxlnoWdxZjVnZWdpaJVofWhFaHFoJWhpaQFpsWklaNVo2WmJaalqaWrxavlrLWsJavVrj" +
"Wtda5lrpWtZa+lr7WwxbC1sWWzJa0FsqWzZbPltDW0VbQFtRW1VbWltbW2VbaVtwW3NbdVt4ZYhbeluA//9bg1umW7hbw1vHW8lb1FvQW+Rb5lviW95b5VvrW/Bb9lvzXAVcB1wIXA1cE1wgXCJcKFw4XDlcQVxGXE5cU1xQXE9bcVxsXG5OYlx2XHlcjFyRXJRZm1yr" +
"XLtctly8XLdcxVy+XMdc2VzpXP1c+lztXYxc6l0LXRVdF11cXR9dG10RXRRdIl0aXRldGF1MXVJdTl1LXWxdc112XYddhF2CXaJdnV2sXa5dvV2QXbddvF3JXc1d013SXdZd213rXfJd9V4LXhpeGV4RXhteNl43XkReQ15AXk5eV15UXl9eYl5kXkdedV52XnqevF5/" +
"XqBewV7CXshe0F7P////////XtZe417dXtpe217iXuFe6F7pXuxe8V7zXvBe9F74Xv5fA18JX11fXF8LXxFfFl8pXy1fOF9BX0hfTF9OXy9fUV9WX1dfWV9hX21fc193X4Nfgl9/X4pfiF+RX4dfnl+ZX5hfoF+oX61fvF/WX/tf5F/4X/Ff3WCzX/9gIWBg//9gGWAQ" +
"YClgDmAxYBtgFWArYCZgD2A6YFpgQWBqYHdgX2BKYEZgTWBjYENgZGBCYGxga2BZYIFgjWDnYINgmmCEYJtglmCXYJJgp2CLYOFguGDgYNNgtF/wYL1gxmC1YNhhTWEVYQZg9mD3YQBg9GD6YQNhIWD7YPFhDWEOYUdhPmEoYSdhSmE/YTxhLGE0YT1hQmFEYXNhd2FY" +
"YVlhWmFrYXRhb2FlYXFhX2FdYVNhdWGZYZZhh2GsYZRhmmGKYZFhq2GuYcxhymHJYfdhyGHDYcZhumHLf3lhzWHmYeNh9mH6YfRh/2H9Yfxh/mIAYghiCWINYgxiFGIb////////Yh5iIWIqYi5iMGIyYjNiQWJOYl5iY2JbYmBiaGJ8YoJiiWJ+YpJik2KWYtRig2KU" +
"Ytdi0WK7Ys9i/2LGZNRiyGLcYsxiymLCYsdim2LJYwxi7mLxYydjAmMIYu9i9WNQYz5jTWQcY09jlmOOY4Bjq2N2Y6Njj2OJY59jtWNr//9jaWO+Y+ljwGPGY+NjyWPSY/ZjxGQWZDRkBmQTZCZkNmUdZBdkKGQPZGdkb2R2ZE5lKmSVZJNkpWSpZIhkvGTaZNJkxWTH" +
"ZLtk2GTCZPFk54IJZOBk4WKsZONk72UsZPZk9GTyZPplAGT9ZRhlHGUFZSRlI2UrZTRlNWU3ZTZlOHVLZUhlVmVVZU1lWGVeZV1lcmV4ZYJlg4uKZZtln2WrZbdlw2XGZcFlxGXMZdJl22XZZeBl4WXxZ3JmCmYDZftnc2Y1ZjZmNGYcZk9mRGZJZkFmXmZdZmRmZ2Zo" +
"Zl9mYmZwZoNmiGaOZolmhGaYZp1mwWa5Zslmvma8////////ZsRmuGbWZtpm4GY/ZuZm6WbwZvVm92cPZxZnHmcmZyeXOGcuZz9nNmdBZzhnN2dGZ15nYGdZZ2NnZGeJZ3BnqWd8Z2pnjGeLZ6ZnoWeFZ7dn72e0Z+xns2fpZ7hn5GfeZ91n4mfuZ7lnzmfGZ+dqnGge" +
"aEZoKWhAaE1oMmhO//9os2graFloY2h3aH9on2iPaK1olGidaJtog2quaLlodGi1aKBoumkPaI1ofmkBaMppCGjYaSJpJmjhaQxozWjUaOdo1Wk2aRJpBGjXaONpJWj5aOBo72koaSppGmkjaSFoxml5aXdpXGl4aWtpVGl+aW5pOWl0aT1pWWkwaWFpXmldaYFpammy" +
"aa5p0Gm/acFp02m+ac5b6GnKad1pu2nDaadqLmmRaaBpnGmVabRp3mnoagJqG2n/awpp+WnyaedqBWmxah5p7WoUaetqCmoSasFqI2oTakRqDGpyajZqeGpHamJqWWpmakhqOGoiapBqjWqgaoRqomqj////////apeGF2q7asNqwmq4arNqrGreatFq32qqatpq6mr7" +
"awWGFmr6axJrFpsxax9rOGs3dtxrOZjua0drQ2tJa1BrWWtUa1trX2tha3hreWt/a4BrhGuDa41rmGuVa55rpGuqa6trr2uya7Frs2u3a7xrxmvLa9Nr32vsa+tr82vv//+evmwIbBNsFGwbbCRsI2xebFVsYmxqbIJsjWyabIFsm2x+bGhsc2ySbJBsxGzxbNNsvWzX" +
"bMVs3WyubLFsvmy6bNts72zZbOptH4hNbTZtK209bThtGW01bTNtEm0MbWNtk21kbVpteW1ZbY5tlW/kbYVt+W4VbgpttW3HbeZtuG3Gbext3m3Mbeht0m3Fbfpt2W3kbdVt6m3ubi1ubm4ubhlucm5fbj5uI25rbitudm5Nbh9uQ246bk5uJG7/bh1uOG6CbqpumG7J" +
"brdu0269bq9uxG6ybtRu1W6PbqVuwm6fb0FvEXBMbuxu+G7+bz9u8m8xbu9vMm7M////////bz5vE273b4Zvem94b4FvgG9vb1tv829tb4JvfG9Yb45vkW/Cb2Zvs2+jb6FvpG+5b8Zvqm/fb9Vv7G/Ub9hv8W/ub9twCXALb/pwEXABcA9v/nAbcBpvdHAdcBhwH3Aw" +
"cD5wMnBRcGNwmXCScK9w8XCscLhws3CucN9wy3Dd//9w2XEJcP1xHHEZcWVxVXGIcWZxYnFMcVZxbHGPcftxhHGVcahxrHHXcblxvnHScclx1HHOceBx7HHncfVx/HH5cf9yDXIQchtyKHItcixyMHIycjtyPHI/ckByRnJLclhydHJ+coJygXKHcpJylnKicqdyuXKy" +
"csNyxnLEcs5y0nLicuBy4XL5cvdQD3MXcwpzHHMWcx1zNHMvcylzJXM+c05zT57Yc1dzanNoc3BzeHN1c3tzenPIc7NzznO7c8Bz5XPuc950onQFdG90JXP4dDJ0OnRVdD90X3RZdEF0XHRpdHB0Y3RqdHZ0fnSLdJ50p3TKdM901HPx////////dOB043TndOl07nTy" +
"dPB08XT4dPd1BHUDdQV1DHUOdQ11FXUTdR51JnUsdTx1RHVNdUp1SXVbdUZ1WnVpdWR1Z3VrdW11eHV2dYZ1h3V0dYp1iXWCdZR1mnWddaV1o3XCdbN1w3W1db11uHW8dbF1zXXKddJ12XXjdd51/nX///91/HYBdfB1+nXydfN2C3YNdgl2H3YndiB2IXYidiR2NHYw" +
"djt2R3ZIdkZ2XHZYdmF2YnZodml2anZndmx2cHZydnZ2eHZ8doB2g3aIdot2jnaWdpN2mXaadrB2tHa4drl2unbCds121nbSdt524Xbldud26oYvdvt3CHcHdwR3KXckdx53JXcmdxt3N3c4d0d3Wndod2t3W3dld393fnd5d453i3eRd6B3nnewd7Z3uXe/d7x3vXe7" +
"d8d3zXfXd9p33Hfjd+53/HgMeBJ5JnggeSp4RXiOeHR4hnh8eJp4jHijeLV4qniveNF4xnjLeNR4vni8eMV4ynjs////////eOd42nj9ePR5B3kSeRF5GXkseSt5QHlgeVd5X3laeVV5U3l6eX95inmdeaefS3mqea55s3m5ebp5yXnVeed57HnheeN6CHoNehh6GXog" +
"eh95gHoxejt6Pno3ekN6V3pJemF6Ynppn516cHp5en16iHqXepV6mHqWeql6yHqw//96tnrFesR6v5CDesd6ynrNes961XrTetl62nrdeuF64nrmeu168HsCew97CnsGezN7GHsZex57NXsoezZ7UHt6ewR7TXsLe0x7RXt1e2V7dHtne3B7cXtse257nXuYe597jXuc" +
"e5p7i3uSe497XXuZe8t7wXvMe897tHvGe9176XwRfBR75nvlfGB8AHwHfBN783v3fBd8DXv2fCN8J3wqfB98N3wrfD18THxDfFR8T3xAfFB8WHxffGR8VnxlfGx8dXyDfJB8pHytfKJ8q3yhfKh8s3yyfLF8rny5fL18wHzFfMJ82HzSfNx84ps7fO988nz0fPZ8+n0G" +
"////////fQJ9HH0VfQp9RX1LfS59Mn0/fTV9Rn1zfVZ9Tn1yfWh9bn1PfWN9k32JfVt9j319fZt9un2ufaN9tX3Hfb19q349faJ9r33cfbh9n32wfdh93X3kfd59+33yfeF+BX4KfiN+IX4SfjF+H34Jfgt+In5GfmZ+O341fjl+Q343//9+Mn46fmd+XX5Wfl5+WX5a" +
"fnl+an5pfnx+e36DfdV+fY+ufn9+iH6Jfox+kn6QfpN+lH6Wfo5+m36cfzh/On9Ff0x/TX9Of1B/UX9Vf1R/WH9ff2B/aH9pf2d/eH+Cf4Z/g3+If4d/jH+Uf55/nX+af6N/r3+yf7l/rn+2f7iLcX/Ff8Z/yn/Vf9R/4X/mf+l/83/5mNyABoAEgAuAEoAYgBmAHIAh" +
"gCiAP4A7gEqARoBSgFiAWoBfgGKAaIBzgHKAcIB2gHmAfYB/gISAhoCFgJuAk4CagK1RkICsgNuA5YDZgN2AxIDagNaBCYDvgPGBG4EpgSOBL4FL////////louBRoE+gVOBUYD8gXGBboFlgWaBdIGDgYiBioGAgYKBoIGVgaSBo4FfgZOBqYGwgbWBvoG4gb2BwIHC" +
"gbqByYHNgdGB2YHYgciB2oHfgeCB54H6gfuB/oIBggKCBYIHggqCDYIQghaCKYIrgjiCM4JAglmCWIJdglqCX4Jk//+CYoJogmqCa4IugnGCd4J4gn6CjYKSgquCn4K7gqyC4YLjgt+C0oL0gvOC+oOTgwOC+4L5gt6DBoLcgwmC2YM1gzSDFoMygzGDQIM5g1CDRYMv" +
"gyuDF4MYg4WDmoOqg5+DooOWgyODjoOHg4qDfIO1g3ODdYOgg4mDqIP0hBOD64POg/2EA4PYhAuDwYP3hAeD4IPyhA2EIoQgg72EOIUGg/uEbYQqhDyFWoSEhHeEa4SthG6EgoRphEaELIRvhHmENYTKhGKEuYS/hJ+E2YTNhLuE2oTQhMGExoTWhKGFIYT/hPSFF4UY" +
"hSyFH4UVhRSE/IVAhWOFWIVI////////hUGGAoVLhVWFgIWkhYiFkYWKhaiFbYWUhZuF6oWHhZyFd4V+hZCFyYW6hc+FuYXQhdWF3YXlhdyF+YYKhhOGC4X+hfqGBoYihhqGMIY/hk1OVYZUhl+GZ4ZxhpOGo4aphqqGi4aMhraGr4bEhsaGsIbJiCOGq4bUht6G6Ybs" +
"//+G34bbhu+HEocGhwiHAIcDhvuHEYcJhw2G+YcKhzSHP4c3hzuHJYcphxqHYIdfh3iHTIdOh3SHV4doh26HWYdTh2OHaogFh6KHn4eCh6+Hy4e9h8CH0JbWh6uHxIezh8eHxoe7h++H8ofgiA+IDYf+h/aH94gOh9KIEYgWiBWIIoghiDGINog5iCeIO4hEiEKIUohZ" +
"iF6IYohriIGIfoieiHWIfYi1iHKIgoiXiJKIroiZiKKIjYikiLCIv4ixiMOIxIjUiNiI2YjdiPmJAoj8iPSI6IjyiQSJDIkKiROJQ4keiSWJKokriUGJRIk7iTaJOIlMiR2JYIle////////iWaJZIltiWqJb4l0iXeJfomDiYiJiomTiZiJoYmpiaaJrImvibKJuom9" +
"ib+JwInaidyJ3YnnifSJ+IoDihaKEIoMihuKHYolijaKQYpbilKKRopIinyKbYpsimKKhYqCioSKqIqhipGKpYqmipqKo4rEis2KworaiuuK84rn//+K5IrxixSK4IriiveK3orbiwyLB4saiuGLFosQixeLIIszl6uLJosriz6LKItBi0yLT4tOi0mLVotbi1qLa4tf" +
"i2yLb4t0i32LgIuMi46LkouTi5aLmYuajDqMQYw/jEiMTIxOjFCMVYxijGyMeIx6jIKMiYyFjIqMjYyOjJSMfIyYYh2MrYyqjL2MsoyzjK6MtozIjMGM5IzjjNqM/Yz6jPuNBI0FjQqNB40PjQ2NEJ9OjROMzY0UjRaNZ41tjXGNc42BjZmNwo2+jbqNz43ajdaNzI3b" +
"jcuN6o3rjd+N4438jgiOCY3/jh2OHo4Qjh+OQo41jjCONI5K////////jkeOSY5MjlCOSI5ZjmSOYI4qjmOOVY52jnKOfI6BjoeOhY6EjouOio6TjpGOlI6ZjqqOoY6sjrCOxo6xjr6OxY7IjsuO247jjvyO+47rjv6PCo8FjxWPEo8ZjxOPHI8fjxuPDI8mjzOPO485" +
"j0WPQo8+j0yPSY9Gj06PV49c//+PYo9jj2SPnI+fj6OPrY+vj7eP2o/lj+KP6o/vkIeP9JAFj/mP+pARkBWQIZANkB6QFpALkCeQNpA1kDmP+JBPkFCQUZBSkA6QSZA+kFaQWJBekGiQb5B2lqiQcpCCkH2QgZCAkIqQiZCPkKiQr5CxkLWQ4pDkYkiQ25ECkRKRGZEy" +
"kTCRSpFWkViRY5FlkWmRc5FykYuRiZGCkaKRq5GvkaqRtZG0kbqRwJHBkcmRy5HQkdaR35HhkduR/JH1kfaSHpH/khSSLJIVkhGSXpJXkkWSSZJkkkiSlZI/kkuSUJKckpaSk5KbklqSz5K5kreS6ZMPkvqTRJMu////////kxmTIpMakyOTOpM1kzuTXJNgk3yTbpNW" +
"k7CTrJOtk5STuZPWk9eT6JPlk9iTw5Pdk9CTyJPklBqUFJQTlAOUB5QQlDaUK5Q1lCGUOpRBlFKURJRblGCUYpRelGqSKZRwlHWUd5R9lFqUfJR+lIGUf5WClYeVipWUlZaVmJWZ//+VoJWolaeVrZW8lbuVuZW+lcpv9pXDlc2VzJXVldSV1pXcleGV5ZXiliGWKJYu" +
"li+WQpZMlk+WS5Z3llyWXpZdll+WZpZylmyWjZaYlpWWl5aqlqeWsZaylrCWtJa2lriWuZbOlsuWyZbNiU2W3JcNltWW+ZcElwaXCJcTlw6XEZcPlxaXGZcklyqXMJc5lz2XPpdEl0aXSJdCl0mXXJdgl2SXZpdoUtKXa5dxl3mXhZd8l4GXepeGl4uXj5eQl5yXqJem" +
"l6OXs5e0l8OXxpfIl8uX3Jftn0+X8nrfl/aX9ZgPmAyYOJgkmCGYN5g9mEaYT5hLmGuYb5hw////////mHGYdJhzmKqYr5ixmLaYxJjDmMaY6ZjrmQOZCZkSmRSZGJkhmR2ZHpkkmSCZLJkumT2ZPplCmUmZRZlQmUuZUZlSmUyZVZmXmZiZpZmtma6ZvJnfmduZ3ZnY" +
"mdGZ7ZnumfGZ8pn7mfiaAZoPmgWZ4poZmiuaN5pFmkKaQJpD//+aPppVmk2aW5pXml+aYpplmmSaaZprmmqarZqwmryawJrPmtGa05rUmt6a35rimuOa5prvmuua7pr0mvGa95r7mwabGJsamx+bIpsjmyWbJ5somymbKpsumy+bMptEm0ObT5tNm06bUZtYm3Sbk5uD" +
"m5GblpuXm5+boJuom7SbwJvKm7mbxpvPm9Gb0pvjm+Kb5JvUm+GcOpvym/Gb8JwVnBScCZwTnAycBpwInBKcCpwEnC6cG5wlnCScIZwwnEecMpxGnD6cWpxgnGecdpx4nOec7JzwnQmdCJzrnQOdBp0qnSadr50jnR+dRJ0VnRKdQZ0/nT6dRp1I////////nV2dXp1k" +
"nVGdUJ1ZnXKdiZ2Hnaudb516nZqdpJ2pnbKdxJ3BnbuduJ26ncadz53Cndmd0534nead7Z3vnf2eGp4bnh6edZ55nn2egZ6InouejJ6SnpWekZ6dnqWeqZ64nqqerZdhnsyezp7PntCe1J7cnt6e3Z7gnuWe6J7v//+e9J72nvee+Z77nvye/Z8Hnwh2t58VnyGfLJ8+" +
"n0qfUp9Un2OfX59gn2GfZp9nn2yfap93n3Kfdp+Vn5yfoFgvaceQWXRkUdxxmf//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
"////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////" +
"/////////////////////////////////////////////w==";
private static short[] UNICODE_TO_QR_KANJI = new short[1 << 16];
static { // Unpack the Shift JIS table into a more computation-friendly form
Arrays.fill(UNICODE_TO_QR_KANJI, (short)-1);
byte[] bytes = Base64.getDecoder().decode(PACKED_QR_KANJI_TO_UNICODE);
for (int i = 0; i < bytes.length; i += 2) {
char c = (char)(((bytes[i] & 0xFF) << 8) | (bytes[i + 1] & 0xFF));
if (c == 0xFFFF)
continue;
assert UNICODE_TO_QR_KANJI[c] == -1;
UNICODE_TO_QR_KANJI[c] = (short)(i / 2);
}
}
/*---- Miscellaneous ----*/
private QrSegmentAdvanced() {} // Not instantiable
}

270
java-fast/io/nayuki/fastqrcodegen/QrTemplate.java Normal file
View File

@ -0,0 +1,270 @@
/*
* Fast QR Code generator library
*
* Copyright (c) Project Nayuki. (MIT License)
* https://www.nayuki.io/page/fast-qr-code-generator-library
*
* 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.
*/
package io.nayuki.fastqrcodegen;
// Stores the parts of a QR Code that depend only on the version number,
// and does not depend on the data or error correction level or mask.
final class QrTemplate {
// Use this memoizer to get instances of this class.
public static final Memoizer<Integer,QrTemplate> MEMOIZER
= new Memoizer<>(QrTemplate::new);
private final int version; // In the range [1, 40].
private final int size; // Derived from version.
final int[] template; // Length and values depend on version.
final int[][] masks; // masks.length == 8, and masks[i].length == template.length.
final int[] dataOutputBitIndexes; // Length and values depend on version.
// Indicates function modules that are not subjected to masking. Discarded when constructor finishes.
// Otherwise when the constructor is running, isFunction.length == template.length.
private int[] isFunction;
// Creates a QR Code template for the given version number.
private QrTemplate(int ver) {
if (ver < QrCode.MIN_VERSION || ver > QrCode.MAX_VERSION)
throw new IllegalArgumentException("Version out of range");
version = ver;
size = version * 4 + 17;
template = new int[(size * size + 31) / 32];
isFunction = new int[template.length];
drawFunctionPatterns(); // Reads and writes fields
masks = generateMasks(); // Reads fields, returns array
dataOutputBitIndexes = generateZigzagScan(); // Reads fields, returns array
isFunction = null;
}
// Reads this object's version field, and draws and marks all function modules.
private void drawFunctionPatterns() {
// Draw horizontal and vertical timing patterns
for (int i = 0; i < size; i++) {
darkenFunctionModule(6, i, ~i & 1);
darkenFunctionModule(i, 6, ~i & 1);
}
// 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 numerous alignment patterns
int[] alignPatPos = getAlignmentPatternPositions();
int numAlign = alignPatPos.length;
for (int i = 0; i < numAlign; i++) {
for (int j = 0; j < numAlign; j++) {
// Don't draw on the three finder corners
if (!(i == 0 && j == 0 || i == 0 && j == numAlign - 1 || i == numAlign - 1 && j == 0))
drawAlignmentPattern(alignPatPos[i], alignPatPos[j]);
}
}
// Draw configuration data
drawDummyFormatBits();
drawVersion();
}
// Draws two blank copies of the format bits.
private void drawDummyFormatBits() {
// Draw first copy
for (int i = 0; i <= 5; i++)
darkenFunctionModule(8, i, 0);
darkenFunctionModule(8, 7, 0);
darkenFunctionModule(8, 8, 0);
darkenFunctionModule(7, 8, 0);
for (int i = 9; i < 15; i++)
darkenFunctionModule(14 - i, 8, 0);
// Draw second copy
for (int i = 0; i < 8; i++)
darkenFunctionModule(size - 1 - i, 8, 0);
for (int i = 8; i < 15; i++)
darkenFunctionModule(8, size - 15 + i, 0);
darkenFunctionModule(8, size - 8, 1); // Always dark
}
// Draws two copies of the version bits (with its own error correction code),
// based on this object's version field, iff 7 <= version <= 40.
private void 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 bits = version << 12 | rem; // uint18
assert bits >>> 18 == 0;
// Draw two copies
for (int i = 0; i < 18; i++) {
int bit = QrCode.getBit(bits, i);
int a = size - 11 + i % 3;
int b = i / 3;
darkenFunctionModule(a, b, bit);
darkenFunctionModule(b, a, bit);
}
}
// Draws a 9*9 finder pattern including the border separator,
// with the center module at (x, y). Modules can be out of bounds.
private void drawFinderPattern(int x, int y) {
for (int dy = -4; dy <= 4; dy++) {
for (int dx = -4; dx <= 4; dx++) {
int dist = Math.max(Math.abs(dx), Math.abs(dy)); // Chebyshev/infinity norm
int xx = x + dx, yy = y + dy;
if (0 <= xx && xx < size && 0 <= yy && yy < size)
darkenFunctionModule(xx, yy, (dist != 2 && dist != 4) ? 1 : 0);
}
}
}
// Draws a 5*5 alignment pattern, with the center module
// at (x, y). All modules must be in bounds.
private void drawAlignmentPattern(int x, int y) {
for (int dy = -2; dy <= 2; dy++) {
for (int dx = -2; dx <= 2; dx++)
darkenFunctionModule(x + dx, y + dy, Math.abs(Math.max(Math.abs(dx), Math.abs(dy)) - 1));
}
}
// Computes and returns a new array of masks, based on this object's various fields.
private int[][] generateMasks() {
int[][] result = new int[8][template.length];
for (int mask = 0; mask < result.length; mask++) {
int[] maskModules = result[mask];
for (int y = 0, i = 0; y < size; y++) {
for (int x = 0; x < size; x++, i++) {
boolean 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 new AssertionError();
}
int bit = (invert ? 1 : 0) & ~getModule(isFunction, x, y);
maskModules[i >>> 5] |= bit << i;
}
}
}
return result;
}
// Computes and returns an array of bit indexes, based on this object's various fields.
private int[] generateZigzagScan() {
int[] result = new int[getNumRawDataModules(version) / 8 * 8];
int i = 0; // Bit index into the data
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
boolean upward = ((right + 1) & 2) == 0;
int y = upward ? size - 1 - vert : vert; // Actual y coordinate
if (getModule(isFunction, x, y) == 0 && i < result.length) {
result[i] = y * size + x;
i++;
}
}
}
}
assert i == result.length;
return result;
}
// Returns the value of the bit at the given coordinates in the given grid.
private int getModule(int[] grid, int x, int y) {
assert 0 <= x && x < size;
assert 0 <= y && y < size;
int i = y * size + x;
return QrCode.getBit(grid[i >>> 5], i);
}
// Marks the module at the given coordinates as a function module.
// Also either sets that module dark or keeps its color unchanged.
private void darkenFunctionModule(int x, int y, int enable) {
assert 0 <= x && x < size;
assert 0 <= y && y < size;
assert enable == 0 || enable == 1;
int i = y * size + x;
template[i >>> 5] |= enable << i;
isFunction[i >>> 5] |= 1 << i;
}
// Returns an ascending list of positions of alignment patterns for this version number.
// Each position is in the range [0,177), and are used on both the x and y axes.
// This could be implemented as lookup table of 40 variable-length lists of unsigned bytes.
private int[] getAlignmentPatternPositions() {
if (version == 1)
return new int[]{};
else {
int numAlign = version / 7 + 2;
int step = (version == 32) ? 26 :
(version * 4 + numAlign * 2 + 1) / (numAlign * 2 - 2) * 2;
int[] result = new int[numAlign];
result[0] = 6;
for (int i = result.length - 1, pos = size - 7; i >= 1; i--, pos -= step)
result[i] = pos;
return result;
}
}
// Returns the number of data bits that can be stored in a QR Code of the given version number, after
// all function modules are excluded. This includes remainder bits, so it might not be a multiple of 8.
// The result is in the range [208, 29648]. This could be implemented as a 40-entry lookup table.
static int getNumRawDataModules(int ver) {
if (ver < QrCode.MIN_VERSION || ver > QrCode.MAX_VERSION)
throw new IllegalArgumentException("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 -= 36;
}
return result;
}
}

106
java-fast/io/nayuki/fastqrcodegen/ReedSolomonGenerator.java Normal file
View File

@ -0,0 +1,106 @@
/*
* Fast QR Code generator library
*
* Copyright (c) Project Nayuki. (MIT License)
* https://www.nayuki.io/page/fast-qr-code-generator-library
*
* 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.
*/
package io.nayuki.fastqrcodegen;
import java.util.Arrays;
import java.util.Objects;
// Computes Reed-Solomon error correction codewords for given data codewords.
final class ReedSolomonGenerator {
// Use this memoizer to get instances of this class.
public static final Memoizer<Integer,ReedSolomonGenerator> MEMOIZER
= new Memoizer<>(ReedSolomonGenerator::new);
// A table of size 256 * degree, where polynomialMultiply[i][j] = multiply(i, coefficients[j]).
// 'coefficients' is the temporary array computed in the constructor.
private byte[][] polynomialMultiply;
// Creates a Reed-Solomon ECC generator polynomial for the given degree.
private ReedSolomonGenerator(int degree) {
if (degree < 1 || degree > 255)
throw new IllegalArgumentException("Degree out of range");
// The divisor polynomial, whose coefficients are stored from highest to lowest power.
// For example, x^3 + 255x^2 + 8x + 93 is stored as the uint8 array {255, 8, 93}.
byte[] coefficients = new byte[degree];
coefficients[degree - 1] = 1; // Start off with the monomial x^0
// Compute the product polynomial (x - r^0) * (x - r^1) * (x - r^2) * ... * (x - r^{degree-1}),
// and drop the highest monomial term which is always 1x^degree.
// 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 (int j = 0; j < coefficients.length; j++) {
coefficients[j] = (byte)multiply(coefficients[j] & 0xFF, root);
if (j + 1 < coefficients.length)
coefficients[j] ^= coefficients[j + 1];
}
root = multiply(root, 0x02);
}
polynomialMultiply = new byte[256][degree];
for (int i = 0; i < polynomialMultiply.length; i++) {
for (int j = 0; j < degree; j++)
polynomialMultiply[i][j] = (byte)multiply(i, coefficients[j] & 0xFF);
}
}
// Returns the error correction codeword for the given data polynomial and this divisor polynomial.
public void getRemainder(byte[] data, int dataOff, int dataLen, byte[] result) {
Objects.requireNonNull(data);
Objects.requireNonNull(result);
int degree = polynomialMultiply[0].length;
assert result.length == degree;
Arrays.fill(result, (byte)0);
for (int i = dataOff, dataEnd = dataOff + dataLen; i < dataEnd; i++) { // Polynomial division
byte[] table = polynomialMultiply[(data[i] ^ result[0]) & 0xFF];
for (int j = 0; j < degree - 1; j++)
result[j] = (byte)(result[j + 1] ^ table[j]);
result[degree - 1] = table[degree - 1];
}
}
// 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.
private static int multiply(int x, int y) {
assert x >> 8 == 0 && y >> 8 == 0;
// Russian peasant multiplication
int z = 0;
for (int i = 7; i >= 0; i--) {
z = (z << 1) ^ ((z >>> 7) * 0x11D);
z ^= ((y >>> i) & 1) * x;
}
assert z >>> 8 == 0;
return z;
}
}

52
java-fast/io/nayuki/fastqrcodegen/package-info.java Normal file
View File

@ -0,0 +1,52 @@
/**
* Generates QR Codes from text strings and byte arrays.
*
* <p>This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.</p>
* <p>Home page for this fast library with design explanation and benchmarks: <a href="https://www.nayuki.io/page/fast-qr-code-generator-library">https://www.nayuki.io/page/fast-qr-code-generator-library</a></p>
* <p>Home page for the main project with live JavaScript demo, extensive descriptions, and competitor comparisons: <a href="https://www.nayuki.io/page/qr-code-generator-library">https://www.nayuki.io/page/qr-code-generator-library</a></p>
*
* <h2>Features</h2>
* <p>Core features:</p>
* <ul>
* <li><p>Approximately 1.5× to 10× faster than other Java implementation</p></li>
* <li><p>Shorter code but more documentation comments compared to competing libraries</p></li>
* <li><p>Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard</p></li>
* <li><p>Output format: Raw modules/pixels of the QR symbol</p></li>
* <li><p>Detects finder-like penalty patterns more accurately than other implementations</p></li>
* <li><p>Encodes numeric and special-alphanumeric text in less space than general text</p></li>
* <li><p>Encodes Japanese Unicode text in kanji mode to save a lot of space compared to UTF-8 bytes</p></li>
* <li><p>Computes optimal segment mode switching for text with mixed numeric/alphanumeric/general/kanji parts</p></li>
* <li><p>Open-source code under the permissive MIT License</p></li>
* </ul>
* <p>Manual parameters:</p>
* <ul>
* <li><p>User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data</p></li>
* <li><p>User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one</p></li>
* <li><p>User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number</p></li>
* <li><p>User can create a list of data segments manually and add ECI segments</p></li>
* </ul>
* <p>More information about QR Code technology and this library's design can be found on the project home page.</p>
*
* <h2>Examples</h2>
* <p>Simple operation:</p>
* <pre style="margin-left:2em">import java.awt.image.BufferedImage;
*import java.io.File;
*import javax.imageio.ImageIO;
*import io.nayuki.fastqrcodegen.*;
*
*QrCode qr = QrCode.encodeText("Hello, world!", QrCode.Ecc.MEDIUM);
*BufferedImage img = toImage(qr, 4, 10); // See QrCodeGeneratorDemo
*ImageIO.write(img, "png", new File("qr-code.png"));</pre>
* <p>Manual operation:</p>
* <pre style="margin-left:2em">import java.util.List;
*import io.nayuki.fastqrcodegen.*;
*
*List&lt;QrSegment&gt; segs = QrSegment.makeSegments("3141592653589793238462643383");
*QrCode qr = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, 5, 5, 2, false);
*for (int y = 0; y &lt; qr.size; y++) {
* for (int x = 0; x &lt; qr.size; x++) {
* (... paint qr.getModule(x, y) ...)
* }
*}</pre>
*/
package io.nayuki.fastqrcodegen;

65
java/Readme.markdown Normal file
View File

@ -0,0 +1,65 @@
QR Code generator library - Java
================================
Introduction
------------
This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
Features
--------
Core features:
* Significantly shorter code but more documentation comments compared to competing libraries
* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
* Output format: Raw modules/pixels of the QR symbol
* Detects finder-like penalty patterns more accurately than other implementations
* Encodes numeric and special-alphanumeric text in less space than general text
* Open-source code under the permissive MIT License
Manual parameters:
* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
* User can create a list of data segments manually and add ECI segments
Optional advanced features:
* Encodes Japanese Unicode text in kanji mode to save a lot of space compared to UTF-8 bytes
* Computes optimal segment mode switching for text with mixed numeric/alphanumeric/general/kanji parts
More information about QR Code technology and this library's design can be found on the project home page.
Examples
--------
```java
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.List;
import javax.imageio.ImageIO;
import io.nayuki.qrcodegen.*;
// Simple operation
QrCode qr0 = QrCode.encodeText("Hello, world!", QrCode.Ecc.MEDIUM);
BufferedImage img = toImage(qr0, 4, 10); // See QrCodeGeneratorDemo
ImageIO.write(img, "png", new File("qr-code.png"));
// Manual operation
List<QrSegment> segs = QrSegment.makeSegments("3141592653589793238462643383");
QrCode qr1 = QrCode.encodeSegments(segs, QrCode.Ecc.HIGH, 5, 5, 2, false);
for (int y = 0; y < qr1.size; y++) {
for (int x = 0; x < qr1.size; x++) {
(... paint qr1.getModule(x, y) ...)
}
}
```
More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/java/QrCodeGeneratorDemo.java .

2
java/pom.xml
View File

@ -4,7 +4,7 @@
<groupId>io.nayuki</groupId>
<artifactId>qrcodegen</artifactId>
<version>1.7.0</version>
<version>1.8.0</version>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

6
java/src/main/java/io/nayuki/qrcodegen/DataTooLongException.java
View File

@ -33,17 +33,17 @@ package io.nayuki.qrcodegen;
* if it was less than {@link QrCode#MAX_VERSION}. (This advice does not apply to the other
* factory functions because they search all versions up to {@code QrCode.MAX_VERSION}.)</p></li>
* <li><p>Split the text data into better or optimal segments in order to reduce the number of
* bits required. (See {@link QrSegmentAdvanced#makeSegmentsOptimally(String,QrCode.Ecc,int,int)
* bits required. (See {@link QrSegmentAdvanced#makeSegmentsOptimally(CharSequence,QrCode.Ecc,int,int)
* QrSegmentAdvanced.makeSegmentsOptimally()}.)</p></li>
* <li><p>Change the text or binary data to be shorter.</p></li>
* <li><p>Change the text to fit the character set of a particular segment mode (e.g. alphanumeric).</p></li>
* <li><p>Propagate the error upward to the caller/user.</p></li>
* </ul>
* @see QrCode#encodeText(String, QrCode.Ecc)
* @see QrCode#encodeText(CharSequence, QrCode.Ecc)
* @see QrCode#encodeBinary(byte[], QrCode.Ecc)
* @see QrCode#encodeSegments(java.util.List, QrCode.Ecc)
* @see QrCode#encodeSegments(java.util.List, QrCode.Ecc, int, int, int, boolean)
* @see QrSegmentAdvanced#makeSegmentsOptimally(String, QrCode.Ecc, int, int)
* @see QrSegmentAdvanced#makeSegmentsOptimally(CharSequence, QrCode.Ecc, int, int)
*/
public class DataTooLongException extends IllegalArgumentException {

55
java/src/main/java/io/nayuki/qrcodegen/QrCode.java
View File

@ -37,7 +37,7 @@ import java.util.Objects;
* from 1 to 40, all 4 error correction levels, and 4 character encoding modes.</p>
* <p>Ways to create a QR Code object:</p>
* <ul>
* <li><p>High level: Take the payload data and call {@link QrCode#encodeText(String,Ecc)}
* <li><p>High level: Take the payload data and call {@link QrCode#encodeText(CharSequence,Ecc)}
* or {@link QrCode#encodeBinary(byte[],Ecc)}.</p></li>
* <li><p>Mid level: Custom-make the list of {@link QrSegment segments}
* and call {@link QrCode#encodeSegments(List,Ecc)} or
@ -66,7 +66,7 @@ public final class QrCode {
* @throws DataTooLongException if the text fails to fit in the
* largest version QR Code at the ECL, which means it is too long
*/
public static QrCode encodeText(String text, Ecc ecl) {
public static QrCode encodeText(CharSequence text, Ecc ecl) {
Objects.requireNonNull(text);
Objects.requireNonNull(ecl);
List<QrSegment> segs = QrSegment.makeSegments(text);
@ -102,7 +102,7 @@ public final class QrCode {
* of the result may be higher than the ecl argument if it can be done without increasing the version.
* <p>This function allows the user to create a custom sequence of segments that switches
* between modes (such as alphanumeric and byte) to encode text in less space.
* This is a mid-level API; the high-level API is {@link #encodeText(String,Ecc)}
* This is a mid-level API; the high-level API is {@link #encodeText(CharSequence,Ecc)}
* and {@link #encodeBinary(byte[],Ecc)}.</p>
* @param segs the segments to encode
* @param ecl the error correction level to use (not {@code null}) (boostable)
@ -125,7 +125,7 @@ public final class QrCode {
* mask, or &#x2212;1 to automatically choose an appropriate mask (which may be slow).
* <p>This function allows the user to create a custom sequence of segments that switches
* between modes (such as alphanumeric and byte) to encode text in less space.
* This is a mid-level API; the high-level API is {@link #encodeText(String,Ecc)}
* This is a mid-level API; the high-level API is {@link #encodeText(CharSequence,Ecc)}
* and {@link #encodeBinary(byte[],Ecc)}.</p>
* @param segs the segments to encode
* @param ecl the error correction level to use (not {@code null}) (boostable)
@ -262,7 +262,26 @@ public final class QrCode {
drawFunctionPatterns();
byte[] allCodewords = addEccAndInterleave(dataCodewords);
drawCodewords(allCodewords);
mask = handleConstructorMasking(msk);
// Do masking
if (msk == -1) { // Automatically choose best mask
int minPenalty = Integer.MAX_VALUE;
for (int i = 0; i < 8; i++) {
applyMask(i);
drawFormatBits(i);
int penalty = getPenaltyScore();
if (penalty < minPenalty) {
msk = i;
minPenalty = penalty;
}
applyMask(i); // Undoes the mask due to XOR
}
}
assert 0 <= msk && msk <= 7;
mask = msk;
applyMask(msk); // Apply the final choice of mask
drawFormatBits(msk); // Overwrite old format bits
isFunction = null;
}
@ -503,30 +522,6 @@ public final class QrCode {
}
// A messy helper function for the constructor. 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.
private int handleConstructorMasking(int msk) {
if (msk == -1) { // Automatically choose best mask
int minPenalty = Integer.MAX_VALUE;
for (int i = 0; i < 8; i++) {
applyMask(i);
drawFormatBits(i);
int penalty = getPenaltyScore();
if (penalty < minPenalty) {
msk = i;
minPenalty = penalty;
}
applyMask(i); // Undoes the mask due to XOR
}
}
assert 0 <= msk && msk <= 7;
applyMask(msk); // Apply the final choice of mask
drawFormatBits(msk); // Overwrite old format bits
return msk; // The caller shall assign this value to the final-declared field
}
// 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.
private int getPenaltyScore() {
@ -599,7 +594,9 @@ public final class QrCode {
int total = size * size; // Note that size is odd, so dark/total != 1/2
// Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
int k = (Math.abs(dark * 20 - total * 10) + total - 1) / total - 1;
assert 0 <= k && k <= 9;
result += k * PENALTY_N4;
assert 0 <= result && result <= 2568888; // Non-tight upper bound based on default values of PENALTY_N1, ..., N4
return result;
}

24
java/src/main/java/io/nayuki/qrcodegen/QrSegment.java
View File

@ -34,7 +34,7 @@ import java.util.regex.Pattern;
* A segment of character/binary/control data in a QR Code symbol.
* Instances of this class are immutable.
* <p>The mid-level way to create a segment is to take the payload data and call a
* static factory function such as {@link QrSegment#makeNumeric(String)}. The low-level
* static factory function such as {@link QrSegment#makeNumeric(CharSequence)}. The low-level
* way to create a segment is to custom-make the bit buffer and call the {@link
* QrSegment#QrSegment(Mode,int,BitBuffer) constructor} with appropriate values.</p>
* <p>This segment class imposes no length restrictions, but QR Codes have restrictions.
@ -72,7 +72,7 @@ public final class QrSegment {
* @throws NullPointerException if the string is {@code null}
* @throws IllegalArgumentException if the string contains non-digit characters
*/
public static QrSegment makeNumeric(String digits) {
public static QrSegment makeNumeric(CharSequence digits) {
Objects.requireNonNull(digits);
if (!isNumeric(digits))
throw new IllegalArgumentException("String contains non-numeric characters");
@ -80,7 +80,7 @@ public final class QrSegment {
BitBuffer bb = new BitBuffer();
for (int i = 0; i < digits.length(); ) { // Consume up to 3 digits per iteration
int n = Math.min(digits.length() - i, 3);
bb.appendBits(Integer.parseInt(digits.substring(i, i + n)), n * 3 + 1);
bb.appendBits(Integer.parseInt(digits.subSequence(i, i + n).toString()), n * 3 + 1);
i += n;
}
return new QrSegment(Mode.NUMERIC, digits.length(), bb);
@ -96,7 +96,7 @@ public final class QrSegment {
* @throws NullPointerException if the string is {@code null}
* @throws IllegalArgumentException if the string contains non-encodable characters
*/
public static QrSegment makeAlphanumeric(String text) {
public static QrSegment makeAlphanumeric(CharSequence text) {
Objects.requireNonNull(text);
if (!isAlphanumeric(text))
throw new IllegalArgumentException("String contains unencodable characters in alphanumeric mode");
@ -121,7 +121,7 @@ public final class QrSegment {
* @return a new mutable list (not {@code null}) of segments (not {@code null}) containing the text
* @throws NullPointerException if the text is {@code null}
*/
public static List<QrSegment> makeSegments(String text) {
public static List<QrSegment> makeSegments(CharSequence text) {
Objects.requireNonNull(text);
// Select the most efficient segment encoding automatically
@ -132,7 +132,7 @@ public final class QrSegment {
else if (isAlphanumeric(text))
result.add(makeAlphanumeric(text));
else
result.add(makeBytes(text.getBytes(StandardCharsets.UTF_8)));
result.add(makeBytes(text.toString().getBytes(StandardCharsets.UTF_8)));
return result;
}
@ -151,10 +151,10 @@ public final class QrSegment {
else if (assignVal < (1 << 7))
bb.appendBits(assignVal, 8);
else if (assignVal < (1 << 14)) {
bb.appendBits(2, 2);
bb.appendBits(0b10, 2);
bb.appendBits(assignVal, 14);
} else if (assignVal < 1_000_000) {
bb.appendBits(6, 3);
bb.appendBits(0b110, 3);
bb.appendBits(assignVal, 21);
} else
throw new IllegalArgumentException("ECI assignment value out of range");
@ -168,9 +168,9 @@ public final class QrSegment {
* @param text the string to test for encodability (not {@code null})
* @return {@code true} iff each character is in the range 0 to 9.
* @throws NullPointerException if the string is {@code null}
* @see #makeNumeric(String)
* @see #makeNumeric(CharSequence)
*/
public static boolean isNumeric(String text) {
public static boolean isNumeric(CharSequence text) {
return NUMERIC_REGEX.matcher(text).matches();
}
@ -182,9 +182,9 @@ public final class QrSegment {
* @param text the string to test for encodability (not {@code null})
* @return {@code true} iff each character is in the alphanumeric mode character set
* @throws NullPointerException if the string is {@code null}
* @see #makeAlphanumeric(String)
* @see #makeAlphanumeric(CharSequence)
*/
public static boolean isAlphanumeric(String text) {
public static boolean isAlphanumeric(CharSequence text) {
return ALPHANUMERIC_REGEX.matcher(text).matches();
}

26
java/src/main/java/io/nayuki/qrcodegen/QrSegmentAdvanced.java
View File

@ -48,7 +48,7 @@ public final class QrSegmentAdvanced {
* in the specified {error correction level, minimum version number, maximum version number}.
* <p>This function can utilize all four text encoding modes: numeric, alphanumeric, byte (UTF-8),
* and kanji. This can be considered as a sophisticated but slower replacement for {@link
* QrSegment#makeSegments(String)}. This requires more input parameters because it searches a
* QrSegment#makeSegments(CharSequence)}. This requires more input parameters because it searches a
* range of versions, like {@link QrCode#encodeSegments(List,QrCode.Ecc,int,int,int,boolean)}.</p>
* @param text the text to be encoded (not {@code null}), which can be any Unicode string
* @param ecl the error correction level to use (not {@code null})
@ -60,7 +60,7 @@ public final class QrSegmentAdvanced {
* @throws IllegalArgumentException if 1 &#x2264; minVersion &#x2264; maxVersion &#x2264; 40 is violated
* @throws DataTooLongException if the text fails to fit in the maxVersion QR Code at the ECL
*/
public static List<QrSegment> makeSegmentsOptimally(String text, QrCode.Ecc ecl, int minVersion, int maxVersion) {
public static List<QrSegment> makeSegmentsOptimally(CharSequence text, QrCode.Ecc ecl, int minVersion, int maxVersion) {
// Check arguments
Objects.requireNonNull(text);
Objects.requireNonNull(ecl);
@ -76,7 +76,7 @@ public final class QrSegmentAdvanced {
assert segs != null;
// Check if the segments fit
int dataCapacityBits = QrCode.getNumDataCodewords(version, ecl) * 8;
int dataCapacityBits = QrCode.getNumDataCodewords(version, ecl) * 8; // Number of data bits available
int dataUsedBits = QrSegment.getTotalBits(segs, version);
if (dataUsedBits != -1 && dataUsedBits <= dataCapacityBits)
return segs; // This version number is found to be suitable
@ -103,13 +103,17 @@ public final class QrSegmentAdvanced {
private static Mode[] computeCharacterModes(int[] codePoints, int version) {
if (codePoints.length == 0)
throw new IllegalArgumentException();
if (codePoints.length > 7089) // Upper bound is the number of characters that fit in QR Code version 40, low error correction, numeric mode
throw new DataTooLongException("String too long");
final Mode[] modeTypes = {Mode.BYTE, Mode.ALPHANUMERIC, Mode.NUMERIC, Mode.KANJI}; // Do not modify
final int numModes = modeTypes.length;
// Segment header sizes, measured in 1/6 bits
final int[] headCosts = new int[numModes];
for (int i = 0; i < numModes; i++)
for (int i = 0; i < numModes; i++) {
headCosts[i] = (4 + modeTypes[i].numCharCountBits(version)) * 6;
assert 0 <= headCosts[i] && headCosts[i] <= (4 + 16) * 6;
}
// charModes[i][j] represents the mode to encode the code point at
// index i such that the final segment ends in modeTypes[j] and the
@ -154,6 +158,10 @@ public final class QrSegmentAdvanced {
}
}
// A non-tight upper bound is when each of 7089 characters switches to
// byte mode (4-bit header + 16-bit count) and requires 4 bytes in UTF-8
for (int cost : curCosts)
assert 0 <= cost && cost <= (4 + 16 + 32) * 6 * 7089;
prevCosts = curCosts;
}
@ -215,7 +223,7 @@ public final class QrSegmentAdvanced {
// Returns a new array of Unicode code points (effectively
// UTF-32 / UCS-4) representing the given UTF-16 string.
private static int[] toCodePoints(String s) {
private static int[] toCodePoints(CharSequence s) {
int[] result = s.codePoints().toArray();
for (int c : result) {
if (Character.isSurrogate((char)c))
@ -249,9 +257,9 @@ public final class QrSegmentAdvanced {
* @return a segment (not {@code null}) containing the text
* @throws NullPointerException if the string is {@code null}
* @throws IllegalArgumentException if the string contains non-encodable characters
* @see #isEncodableAsKanji(String)
* @see #isEncodableAsKanji(CharSequence)
*/
public static QrSegment makeKanji(String text) {
public static QrSegment makeKanji(CharSequence text) {
Objects.requireNonNull(text);
BitBuffer bb = new BitBuffer();
text.chars().forEachOrdered(c -> {
@ -273,9 +281,9 @@ public final class QrSegmentAdvanced {
* @param text the string to test for encodability (not {@code null})
* @return {@code true} iff each character is in the kanji mode character set
* @throws NullPointerException if the string is {@code null}
* @see #makeKanji(String)
* @see #makeKanji(CharSequence)
*/
public static boolean isEncodableAsKanji(String text) {
public static boolean isEncodableAsKanji(CharSequence text) {
Objects.requireNonNull(text);
return text.chars().allMatch(
c -> isKanji((char)c));

5
java/src/main/java/io/nayuki/qrcodegen/package-info.java
View File

@ -7,12 +7,12 @@
* <h2>Features</h2>
* <p>Core features:</p>
* <ul>
* <li><p>Available in 6 programming languages, all with nearly equal functionality: Java, TypeScript/JavaScript, Python, Rust, C++, C</p></li>
* <li><p>Significantly shorter code but more documentation comments compared to competing libraries</p></li>
* <li><p>Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard</p></li>
* <li><p>Output format: Raw modules/pixels of the QR symbol</p></li>
* <li><p>Detects finder-like penalty patterns more accurately than other implementations</p></li>
* <li><p>Encodes numeric and special-alphanumeric text in less space than general text</p></li>
* <li><p>Open source code under the permissive MIT License</p></li>
* <li><p>Open-source code under the permissive MIT License</p></li>
* </ul>
* <p>Manual parameters:</p>
* <ul>
@ -26,6 +26,7 @@
* <li><p>Encodes Japanese Unicode text in kanji mode to save a lot of space compared to UTF-8 bytes</p></li>
* <li><p>Computes optimal segment mode switching for text with mixed numeric/alphanumeric/general/kanji parts</p></li>
* </ul>
* <p>More information about QR Code technology and this library's design can be found on the project home page.</p>
*
* <h2>Examples</h2>
* <p>Simple operation:</p>

53
python/Readme.markdown Normal file
View File

@ -0,0 +1,53 @@
QR Code generator library - Python
==================================
Introduction
------------
This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
Features
--------
Core features:
* Significantly shorter code but more documentation comments compared to competing libraries
* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
* Output format: Raw modules/pixels of the QR symbol
* Detects finder-like penalty patterns more accurately than other implementations
* Encodes numeric and special-alphanumeric text in less space than general text
* Open-source code under the permissive MIT License
Manual parameters:
* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
* User can create a list of data segments manually and add ECI segments
More information about QR Code technology and this library's design can be found on the project home page.
Examples
--------
```python
from qrcodegen import *
# Simple operation
qr0 = QrCode.encode_text("Hello, world!", QrCode.Ecc.MEDIUM)
svg = to_svg_str(qr0, 4) # See qrcodegen-demo
# Manual operation
segs = QrSegment.make_segments("3141592653589793238462643383")
qr1 = QrCode.encode_segments(segs, QrCode.Ecc.HIGH, 5, 5, 2, False)
for y in range(qr1.get_size()):
for x in range(qr1.get_size()):
(... paint qr1.get_module(x, y) ...)
```
More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/python/qrcodegen-demo.py .

11
python/qrcodegen-demo.py
View File

@ -24,6 +24,7 @@
# Software.
#
from typing import List
from qrcodegen import QrCode, QrSegment
@ -179,14 +180,14 @@ def to_svg_str(qr: QrCode, border: int) -> str:
for y in range(qr.get_size()):
for x in range(qr.get_size()):
if qr.get_module(x, y):
parts.append("M{},{}h1v1h-1z".format(x + border, y + border))
return """<?xml version="1.0" encoding="UTF-8"?>
parts.append(f"M{x+border},{y+border}h1v1h-1z")
return f"""<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 {0} {0}" stroke="none">
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 {qr.get_size()+border*2} {qr.get_size()+border*2}" stroke="none">
<rect width="100%" height="100%" fill="#FFFFFF"/>
<path d="{1}" fill="#000000"/>
<path d="{" ".join(parts)}" fill="#000000"/>
</svg>
""".format(qr.get_size() + border * 2, " ".join(parts))
"""
def print_qr(qrcode: QrCode) -> None:

35
python/qrcodegen.py
View File

@ -93,10 +93,9 @@ class QrCode:
if version >= maxversion: # All versions in the range could not fit the given data
msg: str = "Segment too long"
if datausedbits is not None:
msg = "Data length = {} bits, Max capacity = {} bits".format(datausedbits, datacapacitybits)
msg = f"Data length = {datausedbits} bits, Max capacity = {datacapacitybits} bits"
raise DataTooLongError(msg)
if datausedbits is None:
raise AssertionError()
assert datausedbits is not None
# Increase the error correction level while the data still fits in the current version number
for newecl in (QrCode.Ecc.MEDIUM, QrCode.Ecc.QUARTILE, QrCode.Ecc.HIGH): # From low to high
@ -161,7 +160,7 @@ class QrCode:
# ---- Constructor (low level) ----
def __init__(self, version: int, errcorlvl: QrCode.Ecc, datacodewords: Union[bytes,Sequence[int]], mask: int) -> None:
def __init__(self, version: int, errcorlvl: QrCode.Ecc, datacodewords: Union[bytes,Sequence[int]], msk: int) -> None:
"""Creates a new QR Code with the given version number,
error correction level, data codeword bytes, and mask number.
This is a low-level API that most users should not use directly.
@ -170,10 +169,8 @@ class QrCode:
# Check scalar arguments and set fields
if not (QrCode.MIN_VERSION <= version <= QrCode.MAX_VERSION):
raise ValueError("Version value out of range")
if not (-1 <= mask <= 7):
if not (-1 <= msk <= 7):
raise ValueError("Mask value out of range")
if not isinstance(errcorlvl, QrCode.Ecc):
raise TypeError("QrCode.Ecc expected")
self._version = version
self._size = version * 4 + 17
@ -189,20 +186,20 @@ class QrCode:
self._draw_codewords(allcodewords)
# Do masking
if mask == -1: # Automatically choose best mask
if msk == -1: # Automatically choose best mask
minpenalty: int = 1 << 32
for i in range(8):
self._apply_mask(i)
self._draw_format_bits(i)
penalty = self._get_penalty_score()
if penalty < minpenalty:
mask = i
msk = i
minpenalty = penalty
self._apply_mask(i) # Undoes the mask due to XOR
assert 0 <= mask <= 7
self._apply_mask(mask) # Apply the final choice of mask
self._draw_format_bits(mask) # Overwrite old format bits
self._mask = mask
assert 0 <= msk <= 7
self._mask = msk
self._apply_mask(msk) # Apply the final choice of mask
self._draw_format_bits(msk) # Overwrite old format bits
del self._isfunction
@ -470,7 +467,9 @@ class QrCode:
total: int = size**2 # Note that size is odd, so dark/total != 1/2
# Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
k: int = (abs(dark * 20 - total * 10) + total - 1) // total - 1
assert 0 <= k <= 9
result += k * QrCode._PENALTY_N4
assert 0 <= result <= 2568888 # Non-tight upper bound based on default values of PENALTY_N1, ..., N4
return result
@ -721,8 +720,6 @@ class QrSegment:
def make_segments(text: str) -> List[QrSegment]:
"""Returns a new mutable list of zero or more segments to represent the given Unicode text string.
The result may use various segment modes and switch modes to optimize the length of the bit stream."""
if not isinstance(text, str):
raise TypeError("Text string expected")
# Select the most efficient segment encoding automatically
if text == "":
@ -745,10 +742,10 @@ class QrSegment:
elif assignval < (1 << 7):
bb.append_bits(assignval, 8)
elif assignval < (1 << 14):
bb.append_bits(2, 2)
bb.append_bits(0b10, 2)
bb.append_bits(assignval, 14)
elif assignval < 1000000:
bb.append_bits(6, 3)
bb.append_bits(0b110, 3)
bb.append_bits(assignval, 21)
else:
raise ValueError("ECI assignment value out of range")
@ -791,8 +788,6 @@ class QrSegment:
"""Creates a new QR Code segment with the given attributes and data.
The character count (numch) must agree with the mode and the bit buffer length,
but the constraint isn't checked. The given bit buffer is cloned and stored."""
if not isinstance(mode, QrSegment.Mode):
raise TypeError("QrSegment.Mode expected")
if numch < 0:
raise ValueError()
self._mode = mode
@ -817,7 +812,7 @@ class QrSegment:
# Package-private function
@staticmethod
def get_total_bits(segs, version: int) -> Optional[int]:
def get_total_bits(segs: Sequence[QrSegment], version: int) -> Optional[int]:
"""Calculates the number of bits needed to encode the given segments at
the given version. Returns a non-negative number if successful. Otherwise
returns None if a segment has too many characters to fit its length field."""

20
python/setup.py
View File

@ -27,7 +27,7 @@ import setuptools
setuptools.setup(
name = "qrcodegen",
description = "High quality QR Code generator library for Python",
version = "1.7.0",
version = "1.8.0",
platforms = "OS Independent",
python_requires = '>=3',
license = "MIT License",
@ -66,12 +66,12 @@ Features
Core features:
* Available in 6 programming languages, all with nearly equal functionality: Java, TypeScript/JavaScript, Python, Rust, C++, C
* Significantly shorter code but more documentation comments compared to competing libraries
* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
* Output format: Raw modules/pixels of the QR symbol
* Detects finder-like penalty patterns more accurately than other implementations
* Encodes numeric and special-alphanumeric text in less space than general text
* Open source code under the permissive MIT License
* Open-source code under the permissive MIT License
Manual parameters:
@ -80,13 +80,11 @@ Manual parameters:
* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
* User can create a list of data segments manually and add ECI segments
More information about QR Code technology and this library's design can be found on the project home page.
Usage
-----
Install this package by downloading the source code ZIP file from PyPI_, or by running ``pip install qrcodegen``.
Examples:
Examples
--------
::
@ -103,11 +101,7 @@ Examples:
for x in range(qr1.get_size()):
(... paint qr1.get_module(x, y) ...)
More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/python/qrcodegen-demo.py .
API documentation is in the source file itself, with a summary comment at the top: https://github.com/nayuki/QR-Code-generator/blob/master/python/qrcodegen.py .
.. _PyPI: https://pypi.python.org/pypi/qrcodegen""",
More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/python/qrcodegen-demo.py .""",
py_modules = ["qrcodegen"],
)

8
rust-no-heap/Cargo.toml Normal file
View File

@ -0,0 +1,8 @@
[package]
name = "qrcodegen"
version = "1.8.0"
authors = ["Project Nayuki"]
description = "High-quality QR Code generator library"
homepage = "https://www.nayuki.io/page/qr-code-generator-library"
repository = "https://github.com/nayuki/QR-Code-generator"
license = "MIT"

71
rust-no-heap/Readme.markdown Normal file
View File

@ -0,0 +1,71 @@
QR Code generator library - Rust, no heap
=========================================
Introduction
------------
This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
Features
--------
Core features:
* Significantly shorter code but more documentation comments compared to competing libraries
* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
* Output format: Raw modules/pixels of the QR symbol
* Detects finder-like penalty patterns more accurately than other implementations
* Encodes numeric and special-alphanumeric text in less space than general text
* Completely avoids heap allocation (e.g. `std::vec::Vec`), instead relying on suitably sized buffers from the caller and fixed-size stack allocations
* Open-source code under the permissive MIT License
Manual parameters:
* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
* User can create a list of data segments manually and add ECI segments
More information about QR Code technology and this library's design can be found on the project home page.
Examples
--------
```rust
extern crate qrcodegen;
use qrcodegen::Mask;
use qrcodegen::QrCode;
use qrcodegen::QrCodeEcc;
use qrcodegen::Version;
// Text data
let mut outbuffer = vec![0u8; Version::MAX.buffer_len()];
let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
let qr = QrCode::encode_text("Hello, world!",
&mut tempbuffer, &mut outbuffer, QrCodeEcc::Medium,
Version::MIN, Version::MAX, None, true).unwrap();
let svg = to_svg_string(&qr, 4); // See qrcodegen-demo
// Binary data
let mut outbuffer = vec![0u8; Version::MAX.buffer_len()];
let mut dataandtemp = vec![0u8; Version::MAX.buffer_len()];
dataandtemp[0] = 0xE3;
dataandtemp[1] = 0x81;
dataandtemp[2] = 0x82;
let qr = QrCode::encode_binary(&mut dataandtemp, 3,
&mut outbuffer, QrCodeEcc::High,
Version::new(2), Version::new(7),
Some(Mask::new(4)), false).unwrap();
for y in 0 .. qr.size() {
for x in 0 .. qr.size() {
(... paint qr.get_module(x, y) ...)
}
}
```
More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/rust-no-heap/examples/qrcodegen-demo.rs .

267
rust-no-heap/examples/qrcodegen-demo.rs Normal file
View File

@ -0,0 +1,267 @@
/*
* QR Code generator demo (Rust, no heap)
*
* 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) Project Nayuki. (MIT License)
* https://www.nayuki.io/page/qr-code-generator-library
*
* 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.
*/
extern crate qrcodegen;
use qrcodegen::Mask;
use qrcodegen::QrCode;
use qrcodegen::QrCodeEcc;
use qrcodegen::QrSegment;
use qrcodegen::QrSegmentMode;
use qrcodegen::Version;
// The main application program.
fn main() {
do_basic_demo();
do_variety_demo();
do_segment_demo();
do_mask_demo();
}
/*---- Demo suite ----*/
// Creates a single QR Code, then prints it to the console.
fn do_basic_demo() {
let text: &'static str = "Hello, world!"; // User-supplied Unicode text
let errcorlvl: QrCodeEcc = QrCodeEcc::Low; // Error correction level
// Make and print the QR Code symbol
let mut outbuffer = vec![0u8; Version::MAX.buffer_len()];
let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
let qr: QrCode = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer,
errcorlvl, Version::MIN, Version::MAX, None, true).unwrap();
// Note: qr has a reference to outbuffer, so outbuffer needs to outlive qr
std::mem::drop(tempbuffer); // Optional, because tempbuffer is only needed during encode_text()
print_qr(&qr);
println!("{}", to_svg_string(&qr, 4));
}
// Creates a variety of QR Codes that exercise different features of the library, and prints each one to the console.
fn do_variety_demo() {
{ // Numeric mode encoding (3.33 bits per digit)
let mut outbuffer = vec![0u8; Version::MAX.buffer_len()];
let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
let qr = QrCode::encode_text("314159265358979323846264338327950288419716939937510",
&mut tempbuffer, &mut outbuffer, QrCodeEcc::Medium, Version::MIN, Version::MAX, None, true).unwrap();
print_qr(&qr);
}
{ // Alphanumeric mode encoding (5.5 bits per character)
let mut outbuffer = vec![0u8; Version::MAX.buffer_len()];
let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
let qr = QrCode::encode_text("DOLLAR-AMOUNT:$39.87 PERCENTAGE:100.00% OPERATIONS:+-*/",
&mut tempbuffer, &mut outbuffer, QrCodeEcc::High, Version::MIN, Version::MAX, None, true).unwrap();
print_qr(&qr);
}
{ // Unicode text as UTF-8
let mut outbuffer = vec![0u8; Version::MAX.buffer_len()];
let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
let qr = QrCode::encode_text("こんにちwa、世界！ αβγδ",
&mut tempbuffer, &mut outbuffer, QrCodeEcc::Quartile, Version::MIN, Version::MAX, None, true).unwrap();
print_qr(&qr);
}
{ // Moderately large QR Code using longer text (from Lewis Carroll's Alice in Wonderland)
let text = concat!(
"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.");
let mut outbuffer = vec![0u8; Version::MAX.buffer_len()];
let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
let qr = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer,
QrCodeEcc::High, Version::MIN, Version::MAX, None, true).unwrap();
print_qr(&qr);
}
}
// Creates QR Codes with manually specified segments for better compactness.
fn do_segment_demo() {
{ // Illustration "silver"
let silver0 = "THE SQUARE ROOT OF 2 IS 1.";
let silver1 = "41421356237309504880168872420969807856967187537694807317667973799";
let mut outbuffer = vec![0u8; Version::MAX.buffer_len()];
let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
let qr = QrCode::encode_text(&[silver0, silver1].concat(), &mut tempbuffer, &mut outbuffer,
QrCodeEcc::Low, Version::MIN, Version::MAX, None, true).unwrap();
print_qr(&qr);
let (tempbuf0, tempbuf1) = tempbuffer.split_at_mut(QrSegment::calc_buffer_size(QrSegmentMode::Alphanumeric, silver0.len()).unwrap());
let segs = [
QrSegment::make_alphanumeric(silver0, tempbuf0),
QrSegment::make_numeric(silver1, tempbuf1),
];
let (datacodewordslen, ecl, version) = QrCode::encode_segments_to_codewords(
&segs, &mut outbuffer, QrCodeEcc::Low, Version::MIN, Version::MAX, true).unwrap();
std::mem::drop(segs); // Implied, because segs has references to tempbuffer, but tempbuffer will be reused in encode_codewords()
let qr = QrCode::encode_codewords(&mut outbuffer, datacodewordslen, &mut tempbuffer, ecl, version, None);
print_qr(&qr);
}
{ // Illustration "golden"
let golden0 = "Golden ratio φ = 1.";
let golden1 = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374";
let golden2 = "......";
let mut outbuffer = vec![0u8; Version::MAX.buffer_len()];
let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
let qr = QrCode::encode_text(&[golden0, golden1, golden2].concat(), &mut tempbuffer, &mut outbuffer,
QrCodeEcc::Low, Version::MIN, Version::MAX, None, true).unwrap();
print_qr(&qr);
let (tempbuf1, tempbuf2) = tempbuffer.split_at_mut(QrSegment::calc_buffer_size(QrSegmentMode::Numeric, golden1.len()).unwrap());
let segs = [
QrSegment::make_bytes(golden0.as_bytes()),
QrSegment::make_numeric(golden1, tempbuf1),
QrSegment::make_alphanumeric(golden2, tempbuf2),
];
let (datacodewordslen, ecl, version) = QrCode::encode_segments_to_codewords(
&segs, &mut outbuffer, QrCodeEcc::Low, Version::MIN, Version::MAX, true).unwrap();
let qr = QrCode::encode_codewords(&mut outbuffer, datacodewordslen, &mut tempbuffer, ecl, version, None);
print_qr(&qr);
}
{ // Illustration "Madoka": kanji, kana, Cyrillic, full-width Latin, Greek characters
let madoka = "「魔法少女まどか☆マギカ」って、　ИАИ　ｄｅｓｕ　κα？";
let mut outbuffer = vec![0u8; Version::MAX.buffer_len()];
let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
let qr = QrCode::encode_text(madoka, &mut outbuffer, &mut tempbuffer,
QrCodeEcc::Low, Version::MIN, Version::MAX, None, true).unwrap();
print_qr(&qr);
let kanjichars: Vec<u32> = vec![ // Kanji mode encoding (13 bits per character)
0x0035, 0x1002, 0x0FC0, 0x0AED, 0x0AD7,
0x015C, 0x0147, 0x0129, 0x0059, 0x01BD,
0x018D, 0x018A, 0x0036, 0x0141, 0x0144,
0x0001, 0x0000, 0x0249, 0x0240, 0x0249,
0x0000, 0x0104, 0x0105, 0x0113, 0x0115,
0x0000, 0x0208, 0x01FF, 0x0008,
];
let mut bb = qrcodegen::BitBuffer::new(&mut tempbuffer);
for &c in &kanjichars {
bb.append_bits(c, 13);
}
let segs = [
{
let bitlen = bb.len();
QrSegment::new(qrcodegen::QrSegmentMode::Kanji, kanjichars.len(), &tempbuffer, bitlen)
},
];
let (datacodewordslen, ecl, version) = QrCode::encode_segments_to_codewords(
&segs, &mut outbuffer, QrCodeEcc::Low, Version::MIN, Version::MAX, true).unwrap();
let qr = QrCode::encode_codewords(&mut outbuffer, datacodewordslen, &mut tempbuffer, ecl, version, None);
print_qr(&qr);
}
}
// Creates QR Codes with the same size and contents but different mask patterns.
fn do_mask_demo() {
{ // Project Nayuki URL
let text = "https://www.nayuki.io/";
let mut outbuffer = vec![0u8; Version::MAX.buffer_len()];
let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
let qr = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer, QrCodeEcc::High,
Version::MIN, Version::MAX, None, true).unwrap(); // Automatic mask
print_qr(&qr);
let qr = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer, QrCodeEcc::High,
Version::MIN, Version::MAX, Some(Mask::new(3)), true).unwrap(); // Force mask 3
print_qr(&qr);
}
{ // Chinese text as UTF-8
let text = "維基百科（Wikipedia，聆聽i/ˌwɪkᵻˈpiːdi.ə/）是一個自由內容、公開編輯且多語言的網路百科全書協作計畫";
let mut outbuffer = vec![0u8; Version::MAX.buffer_len()];
let mut tempbuffer = vec![0u8; Version::MAX.buffer_len()];
let qr = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer, QrCodeEcc::Medium,
Version::MIN, Version::MAX, Some(Mask::new(0)), true).unwrap(); // Force mask 0
print_qr(&qr);
let qr = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer, QrCodeEcc::Medium,
Version::MIN, Version::MAX, Some(Mask::new(1)), true).unwrap(); // Force mask 1
print_qr(&qr);
let qr = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer, QrCodeEcc::Medium,
Version::MIN, Version::MAX, Some(Mask::new(5)), true).unwrap(); // Force mask 5
print_qr(&qr);
let qr = QrCode::encode_text(text, &mut tempbuffer, &mut outbuffer, QrCodeEcc::Medium,
Version::MIN, Version::MAX, Some(Mask::new(7)), true).unwrap(); // Force mask 7
print_qr(&qr);
}
}
/*---- Utilities ----*/
// Returns a string of SVG code for an image depicting
// the given QR Code, with the given number of border modules.
// The string always uses Unix newlines (\n), regardless of the platform.
fn to_svg_string(qr: &QrCode, border: i32) -> String {
assert!(border >= 0, "Border must be non-negative");
let mut result = String::new();
result += "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
result += "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n";
let dimension = qr.size().checked_add(border.checked_mul(2).unwrap()).unwrap();
result += &format!(
"<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 {0} {0}\" stroke=\"none\">\n", dimension);
result += "\t<rect width=\"100%\" height=\"100%\" fill=\"#FFFFFF\"/>\n";
result += "\t<path d=\"";
for y in 0 .. qr.size() {
for x in 0 .. qr.size() {
if qr.get_module(x, y) {
if x != 0 || y != 0 {
result += " ";
}
result += &format!("M{},{}h1v1h-1z", x + border, y + border);
}
}
}
result += "\" fill=\"#000000\"/>\n";
result += "</svg>\n";
result
}
// Prints the given QrCode object to the console.
fn print_qr(qr: &QrCode) {
let border: i32 = 4;
for y in -border .. qr.size() + border {
for x in -border .. qr.size() + border {
let c: char = if qr.get_module(x, y) { '█' } else { ' ' };
print!("{0}{0}", c);
}
println!();
}
println!();
}

1476
rust-no-heap/src/lib.rs Normal file
View File

File diff suppressed because it is too large Load Diff

2
rust/Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "qrcodegen"
version = "1.7.0"
version = "1.8.0"
authors = ["Project Nayuki"]
description = "High-quality QR Code generator library"
homepage = "https://www.nayuki.io/page/qr-code-generator-library"

20
rust/Readme.markdown
View File

@ -1,5 +1,5 @@
QR Code generator library
=========================
QR Code generator library - Rust
================================
Introduction
@ -15,13 +15,12 @@ Features
Core features:
* Available in 6 programming languages, all with nearly equal functionality: Java, TypeScript/JavaScript, Python, Rust, C++, C
* Significantly shorter code but more documentation comments compared to competing libraries
* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
* Output format: Raw modules/pixels of the QR symbol
* Detects finder-like penalty patterns more accurately than other implementations
* Encodes numeric and special-alphanumeric text in less space than general text
* Open source code under the permissive MIT License
* Open-source code under the permissive MIT License
Manual parameters:
@ -30,10 +29,13 @@ Manual parameters:
* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
* User can create a list of data segments manually and add ECI segments
More information about QR Code technology and this library's design can be found on the project home page.
Examples
--------
```rust
extern crate qrcodegen;
use qrcodegen::Mask;
use qrcodegen::QrCode;
@ -47,14 +49,16 @@ Examples
let svg = to_svg_string(&qr, 4); // See qrcodegen-demo
// Manual operation
let chrs: Vec<char> = "3141592653589793238462643383".chars().collect();
let segs = QrSegment::make_segments(&chrs);
let qr = QrCode::encode_segments_advanced(&segs, QrCodeEcc::High,
Version::new(5), Version::new(5), Some(Mask::new(2)), false).unwrap();
let text: &str = "3141592653589793238462643383";
let segs = QrSegment::make_segments(text);
let qr = QrCode::encode_segments_advanced(&segs,
QrCodeEcc::High, Version::new(5), Version::new(5),
Some(Mask::new(2)), false).unwrap();
for y in 0 .. qr.size() {
for x in 0 .. qr.size() {
(... paint qr.get_module(x, y) ...)
}
}
```
More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/rust/examples/qrcodegen-demo.rs .

18
rust/examples/qrcodegen-demo.rs
View File

@ -92,8 +92,8 @@ fn do_segment_demo() {
print_qr(&qr);
let segs = vec![
QrSegment::make_alphanumeric(&to_chars(silver0)),
QrSegment::make_numeric(&to_chars(silver1)),
QrSegment::make_alphanumeric(silver0),
QrSegment::make_numeric(silver1),
];
let qr = QrCode::encode_segments(&segs, QrCodeEcc::Low).unwrap();
print_qr(&qr);
@ -107,8 +107,8 @@ fn do_segment_demo() {
let segs = vec![
QrSegment::make_bytes(golden0.as_bytes()),
QrSegment::make_numeric(&to_chars(golden1)),
QrSegment::make_alphanumeric(&to_chars(golden2)),
QrSegment::make_numeric(golden1),
QrSegment::make_alphanumeric(golden2),
];
let qr = QrCode::encode_segments(&segs, QrCodeEcc::Low).unwrap();
print_qr(&qr);
@ -141,14 +141,14 @@ fn do_segment_demo() {
// Creates QR Codes with the same size and contents but different mask patterns.
fn do_mask_demo() {
// Project Nayuki URL
let segs = QrSegment::make_segments(&to_chars("https://www.nayuki.io/"));
let segs = QrSegment::make_segments("https://www.nayuki.io/");
let qr = QrCode::encode_segments_advanced(&segs, QrCodeEcc::High, Version::MIN, Version::MAX, None, true).unwrap(); // Automatic mask
print_qr(&qr);
let qr = QrCode::encode_segments_advanced(&segs, QrCodeEcc::High, Version::MIN, Version::MAX, Some(Mask::new(3)), true).unwrap(); // Force mask 3
print_qr(&qr);
// Chinese text as UTF-8
let segs = QrSegment::make_segments(&to_chars("維基百科（Wikipedia，聆聽i/ˌwɪkᵻˈpiːdi.ə/）是一個自由內容、公開編輯且多語言的網路百科全書協作計畫"));
let segs = QrSegment::make_segments("維基百科（Wikipedia，聆聽i/ˌwɪkᵻˈpiːdi.ə/）是一個自由內容、公開編輯且多語言的網路百科全書協作計畫");
let qr = QrCode::encode_segments_advanced(&segs, QrCodeEcc::Medium, Version::MIN, Version::MAX, Some(Mask::new(0)), true).unwrap(); // Force mask 0
print_qr(&qr);
let qr = QrCode::encode_segments_advanced(&segs, QrCodeEcc::Medium, Version::MIN, Version::MAX, Some(Mask::new(1)), true).unwrap(); // Force mask 1
@ -204,9 +204,3 @@ fn print_qr(qr: &QrCode) {
}
println!();
}
// Converts the given borrowed string slice to a new character vector.
fn to_chars(text: &str) -> Vec<char> {
text.chars().collect()
}

163
rust/src/lib.rs
View File

@ -35,13 +35,12 @@
//!
//! Core features:
//!
//! - Available in 6 programming languages, all with nearly equal functionality: Java, TypeScript/JavaScript, Python, Rust, C++, C
//! - Significantly shorter code but more documentation comments compared to competing libraries
//! - Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
//! - Output format: Raw modules/pixels of the QR symbol
//! - Detects finder-like penalty patterns more accurately than other implementations
//! - Encodes numeric and special-alphanumeric text in less space than general text
//! - Open source code under the permissive MIT License
//! - Open-source code under the permissive MIT License
//!
//! Manual parameters:
//!
@ -50,6 +49,8 @@
//! - User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
//! - User can create a list of data segments manually and add ECI segments
//!
//! More information about QR Code technology and this library's design can be found on the project home page.
//!
//! # Examples
//!
//! ```
@ -72,8 +73,8 @@
//! Manual operation:
//!
//! ```
//! let chrs: Vec<char> = "3141592653589793238462643383".chars().collect();
//! let segs = QrSegment::make_segments(&chrs);
//! let text: &str = "3141592653589793238462643383";
//! let segs = QrSegment::make_segments(text);
//! let qr = QrCode::encode_segments_advanced(&segs, QrCodeEcc::High,
//! Version::new(5), Version::new(5), Some(Mask::new(2)), false).unwrap();
//! for y in 0 .. qr.size() {
@ -84,6 +85,10 @@
//! ```
#![forbid(unsafe_code)]
use std::convert::TryFrom;
/*---- QrCode functionality ----*/
/// A QR Code symbol, which is a type of two-dimension barcode.
@ -152,8 +157,7 @@ impl QrCode {
/// Returns a wrapped `QrCode` if successful, or `Err` if the
/// data is too long to fit in any version at the given ECC level.
pub fn encode_text(text: &str, ecl: QrCodeEcc) -> Result<Self,DataTooLong> {
let chrs: Vec<char> = text.chars().collect();
let segs: Vec<QrSegment> = QrSegment::make_segments(&chrs);
let segs: Vec<QrSegment> = QrSegment::make_segments(text);
QrCode::encode_segments(&segs, ecl)
}
@ -205,24 +209,23 @@ impl QrCode {
/// Returns a wrapped `QrCode` if successful, or `Err` if the data is too
/// long to fit in any version in the given range at the given ECC level.
pub fn encode_segments_advanced(segs: &[QrSegment], mut ecl: QrCodeEcc,
minversion: Version, maxversion: Version, mask: Option<Mask>, boostecl: bool) -> Result<Self,DataTooLong> {
assert!(minversion.value() <= maxversion.value(), "Invalid value");
minversion: Version, maxversion: Version, mask: Option<Mask>, boostecl: bool)
-> Result<Self,DataTooLong> {
assert!(minversion <= maxversion, "Invalid value");
// Find the minimal version number to use
let mut version: Version = minversion;
let datausedbits: usize = loop {
// Number of data bits available
let datacapacitybits: usize = QrCode::get_num_data_codewords(version, ecl) * 8;
let datacapacitybits: usize = QrCode::get_num_data_codewords(version, ecl) * 8; // Number of data bits available
let dataused: Option<usize> = QrSegment::get_total_bits(segs, version);
if dataused.map_or(false, |n| n <= datacapacitybits) {
break dataused.unwrap(); // This version number is found to be suitable
} else if version.value() >= maxversion.value() { // All versions in the range could not fit the given data
let msg: String = match dataused {
None => String::from("Segment too long"),
Some(n) => format!("Data length = {} bits, Max capacity = {} bits",
n, datacapacitybits),
};
return Err(DataTooLong(msg));
} else if version >= maxversion { // All versions in the range could not fit the given data
return Err(match dataused {
None => DataTooLong::SegmentTooLong,
Some(n) => DataTooLong::DataOverCapacity(n, datacapacitybits),
});
} else {
version = Version::new(version.value() + 1);
}
@ -239,19 +242,19 @@ impl QrCode {
let mut bb = BitBuffer(Vec::new());
for seg in segs {
bb.append_bits(seg.mode.mode_bits(), 4);
bb.append_bits(seg.numchars as u32, seg.mode.num_char_count_bits(version));
bb.append_bits(u32::try_from(seg.numchars).unwrap(), seg.mode.num_char_count_bits(version));
bb.0.extend_from_slice(&seg.data);
}
assert_eq!(bb.0.len(), datausedbits);
debug_assert_eq!(bb.0.len(), datausedbits);
// Add terminator and pad up to a byte if applicable
let datacapacitybits: usize = QrCode::get_num_data_codewords(version, ecl) * 8;
assert!(bb.0.len() <= datacapacitybits);
debug_assert!(bb.0.len() <= datacapacitybits);
let numzerobits: usize = std::cmp::min(4, datacapacitybits - bb.0.len());
bb.append_bits(0, numzerobits as u8);
bb.append_bits(0, u8::try_from(numzerobits).unwrap());
let numzerobits: usize = bb.0.len().wrapping_neg() & 7;
bb.append_bits(0, numzerobits as u8);
assert_eq!(bb.0.len() % 8, 0, "Assertion error");
bb.append_bits(0, u8::try_from(numzerobits).unwrap());
debug_assert_eq!(bb.0.len() % 8, 0);
// Pad with alternating bytes until data capacity is reached
for &padbyte in [0xEC, 0x11].iter().cycle() {
@ -279,7 +282,7 @@ impl QrCode {
///
/// This is a low-level API that most users should not use directly.
/// A mid-level API is the `encode_segments()` function.
pub fn encode_codewords(ver: Version, ecl: QrCodeEcc, datacodewords: &[u8], mut mask: Option<Mask>) -> Self {
pub fn encode_codewords(ver: Version, ecl: QrCodeEcc, datacodewords: &[u8], mut msk: Option<Mask>) -> Self {
// Initialize fields
let size = usize::from(ver.value()) * 4 + 17;
let mut result = Self {
@ -297,24 +300,24 @@ impl QrCode {
result.draw_codewords(&allcodewords);
// Do masking
if mask.is_none() { // Automatically choose best mask
if msk.is_none() { // Automatically choose best mask
let mut minpenalty = std::i32::MAX;
for i in 0u8 .. 8 {
let newmask = Mask::new(i);
result.apply_mask(newmask);
result.draw_format_bits(newmask);
let i = Mask::new(i);
result.apply_mask(i);
result.draw_format_bits(i);
let penalty: i32 = result.get_penalty_score();
if penalty < minpenalty {
mask = Some(newmask);
msk = Some(i);
minpenalty = penalty;
}
result.apply_mask(newmask); // Undoes the mask due to XOR
result.apply_mask(i); // Undoes the mask due to XOR
}
}
let mask: Mask = mask.unwrap();
result.mask = mask;
result.apply_mask(mask); // Apply the final choice of mask
result.draw_format_bits(mask); // Overwrite old format bits
let msk: Mask = msk.unwrap();
result.mask = msk;
result.apply_mask(msk); // Apply the final choice of mask
result.draw_format_bits(msk); // Overwrite old format bits
result.isfunction.clear();
result.isfunction.shrink_to_fit();
@ -354,7 +357,7 @@ impl QrCode {
/// The top left corner has the coordinates (x=0, y=0). If the given
/// coordinates are out of bounds, then `false` (light) is returned.
pub fn get_module(&self, x: i32, y: i32) -> bool {
0 <= x && x < self.size && 0 <= y && y < self.size && self.module(x, y)
(0 .. self.size).contains(&x) && (0 .. self.size).contains(&y) && self.module(x, y)
}
@ -417,7 +420,7 @@ impl QrCode {
}
(data << 10 | rem) ^ 0x5412 // uint15
};
assert_eq!(bits >> 15, 0, "Assertion error");
debug_assert_eq!(bits >> 15, 0);
// Draw first copy
for i in 0 .. 6 {
@ -458,7 +461,7 @@ impl QrCode {
}
data << 12 | rem // uint18
};
assert!(bits >> 18 == 0, "Assertion error");
debug_assert_eq!(bits >> 18, 0);
// Draw two copies
for i in 0 .. 18 {
@ -478,7 +481,7 @@ impl QrCode {
for dx in -4 ..= 4 {
let xx: i32 = x + dx;
let yy: i32 = y + dy;
if 0 <= xx && xx < self.size && 0 <= yy && yy < self.size {
if (0 .. self.size).contains(&xx) && (0 .. self.size).contains(&yy) {
let dist: i32 = std::cmp::max(dx.abs(), dy.abs()); // Chebyshev/infinity norm
self.set_function_module(xx, yy, dist != 2 && dist != 4);
}
@ -570,7 +573,7 @@ impl QrCode {
let upward: bool = (right + 1) & 2 == 0;
let y: i32 = if upward { self.size - 1 - vert } else { vert }; // Actual y coordinate
if !self.isfunction[(y * self.size + x) as usize] && i < data.len() * 8 {
*self.module_mut(x, y) = get_bit(u32::from(data[i >> 3]), 7 - ((i & 7) as i32));
*self.module_mut(x, y) = get_bit(u32::from(data[i >> 3]), 7 - ((i as i32) & 7));
i += 1;
}
// If this QR Code has any remainder bits (0 to 7), they were assigned as
@ -579,7 +582,7 @@ impl QrCode {
}
right -= 2;
}
assert_eq!(i, data.len() * 8, "Assertion error");
debug_assert_eq!(i, data.len() * 8);
}
@ -680,7 +683,9 @@ impl QrCode {
let total: i32 = size * size; // Note that size is odd, so dark/total != 1/2
// Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
let k: i32 = ((dark * 20 - total * 10).abs() + total - 1) / total - 1;
debug_assert!(0 <= k && k <= 9);
result += k * PENALTY_N4;
debug_assert!(0 <= result && result <= 2568888); // Non-tight upper bound based on default values of PENALTY_N1, ..., N4
result
}
@ -720,7 +725,7 @@ impl QrCode {
result -= 36;
}
}
assert!(208 <= result && result <= 29648);
debug_assert!((208 ..= 29648).contains(&result));
result
}
@ -744,7 +749,7 @@ impl QrCode {
// Returns a Reed-Solomon ECC generator polynomial for the given degree. This could be
// implemented as a lookup table over all possible parameter values, instead of as an algorithm.
fn reed_solomon_compute_divisor(degree: usize) -> Vec<u8> {
assert!(1 <= degree && degree <= 255, "Degree out of range");
assert!((1 ..= 255).contains(&degree), "Degree out of range");
// Polynomial coefficients are 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].
let mut result = vec![0u8; degree - 1];
@ -832,7 +837,7 @@ impl FinderPenalty {
pub fn count_patterns(&self) -> i32 {
let rh = &self.run_history;
let n = rh[1];
assert!(n <= self.qr_size * 3);
debug_assert!(n <= self.qr_size * 3);
let core = n > 0 && rh[2] == n && rh[3] == n * 3 && rh[4] == n && rh[5] == n;
( i32::from(core && rh[0] >= n * 4 && rh[6] >= n)
+ i32::from(core && rh[6] >= n * 4 && rh[0] >= n))
@ -979,13 +984,13 @@ impl QrSegment {
/// Returns a segment representing the given string of decimal digits encoded in numeric mode.
///
/// Panics if the string contains non-digit characters.
pub fn make_numeric(text: &[char]) -> Self {
pub fn make_numeric(text: &str) -> Self {
let mut bb = BitBuffer(Vec::with_capacity(text.len() * 3 + (text.len() + 2) / 3));
let mut accumdata: u32 = 0;
let mut accumcount: u8 = 0;
for &c in text {
assert!('0' <= c && c <= '9', "String contains non-numeric characters");
accumdata = accumdata * 10 + (u32::from(c) - u32::from('0'));
for b in text.bytes() {
assert!((b'0' ..= b'9').contains(&b), "String contains non-numeric characters");
accumdata = accumdata * 10 + u32::from(b - b'0');
accumcount += 1;
if accumcount == 3 {
bb.append_bits(accumdata, 10);
@ -1006,14 +1011,14 @@ impl QrSegment {
/// dollar, percent, asterisk, plus, hyphen, period, slash, colon.
///
/// Panics if the string contains non-encodable characters.
pub fn make_alphanumeric(text: &[char]) -> Self {
pub fn make_alphanumeric(text: &str) -> Self {
let mut bb = BitBuffer(Vec::with_capacity(text.len() * 5 + (text.len() + 1) / 2));
let mut accumdata: u32 = 0;
let mut accumcount: u32 = 0;
for &c in text {
let i: usize = ALPHANUMERIC_CHARSET.iter().position(|&x| x == c)
for c in text.chars() {
let i: usize = ALPHANUMERIC_CHARSET.find(c)
.expect("String contains unencodable characters in alphanumeric mode");
accumdata = accumdata * 45 + (i as u32);
accumdata = accumdata * 45 + u32::try_from(i).unwrap();
accumcount += 1;
if accumcount == 2 {
bb.append_bits(accumdata, 11);
@ -1032,16 +1037,19 @@ impl QrSegment {
///
/// The result may use various segment modes and switch
/// modes to optimize the length of the bit stream.
pub fn make_segments(text: &[char]) -> Vec<Self> {
pub fn make_segments(text: &str) -> Vec<Self> {
if text.is_empty() {
vec![]
} else if QrSegment::is_numeric(text) {
vec![QrSegment::make_numeric(text)]
} else if QrSegment::is_alphanumeric(text) {
vec![QrSegment::make_alphanumeric(text)]
} else {
let s: String = text.iter().cloned().collect();
vec![QrSegment::make_bytes(s.as_bytes())]
vec![
if QrSegment::is_numeric(text) {
QrSegment::make_numeric(text)
} else if QrSegment::is_alphanumeric(text) {
QrSegment::make_alphanumeric(text)
} else {
QrSegment::make_bytes(text.as_bytes())
}
]
}
}
@ -1053,10 +1061,10 @@ impl QrSegment {
if assignval < (1 << 7) {
bb.append_bits(assignval, 8);
} else if assignval < (1 << 14) {
bb.append_bits(2, 2);
bb.append_bits(0b10, 2);
bb.append_bits(assignval, 14);
} else if assignval < 1_000_000 {
bb.append_bits(6, 3);
bb.append_bits(0b110, 3);
bb.append_bits(assignval, 21);
} else {
panic!("ECI assignment value out of range");
@ -1106,7 +1114,7 @@ impl QrSegment {
for seg in segs {
let ccbits: u8 = seg.mode.num_char_count_bits(version);
// ccbits can be as large as 16, but usize can be as small as 16
if let Some(limit) = 1usize.checked_shl(u32::from(ccbits)) {
if let Some(limit) = 1usize.checked_shl(ccbits.into()) {
if seg.numchars >= limit {
return None; // The segment's length doesn't fit the field's bit width
}
@ -1121,8 +1129,8 @@ impl QrSegment {
/// Tests whether the given string can be encoded as a segment in numeric mode.
///
/// A string is encodable iff each character is in the range 0 to 9.
pub fn is_numeric(text: &[char]) -> bool {
text.iter().all(|&c| '0' <= c && c <= '9')
pub fn is_numeric(text: &str) -> bool {
text.chars().all(|c| ('0' ..= '9').contains(&c))
}
@ -1130,8 +1138,8 @@ impl QrSegment {
///
/// A string is encodable iff each character is in the following set: 0 to 9, A to Z
/// (uppercase only), space, dollar, percent, asterisk, plus, hyphen, period, slash, colon.
pub fn is_alphanumeric(text: &[char]) -> bool {
text.iter().all(|c| ALPHANUMERIC_CHARSET.contains(c))
pub fn is_alphanumeric(text: &str) -> bool {
text.chars().all(|c| ALPHANUMERIC_CHARSET.contains(c))
}
}
@ -1139,9 +1147,7 @@ impl QrSegment {
// The set of all legal characters in alphanumeric mode,
// where each character value maps to the index in the string.
static ALPHANUMERIC_CHARSET: [char; 45] = ['0','1','2','3','4','5','6','7','8','9',
'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',
' ','$','%','*','+','-','.','/',':'];
static ALPHANUMERIC_CHARSET: &str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
@ -1204,7 +1210,7 @@ impl BitBuffer {
///
/// Requires len &#x2264; 31 and val &lt; 2<sup>len</sup>.
pub fn append_bits(&mut self, val: u32, len: u8) {
assert!(len <= 31 && (val >> len) == 0, "Value out of range");
assert!(len <= 31 && val >> len == 0, "Value out of range");
self.0.extend((0 .. i32::from(len)).rev().map(|i| get_bit(val, i))); // Append bit by bit
}
}
@ -1226,17 +1232,20 @@ impl BitBuffer {
/// - Change the text to fit the character set of a particular segment mode (e.g. alphanumeric).
/// - Propagate the error upward to the caller/user.
#[derive(Debug, Clone)]
pub struct DataTooLong(String);
pub enum DataTooLong {
SegmentTooLong,
DataOverCapacity(usize, usize),
}
impl std::error::Error for DataTooLong {
fn description(&self) -> &str {
&self.0
}
}
impl std::error::Error for DataTooLong {}
impl std::fmt::Display for DataTooLong {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
f.write_str(&self.0)
match *self {
Self::SegmentTooLong => write!(f, "Segment too long"),
Self::DataOverCapacity(datalen, maxcapacity) =>
write!(f, "Data length = {} bits, Max capacity = {} bits", datalen, maxcapacity),
}
}
}
@ -1256,7 +1265,7 @@ impl Version {
///
/// Panics if the number is outside the range [1, 40].
pub fn new(ver: u8) -> Self {
assert!(Version::MIN.value() <= ver && ver <= Version::MAX.value(), "Version number out of range");
assert!((Version::MIN.value() ..= Version::MAX.value()).contains(&ver), "Version number out of range");
Self(ver)
}

56
typescript-javascript/Readme.markdown Normal file
View File

@ -0,0 +1,56 @@
QR Code generator library - TypeScript
======================================
Introduction
------------
This project aims to be the best, clearest QR Code generator library. The primary goals are flexible options and absolute correctness. Secondary goals are compact implementation size and good documentation comments.
Home page with live JavaScript demo, extensive descriptions, and competitor comparisons: https://www.nayuki.io/page/qr-code-generator-library
Features
--------
Core features:
* Significantly shorter code but more documentation comments compared to competing libraries
* Supports encoding all 40 versions (sizes) and all 4 error correction levels, as per the QR Code Model 2 standard
* Output format: Raw modules/pixels of the QR symbol
* Detects finder-like penalty patterns more accurately than other implementations
* Encodes numeric and special-alphanumeric text in less space than general text
* Open-source code under the permissive MIT License
Manual parameters:
* User can specify minimum and maximum version numbers allowed, then library will automatically choose smallest version in the range that fits the data
* User can specify mask pattern manually, otherwise library will automatically evaluate all 8 masks and select the optimal one
* User can specify absolute error correction level, or allow the library to boost it if it doesn't increase the version number
* User can create a list of data segments manually and add ECI segments
More information about QR Code technology and this library's design can be found on the project home page.
Examples
--------
```typescript
// Name abbreviated for the sake of these examples here
const QRC = qrcodegen.QrCode;
// Simple operation
const qr0 = QRC.encodeText("Hello, world!", QRC.Ecc.MEDIUM);
const svg = toSvgString(qr0, 4); // See qrcodegen-input-demo
// Manual operation
const segs = qrcodegen.QrSegment.makeSegments("3141592653589793238462643383");
const qr1 = QRC.encodeSegments(segs, QRC.Ecc.HIGH, 5, 5, 2, false);
for (let y = 0; y < qr1.size; y++) {
for (let x = 0; x < qr1.size; x++) {
(... paint qr1.getModule(x, y) ...)
}
}
```
More complete set of examples: https://github.com/nayuki/QR-Code-generator/blob/master/typescript-javascript/qrcodegen-output-demo.ts .

10
typescript-javascript/qrcodegen-input-demo.ts
View File

@ -137,7 +137,7 @@ namespace app {
if (0xDC00 <= d && d < 0xE000) // Low surrogate
continue;
}
throw "Invalid UTF-16 string";
throw new RangeError("Invalid UTF-16 string");
}
return result;
}
@ -158,7 +158,7 @@ namespace app {
// The scale must be a positive integer and the border must be a non-negative integer.
function drawCanvas(qr: qrcodegen.QrCode, scale: number, border: number, lightColor: string, darkColor: string, canvas: HTMLCanvasElement): void {
if (scale <= 0 || border < 0)
throw "Value out of range";
throw new RangeError("Value out of range");
const width: number = (qr.size + border * 2) * scale;
canvas.width = width;
canvas.height = width;
@ -176,7 +176,7 @@ namespace app {
// of border modules. The string always uses Unix newlines (\n), regardless of the platform.
function toSvgString(qr: qrcodegen.QrCode, border: number, lightColor: string, darkColor: string): string {
if (border < 0)
throw "Border must be non-negative";
throw new RangeError("Border must be non-negative");
let parts: Array<string> = [];
for (let y = 0; y < qr.size; y++) {
for (let x = 0; x < qr.size; x++) {
@ -215,7 +215,7 @@ namespace app {
const result: HTMLElement|null = document.getElementById(id);
if (result instanceof HTMLElement)
return result;
throw "Assertion error";
throw new Error("Assertion error");
}
@ -223,7 +223,7 @@ namespace app {
const result: HTMLElement = getElem(id);
if (result instanceof HTMLInputElement)
return result;
throw "Assertion error";
throw new Error("Assertion error");
}

2
typescript-javascript/qrcodegen-output-demo.ts
View File

@ -206,7 +206,7 @@ namespace app {
// The scale must be a positive integer and the border must be a non-negative integer.
function drawCanvas(qr: qrcodegen.QrCode, scale: number, border: number, lightColor: string, darkColor: string, canvas: HTMLCanvasElement): void {
if (scale <= 0 || border < 0)
throw "Value out of range";
throw new RangeError("Value out of range");
const width: number = (qr.size + border * 2) * scale;
canvas.width = width;
canvas.height = width;

120
typescript-javascript/qrcodegen.ts
View File

@ -68,7 +68,7 @@ namespace qrcodegen {
// 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.
// The ECC level of the result may be higher than the ecl argument if it can be done without increasing the version.
public static encodeBinary(data: Array<byte>, ecl: QrCode.Ecc): QrCode {
public static encodeBinary(data: Readonly<Array<byte>>, ecl: QrCode.Ecc): QrCode {
const seg: QrSegment = qrcodegen.QrSegment.makeBytes(data);
return QrCode.encodeSegments([seg], ecl);
}
@ -85,13 +85,13 @@ namespace qrcodegen {
// This function allows the user to create a custom sequence of segments that switches
// between modes (such as alphanumeric and byte) to encode text in less space.
// This is a mid-level API; the high-level API is encodeText() and encodeBinary().
public static encodeSegments(segs: Array<QrSegment>, ecl: QrCode.Ecc,
public static encodeSegments(segs: Readonly<Array<QrSegment>>, ecl: QrCode.Ecc,
minVersion: int = 1, maxVersion: int = 40,
mask: int = -1, boostEcl: boolean = true): QrCode {
if (!(QrCode.MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= QrCode.MAX_VERSION)
|| mask < -1 || mask > 7)
throw "Invalid value";
throw new RangeError("Invalid value");
// Find the minimal version number to use
let version: int;
@ -104,7 +104,7 @@ namespace qrcodegen {
break; // This version number is found to be suitable
}
if (version >= maxVersion) // All versions in the range could not fit the given data
throw "Data too long";
throw new RangeError("Data too long");
}
// Increase the error correction level while the data still fits in the current version number
@ -121,17 +121,14 @@ namespace qrcodegen {
for (const b of seg.getData())
bb.push(b);
}
if (bb.length != dataUsedBits)
throw "Assertion error";
assert(bb.length == dataUsedBits);
// Add terminator and pad up to a byte if applicable
const dataCapacityBits: int = QrCode.getNumDataCodewords(version, ecl) * 8;
if (bb.length > dataCapacityBits)
throw "Assertion error";
assert(bb.length <= dataCapacityBits);
appendBits(0, Math.min(4, dataCapacityBits - bb.length), bb);
appendBits(0, (8 - bb.length % 8) % 8, bb);
if (bb.length % 8 != 0)
throw "Assertion error";
assert(bb.length % 8 == 0);
// Pad with alternating bytes until data capacity is reached
for (let padByte = 0xEC; bb.length < dataCapacityBits; padByte ^= 0xEC ^ 0x11)
@ -155,6 +152,11 @@ namespace qrcodegen {
// 21 and 177 (inclusive). This is equal to version * 4 + 17.
public readonly size: int;
// The index of the mask pattern used in this QR Code, which is between 0 and 7 (inclusive).
// Even if a QR Code is created with automatic masking requested (mask = -1),
// the resulting object still has a mask value between 0 and 7.
public readonly mask: int;
// The modules of this QR Code (false = light, true = dark).
// Immutable after constructor finishes. Accessed through getModule().
private readonly modules : Array<Array<boolean>> = [];
@ -177,18 +179,15 @@ namespace qrcodegen {
// The error correction level used in this QR Code.
public readonly errorCorrectionLevel: QrCode.Ecc,
dataCodewords: Array<byte>,
dataCodewords: Readonly<Array<byte>>,
// The index of the mask pattern used in this QR Code, which is between 0 and 7 (inclusive).
// Even if a QR Code is created with automatic masking requested (mask = -1),
// the resulting object still has a mask value between 0 and 7.
public readonly mask: int) {
msk: int) {
// Check scalar arguments
if (version < QrCode.MIN_VERSION || version > QrCode.MAX_VERSION)
throw "Version value out of range";
if (mask < -1 || mask > 7)
throw "Mask value out of range";
throw new RangeError("Version value out of range");
if (msk < -1 || msk > 7)
throw new RangeError("Mask value out of range");
this.size = version * 4 + 17;
// Initialize both grids to be size*size arrays of Boolean false
@ -206,24 +205,23 @@ namespace qrcodegen {
this.drawCodewords(allCodewords);
// Do masking
if (mask == -1) { // Automatically choose best mask
if (msk == -1) { // Automatically choose best mask
let minPenalty: int = 1000000000;
for (let i = 0; i < 8; i++) {
this.applyMask(i);
this.drawFormatBits(i);
const penalty: int = this.getPenaltyScore();
if (penalty < minPenalty) {
mask = i;
msk = i;
minPenalty = penalty;
}
this.applyMask(i); // Undoes the mask due to XOR
}
}
if (mask < 0 || mask > 7)
throw "Assertion error";
this.mask = mask;
this.applyMask(mask); // Apply the final choice of mask
this.drawFormatBits(mask); // Overwrite old format bits
assert(0 <= msk && msk <= 7);
this.mask = msk;
this.applyMask(msk); // Apply the final choice of mask
this.drawFormatBits(msk); // Overwrite old format bits
this.isFunction = [];
}
@ -280,8 +278,7 @@ namespace qrcodegen {
for (let i = 0; i < 10; i++)
rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
const bits = (data << 10 | rem) ^ 0x5412; // uint15
if (bits >>> 15 != 0)
throw "Assertion error";
assert(bits >>> 15 == 0);
// Draw first copy
for (let i = 0; i <= 5; i++)
@ -312,8 +309,7 @@ namespace qrcodegen {
for (let i = 0; i < 12; i++)
rem = (rem << 1) ^ ((rem >>> 11) * 0x1F25);
const bits: int = this.version << 12 | rem; // uint18
if (bits >>> 18 != 0)
throw "Assertion error";
assert(bits >>> 18 == 0);
// Draw two copies
for (let i = 0; i < 18; i++) {
@ -363,11 +359,11 @@ namespace qrcodegen {
// 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.
private addEccAndInterleave(data: Array<byte>): Array<byte> {
private addEccAndInterleave(data: Readonly<Array<byte>>): Array<byte> {
const ver: int = this.version;
const ecl: QrCode.Ecc = this.errorCorrectionLevel;
if (data.length != QrCode.getNumDataCodewords(ver, ecl))
throw "Invalid argument";
throw new RangeError("Invalid argument");
// Calculate parameter numbers
const numBlocks: int = QrCode.NUM_ERROR_CORRECTION_BLOCKS[ecl.ordinal][ver];
@ -397,17 +393,16 @@ namespace qrcodegen {
result.push(block[i]);
});
}
if (result.length != rawCodewords)
throw "Assertion error";
assert(result.length == rawCodewords);
return result;
}
// Draws the given sequence of 8-bit codewords (data and error correction) onto the entire
// data area of this QR Code. Function modules need to be marked off before this is called.
private drawCodewords(data: Array<byte>): void {
private drawCodewords(data: Readonly<Array<byte>>): void {
if (data.length != Math.floor(QrCode.getNumRawDataModules(this.version) / 8))
throw "Invalid argument";
throw new RangeError("Invalid argument");
let i: int = 0; // Bit index into the data
// Do the funny zigzag scan
for (let right = this.size - 1; right >= 1; right -= 2) { // Index of right column in each column pair
@ -427,8 +422,7 @@ namespace qrcodegen {
}
}
}
if (i != data.length * 8)
throw "Assertion error";
assert(i == data.length * 8);
}
@ -439,7 +433,7 @@ namespace qrcodegen {
// QR Code needs exactly one (not zero, two, etc.) mask applied.
private applyMask(mask: int): void {
if (mask < 0 || mask > 7)
throw "Mask value out of range";
throw new RangeError("Mask value out of range");
for (let y = 0; y < this.size; y++) {
for (let x = 0; x < this.size; x++) {
let invert: boolean;
@ -452,7 +446,7 @@ namespace qrcodegen {
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";
default: throw new Error("Unreachable");
}
if (!this.isFunction[y][x] && invert)
this.modules[y][x] = !this.modules[y][x];
@ -529,7 +523,9 @@ namespace qrcodegen {
const total: int = this.size * this.size; // Note that size is odd, so dark/total != 1/2
// Compute the smallest integer k >= 0 such that (45-5k)% <= dark/total <= (55+5k)%
const k: int = Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1;
assert(0 <= k && k <= 9);
result += k * QrCode.PENALTY_N4;
assert(0 <= result && result <= 2568888); // Non-tight upper bound based on default values of PENALTY_N1, ..., N4
return result;
}
@ -559,7 +555,7 @@ namespace qrcodegen {
// The result is in the range [208, 29648]. This could be implemented as a 40-entry lookup table.
private static getNumRawDataModules(ver: int): int {
if (ver < QrCode.MIN_VERSION || ver > QrCode.MAX_VERSION)
throw "Version number out of range";
throw new RangeError("Version number out of range");
let result: int = (16 * ver + 128) * ver + 64;
if (ver >= 2) {
const numAlign: int = Math.floor(ver / 7) + 2;
@ -567,8 +563,7 @@ namespace qrcodegen {
if (ver >= 7)
result -= 36;
}
if (!(208 <= result && result <= 29648))
throw "Assertion error";
assert(208 <= result && result <= 29648);
return result;
}
@ -587,7 +582,7 @@ namespace qrcodegen {
// implemented as a lookup table over all possible parameter values, instead of as an algorithm.
private static reedSolomonComputeDivisor(degree: int): Array<byte> {
if (degree < 1 || degree > 255)
throw "Degree out of range";
throw new RangeError("Degree out of range");
// Polynomial coefficients are 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].
let result: Array<byte> = [];
@ -613,7 +608,7 @@ namespace qrcodegen {
// Returns the Reed-Solomon error correction codeword for the given data and divisor polynomials.
private static reedSolomonComputeRemainder(data: Array<byte>, divisor: Array<byte>): Array<byte> {
private static reedSolomonComputeRemainder(data: Readonly<Array<byte>>, divisor: Readonly<Array<byte>>): Array<byte> {
let result: Array<byte> = divisor.map(_ => 0);
for (const b of data) { // Polynomial division
const factor: byte = b ^ (result.shift() as byte);
@ -629,25 +624,23 @@ namespace qrcodegen {
// are unsigned 8-bit integers. This could be implemented as a lookup table of 256*256 entries of uint8.
private static reedSolomonMultiply(x: byte, y: byte): byte {
if (x >>> 8 != 0 || y >>> 8 != 0)
throw "Byte out of range";
throw new RangeError("Byte out of range");
// Russian peasant multiplication
let z: int = 0;
for (let i = 7; i >= 0; i--) {
z = (z << 1) ^ ((z >>> 7) * 0x11D);
z ^= ((y >>> i) & 1) * x;
}
if (z >>> 8 != 0)
throw "Assertion error";
assert(z >>> 8 == 0);
return z as byte;
}
// Can only be called immediately after a light run is added, and
// returns either 0, 1, or 2. A helper function for getPenaltyScore().
private finderPenaltyCountPatterns(runHistory: Array<int>): int {
private finderPenaltyCountPatterns(runHistory: Readonly<Array<int>>): int {
const n: int = runHistory[1];
if (n > this.size * 3)
throw "Assertion error";
assert(n <= this.size * 3);
const core: boolean = n > 0 && runHistory[2] == n && runHistory[3] == n * 3 && runHistory[4] == n && runHistory[5] == n;
return (core && runHistory[0] >= n * 4 && runHistory[6] >= n ? 1 : 0)
+ (core && runHistory[6] >= n * 4 && runHistory[0] >= n ? 1 : 0);
@ -713,7 +706,7 @@ namespace qrcodegen {
// to the given buffer. Requires 0 <= len <= 31 and 0 <= val < 2^len.
function appendBits(val: int, len: int, bb: Array<bit>): void {
if (len < 0 || len > 31 || val >>> len != 0)
throw "Value out of range";
throw new RangeError("Value out of range");
for (let i = len - 1; i >= 0; i--) // Append bit by bit
bb.push((val >>> i) & 1);
}
@ -725,6 +718,13 @@ namespace qrcodegen {
}
// Throws an exception if the given condition is false.
function assert(cond: boolean): void {
if (!cond)
throw new Error("Assertion error");
}
/*---- Data segment class ----*/
@ -746,7 +746,7 @@ namespace qrcodegen {
// Returns a segment representing the given binary data encoded in
// byte mode. All input byte arrays are acceptable. Any text string
// can be converted to UTF-8 bytes and encoded as a byte mode segment.
public static makeBytes(data: Array<byte>): QrSegment {
public static makeBytes(data: Readonly<Array<byte>>): QrSegment {
let bb: Array<bit> = []
for (const b of data)
appendBits(b, 8, bb);
@ -757,7 +757,7 @@ namespace qrcodegen {
// Returns a segment representing the given string of decimal digits encoded in numeric mode.
public static makeNumeric(digits: string): QrSegment {
if (!QrSegment.isNumeric(digits))
throw "String contains non-numeric characters";
throw new RangeError("String contains non-numeric characters");
let bb: Array<bit> = []
for (let i = 0; i < digits.length; ) { // Consume up to 3 digits per iteration
const n: int = Math.min(digits.length - i, 3);
@ -773,7 +773,7 @@ namespace qrcodegen {
// dollar, percent, asterisk, plus, hyphen, period, slash, colon.
public static makeAlphanumeric(text: string): QrSegment {
if (!QrSegment.isAlphanumeric(text))
throw "String contains unencodable characters in alphanumeric mode";
throw new RangeError("String contains unencodable characters in alphanumeric mode");
let bb: Array<bit> = []
let i: int;
for (i = 0; i + 2 <= text.length; i += 2) { // Process groups of 2
@ -807,17 +807,17 @@ namespace qrcodegen {
public static makeEci(assignVal: int): QrSegment {
let bb: Array<bit> = []
if (assignVal < 0)
throw "ECI assignment value out of range";
throw new RangeError("ECI assignment value out of range");
else if (assignVal < (1 << 7))
appendBits(assignVal, 8, bb);
else if (assignVal < (1 << 14)) {
appendBits(2, 2, bb);
appendBits(0b10, 2, bb);
appendBits(assignVal, 14, bb);
} else if (assignVal < 1000000) {
appendBits(6, 3, bb);
appendBits(0b110, 3, bb);
appendBits(assignVal, 21, bb);
} else
throw "ECI assignment value out of range";
throw new RangeError("ECI assignment value out of range");
return new QrSegment(QrSegment.Mode.ECI, 0, bb);
}
@ -855,7 +855,7 @@ namespace qrcodegen {
private readonly bitData: Array<bit>) {
if (numChars < 0)
throw "Invalid argument";
throw new RangeError("Invalid argument");
this.bitData = bitData.slice(); // Make defensive copy
}
@ -870,7 +870,7 @@ namespace qrcodegen {
// (Package-private) Calculates and returns the number of bits needed to encode the given segments at
// the given version. The result is infinity if a segment has too many characters to fit its length field.
public static getTotalBits(segs: Array<QrSegment>, version: int): number {
public static getTotalBits(segs: Readonly<Array<QrSegment>>, version: int): number {
let result: number = 0;
for (const seg of segs) {
const ccbits: int = seg.mode.numCharCountBits(version);