Render QR codes pixel-exact with an own encoder

nxhmi.qr is a dependency-free QR encoder. Measured in the Editor
simulator: numeric/alphanumeric/byte mode by content, level L, mask 0,
smallest version; scaled to w - 2*dis by width (not clipped to h), last
column run one pixel narrower, logo centred, nothing when too small.
Basic rendering is now 20/20 pixel-exact.

Also: unknown component kinds give a clean CLI error instead of a
traceback.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
mangavalkandClaude Opus 5.5 committed 2026-11-15 16:17:23 +01:00
1 parent f0bcc608b1
commit 842591a14c
10 files changed
+429 -9

No files matched your search

+5 -1
View File
@@ -201,7 +201,11 @@ def main(argv=None):
s = sub.add_parser("dump", help="print pages as JSON"); s.add_argument("hmi"); s.add_argument("--page")
s.add_argument("--encoding", default="latin-1"); s.add_argument("--raw", action="store_true"); s.set_defaults(f=cmd_dump)
a = ap.parse_args(argv)
return a.f(a) or 0
try:
return a.f(a) or 0
except (ValueError, KeyError) as e:
print("error:", e.args[0] if e.args else e, file=sys.stderr)
return 2
if __name__ == "__main__":
+2
View File
@@ -186,6 +186,8 @@ def t_verify(path):
def t_schema(kind):
if kind not in C.KINDS:
raise ValueError("unknown component kind %r; known kinds: %s" % (kind, ", ".join(sorted(C.KINDS))))
tpl = C.TYPES[C.KINDS[kind]]
ctype = C.KINDS[kind]
out = []
+262
View File
@@ -0,0 +1,262 @@
"""Minimal QR code encoder (no dependencies), matching what Nextion draws for the QR code component.
Measured in Nextion Editor 1.68's simulator: byte mode, error correction level L, mask 0 always
(no mask scoring), smallest version that fits. `matrix()` is a plain ISO 18004 encoder; the
choices are parameters so other settings can be produced too.
"""
from __future__ import annotations
# error-correction codewords per block and number of blocks, indexed [level][version]
_ECC_PER_BLOCK = {
"L": [-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],
"M": [-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],
"Q": [-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],
"H": [-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],
}
_BLOCKS = {
"L": [-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],
"M": [-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],
"Q": [-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],
"H": [-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],
}
_FORMAT_LEVEL = {"L": 1, "M": 0, "Q": 3, "H": 2}
_MASKS = [
lambda r, c: (r + c) % 2 == 0,
lambda r, c: r % 2 == 0,
lambda r, c: c % 3 == 0,
lambda r, c: (r + c) % 3 == 0,
lambda r, c: (r // 2 + c // 3) % 2 == 0,
lambda r, c: r * c % 2 + r * c % 3 == 0,
lambda r, c: (r * c % 2 + r * c % 3) % 2 == 0,
lambda r, c: ((r + c) % 2 + r * c % 3) % 2 == 0,
]
def _raw_modules(ver: int) -> int:
n = (16 * ver + 128) * ver + 64
if ver >= 2:
a = ver // 7 + 2
n -= (25 * a - 10) * a - 55
if ver >= 7:
n -= 36
return n
def data_codewords(ver: int, ecc: str = "L") -> int:
return _raw_modules(ver) // 8 - _ECC_PER_BLOCK[ecc][ver] * _BLOCKS[ecc][ver]
ALNUM = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:"
def mode_of(data: bytes) -> str:
"""Numeric if all digits, alphanumeric if all in the QR alnum set, else byte (as the display does)."""
t = data.decode("latin-1")
if t and t.isdigit() and t.isascii():
return "numeric"
if t and all(ch in ALNUM for ch in t):
return "alnum"
return "byte"
def _count_bits(mode: str, ver: int) -> int:
i = 0 if ver < 10 else (1 if ver < 27 else 2)
return {"numeric": (10, 12, 14), "alnum": (9, 11, 13), "byte": (8, 16, 16)}[mode][i]
def _data_bits(data: bytes, mode: str):
bits = []
def put(val, n):
bits.extend((val >> k) & 1 for k in range(n - 1, -1, -1))
t = data.decode("latin-1")
if mode == "numeric":
for k in range(0, len(t), 3):
g = t[k:k + 3]
put(int(g), len(g) * 3 + 1)
elif mode == "alnum":
for k in range(0, len(t) - 1, 2):
put(ALNUM.index(t[k]) * 45 + ALNUM.index(t[k + 1]), 11)
if len(t) % 2:
put(ALNUM.index(t[-1]), 6)
else:
for b in data:
put(b, 8)
return bits
def pick_version(data: bytes, ecc: str = "L", mode: str = None) -> int:
mode = mode or mode_of(data)
n = len(_data_bits(data, mode))
for v in range(1, 41):
if 4 + _count_bits(mode, v) + n <= data_codewords(v, ecc) * 8:
return v
raise ValueError("%d bytes do not fit in a QR code" % len(data))
def _gf_mul(x: int, y: int) -> int:
z = 0
for i in range(7, -1, -1):
z = (z << 1) ^ ((z >> 7) * 0x11D)
z ^= ((y >> i) & 1) * x
return z
def _rs_divisor(degree: int):
res = [0] * (degree - 1) + [1]
root = 1
for _ in range(degree):
for j in range(degree):
res[j] = _gf_mul(res[j], root)
if j + 1 < degree:
res[j] ^= res[j + 1]
root = _gf_mul(root, 2)
return res
def _rs_remainder(data, divisor):
res = [0] * len(divisor)
for b in data:
f = b ^ res.pop(0)
res.append(0)
for i, coef in enumerate(divisor):
res[i] ^= _gf_mul(coef, f)
return res
def _codewords(data: bytes, ver: int, ecc: str, mode: str):
bits = []
def put(val, n):
bits.extend((val >> i) & 1 for i in range(n - 1, -1, -1))
put({"numeric": 1, "alnum": 2, "byte": 4}[mode], 4)
put(len(data), _count_bits(mode, ver))
bits += _data_bits(data, mode)
cap = data_codewords(ver, ecc) * 8
put(0, min(4, cap - len(bits)))
put(0, -len(bits) % 8)
words = [int("".join(map(str, bits[i:i + 8])), 2) for i in range(0, len(bits), 8)]
pad = 0xEC
while len(words) < cap // 8:
words.append(pad)
pad ^= 0xEC ^ 0x11
# split into blocks, add RS codes, interleave
nblocks, eccn = _BLOCKS[ecc][ver], _ECC_PER_BLOCK[ecc][ver]
raw = _raw_modules(ver) // 8
nshort = nblocks - raw % nblocks
short_len = raw // nblocks
div = _rs_divisor(eccn)
blocks, k = [], 0
for i in range(nblocks):
dlen = short_len - eccn + (0 if i < nshort else 1)
d = words[k:k + dlen]
k += dlen
e = _rs_remainder(d, div)
if i < nshort:
d = d + [None]
blocks.append(d + e)
out = []
for i in range(len(blocks[0])):
for j, b in enumerate(blocks):
if b[i] is not None:
out.append(b[i])
return out
def _align_positions(ver: int):
if ver == 1:
return []
n = ver // 7 + 2
step = 26 if ver == 32 else (ver * 4 + n * 2 + 1) // (n * 2 - 2) * 2
size = ver * 4 + 17
return [6] + sorted(size - 7 - i * step for i in range(n - 1))
def matrix(data, ecc: str = "L", mask: int = 0, version: int = None, mode: str = None):
"""QR code modules as a list of rows of booleans (True = dark), without quiet zone.
`data` is bytes or str (str is encoded as latin-1, like the display's text)."""
if isinstance(data, str):
data = data.encode("latin-1")
mode = mode or mode_of(data)
ver = version or pick_version(data, ecc, mode)
size = ver * 4 + 17
m = [[False] * size for _ in range(size)]
fn = [[False] * size for _ in range(size)]
def setf(r, c, dark):
m[r][c] = dark
fn[r][c] = True
for i in range(size): # timing patterns
setf(6, i, i % 2 == 0)
setf(i, 6, i % 2 == 0)
for fr, fc in ((3, 3), (3, size - 4), (size - 4, 3)): # finders + separators
for dr in range(-4, 5):
for dc in range(-4, 5):
r, c = fr + dr, fc + dc
if 0 <= r < size and 0 <= c < size:
d = max(abs(dr), abs(dc))
setf(r, c, d not in (2, 4))
pos = _align_positions(ver)
for i, r in enumerate(pos):
for j, c in enumerate(pos):
if (i == 0 and j == 0) or (i == 0 and j == len(pos) - 1) or (i == len(pos) - 1 and j == 0):
continue
for dr in range(-2, 3):
for dc in range(-2, 3):
setf(r + dr, c + dc, max(abs(dr), abs(dc)) != 1)
def draw_format(msk):
d = _FORMAT_LEVEL[ecc] << 3 | msk
rem = d
for _ in range(10):
rem = (rem << 1) ^ ((rem >> 9) * 0x537)
bits = (d << 10 | rem) ^ 0x5412
g = lambda i: (bits >> i) & 1 == 1
for i in range(6):
setf(i, 8, g(i))
setf(7, 8, g(6))
setf(8, 8, g(7))
setf(8, 7, g(8))
for i in range(9, 15):
setf(8, 14 - i, g(i))
for i in range(8):
setf(8, size - 1 - i, g(i))
for i in range(8, 15):
setf(size - 15 + i, 8, g(i))
setf(size - 8, 8, True) # dark module
draw_format(0) # reserve the format area
if ver >= 7:
rem = ver
for _ in range(12):
rem = (rem << 1) ^ ((rem >> 11) * 0x1F25)
bits = ver << 12 | rem
for i in range(18):
b = (bits >> i) & 1 == 1
a, c = size - 11 + i % 3, i // 3
setf(a, c, b)
setf(c, a, b)
words = _codewords(data, ver, ecc, mode)
i = 0
right = size - 1
while right >= 1:
if right == 6:
right = 5
for vert in range(size):
for j in range(2):
c = right - j
upward = ((right + 1) & 2) == 0
r = size - 1 - vert if upward else vert
if not fn[r][c] and i < len(words) * 8:
m[r][c] = (words[i >> 3] >> (7 - (i & 7))) & 1 == 1
i += 1
right -= 2
f = _MASKS[mask]
for r in range(size):
for c in range(size):
if not fn[r][c] and f(r, c):
m[r][c] = not m[r][c]
draw_format(mask)
return m
+40 -1
View File
@@ -86,6 +86,37 @@ def gauge_needle(w: int, h: int, val: int, wid: int):
for ax in range(lo, lo + wid) for ay in range(lo, lo + wid)}
def qr_rects(txt, w: int, dis: int):
"""Dark rectangles ((x0, y0), (x1, y1)) exclusive, relative to the component, for a QR code
component: the code (see nxhmi.qr) scaled to w - 2*dis pixels starting at (dis, dis);
pixel p shows module p*N//size. The display draws dark runs column by column; the run still
open at the very end (last column, reaching the bottom) comes out one pixel narrower.
The code is square (sized by the width) and is not clipped to the component's height."""
from . import qr
if isinstance(txt, str):
txt = txt.encode("latin-1", "replace")
if not txt:
return []
m = qr.matrix(txt)
n, size = len(m), w - 2 * dis
if size < n: # less than a pixel per module: nothing drawn
return []
edge = [-(-k * size // n) for k in range(n + 1)] # first pixel of module k = ceil(k*size/n)
rects = []
for col in range(n):
r = 0
while r < n:
if not m[r][col]:
r += 1
continue
r0 = r
while r < n and m[r][col]:
r += 1
x1 = edge[col + 1] - (1 if (col == n - 1 and r == n) else 0)
rects.append(((dis + edge[col], dis + edge[r0]), (dis + x1, dis + edge[r])))
return rects
def rgb(v: int):
r, g, b = v >> 11, (v >> 5) & 63, v & 31
return (r << 3 | r >> 2, g << 2 | g >> 4, b << 3 | b >> 2)
@@ -437,4 +468,12 @@ class Renderer:
def qrcode(self, img, c):
x, y, w, h = self._box(c)
img.paste(rgb(c.get("bco") or 0xFFFF), (x, y, x + w, y + h))
bco, pco = c.get("bco"), c.get("pco")
img.paste(rgb(0xFFFF if bco is None else bco), (x, y, x + w, y + h))
rects = qr_rects(c.get("txt") or "", w, c.get("dis") or 0)
for (ax, ay), (bx, by) in rects:
img.paste(rgb(pco or 0), (x + ax, y + ay, x + bx, y + by)) # not clipped to h (like the display)
if rects and c.get("sta") == 1: # logo picture, centred in the box
src = self.pic(c.get("pic"))
if src:
self._paste(img, src, 0, 0, src.width, src.height, x + (w - src.width) // 2, y + (h - src.height) // 2)