devmandan's picture
Claude Opus 5.5
Facts from each code at its own size; the design test's server, not yet on the page
5b3cd1e verified
Raw History Blame Contribute Delete
9.96 kB
"""Read one picture the way QR Scan Difficulty read every code, with the five of its eight scanners that run on Linux.
As in the measurement:
* the picture is read in gray and shrunk, never enlarged, so its long side is at most each frame size (1920 down to
224 pixels), with OpenCV's INTER_AREA; sizes that come out the same are read once;
* each frame is staged as a gray PNG; zxing-cpp, WeChat's scanner and OpenCV's two detectors read it in a worker
process (one OpenCV thread, library defaults, QR codes only), and ZXing reads it in a Java process the way
Android's Settings app calls it;
* a decode that runs past TIMEOUT_S counts as a miss: the worker is replaced and the rest is read without that call.
No measured picture had transparency; here a transparent part counts as white, as on a printed page. Nor did one hold
many codes: here, from the first frame where zxing-cpp reads MANY_CODES codes or more (reading_rules), OpenCV's newer
detector isn't run on that frame or any smaller one, and those decodes count as misses ("not_run").
A scanner reads a frame when one of the contents it returns is the picture's content. The measurement knew each code's
content; here it is the content the most scanners return (ties: the most frames, then text over raw bytes, then the
shortest). Raw bytes and the text a scanner makes of them (ISO-8859-1, QR's default, or Shift JIS) are one content.
The picture-quality checks (quality.py) are diagnostics and leave the reading as it is: the worker takes each read's
corners from the scanner's own result inside a guard and as plain data, so an error in them never costs a read; once a
reading has finished (not cut short), the worker measures its largest frame by the corners of the reads of its content.
Checks that fail or run past MEASURE_TIMEOUT_S are left out ("checks": None); a worker that ran past it is replaced as
after a stuck decode. In the same way, a finished reading also gives zxing-cpp's facts about the code
(reading_facts.chosen), on the largest frame where it read the content with a UEC ("uec_frame": that frame's largest
size): its unused error correction ("uec", from 1.0 when none was needed down to 0.0, with a second look where a copy
under SECOND_LOOK_BELOW, 3 pixels a square, reads under 1.0), the lowest over its reads of the content there; and,
from its last read of the content with a UEC there (or that read's second look, when it stands), the error correction
and mask ("ec_level", "mask"), the squares it sampled ("squares"), its raw bytes' SHA-256 and count ("raw_sha256",
"raw_bytes") and how many copies of that code it read there ("copies"); all None when it never read the content with
a UEC. It also gives the content's SHA-256 ("content": {"sha256"}), as one content's raw bytes, and the SHA-256s of
every set of raw bytes it stands for ("sha256s"; reading_content.py), which the page pairs pictures of one code by.
Where zxing-cpp read the content two or more times in the first frame it read it in, the checks and these facts leave
out its reads from its own smaller copies of that frame (reading_facts.own_reads): it reads those copies only while
the frame itself gave it fewer than 255 codes, and their reads have coarse corners and squares sampled at a third of
the frame's resolution or less.
The reader is here (Reader, and _checks for the picture-quality checks); the settings are in reading_rules.py, the
decoder worker in reading_worker.py, ZXing's Java process in reading_java.py, the content in reading_content.py and
zxing-cpp's facts in reading_facts.py.
"""
from __future__ import annotations
import hashlib
import json
import queue
import tempfile
import threading
import time
from multiprocessing import get_context
from .reading_content import _consensus, _same, describe
from .reading_facts import NO_FACTS, chosen, own_reads
from .reading_java import _Java
from .reading_rules import DEADLINE_S, FRAMES, POOL, SCANNERS, SELF_TEST, VENDOR, PictureError, frame_sizes
from .reading_worker import _decoders, _open, _TooBig, _Worker # noqa: F401 - _decoders, _open and _TooBig: for tools
__all__ = ["FRAMES", "POOL", "SCANNERS", "VENDOR", "PictureError", "Reader", "frame_sizes"]
# ---- one picture ----------------------------------------------------------------------------------------------------
def _checks(worker: _Worker, frames: list, w: int, pool: dict, geo: dict, hit, deadline: float) -> dict | None:
"""The picture-quality checks of a reading that finished, on its largest frame, by the corners of the reads hit
takes for its content; None when none of those reads has corners, when the worker isn't running or the deadline
has passed, or when the checks fail. Diagnostics only: nothing here can cost the reading."""
try:
if not worker.alive() or time.monotonic() >= deadline:
return None
found = {(n, k): c for (k, n), ps in pool.items()
for p, c in zip(ps, geo.get((k, n), []), strict=False) if c is not None and hit([p])}
if not found:
return None
w1280 = next(f[0] for f in frames if 1280 in f[2])
checks = worker.measure(frames[0][3], found, [(f[0], f[1]) for f in frames],
{"to1280": w1280 / frames[0][0], "to_native": w / frames[0][0]})
# encoded as Starlette's JSONResponse encodes the response: a value it would refuse leaves the checks out
json.dumps(checks, ensure_ascii=False, allow_nan=False).encode("utf-8")
return checks if isinstance(checks, dict) else None
except Exception: # noqa: BLE001 - diagnostics never cost the reading
return None
class Reader:
"""Reads pictures, `slots` at a time (one decoder worker each); the ZXing process is shared."""
def __init__(self, slots: int = 2):
ctx = get_context("spawn")
self.java = _Java()
self.workers = [_Worker(ctx) for _ in range(slots)]
self.free: queue.Queue = queue.Queue()
for w in self.workers:
self.free.put(w)
self._self_test()
def _self_test(self) -> None:
"""Refuse to start, rather than place every picture wrongly, unless all five read a clean code at every size."""
r = self.read(str(SELF_TEST))
missed = [n for n in SCANNERS if not all(r["reads"][n])]
if missed or r["partial"]:
self.close()
raise RuntimeError(f"self-test failed: {', '.join(missed) or 'the reading ran out of time'}")
def close(self) -> None:
for w in self.workers:
w.close()
self.java.close()
def read(self, path: str, truth: set[str] | None = None) -> dict:
"""Read one picture file. `truth` (sha256 hex digests of the content) replaces the consensus, as the
measurement scored known codes; the server never passes it. "checks": the picture-quality checks of a
reading that finished (see _checks), else None; "uec", "uec_frame", "copies", "ec_level", "mask",
"squares", "raw_sha256" and "raw_bytes": zxing-cpp's facts (reading_facts.chosen: "uec" the lowest over its
reads of the content in their frame, "copies" how many copies of one code it read there, the others from
that read), all None when zxing-cpp never read the content with a UEC and for a reading cut short;
"not_run": the decodes the many-codes rule left out, {scanner: [frame sizes]}, {} when none."""
t0 = time.monotonic()
deadline = t0 + DEADLINE_S
worker = self.free.get()
try:
with tempfile.TemporaryDirectory(prefix="qsd-") as tmp:
w, h, frames = worker.stage(path, tmp)
java: dict = {"r": [None] * len(frames)}
def zxing_java():
java["r"] = self.java.read([f[3] for f in frames], deadline)
t = threading.Thread(target=zxing_java, daemon=True)
t.start()
try:
pool, geo, facts, partial, off = worker.decode(frames, deadline)
finally:
t.join()
contents = {(n, k): p for (k, n), p in pool.items()}
for k, p in enumerate(java["r"]):
contents[("zxing-java", k)] = p or []
partial = partial or p is None
if truth is None:
content = _consensus(contents)
def hit(ps): return content is not None and any(_same(p, content) for p in ps) # noqa: E306
else:
content = None
def hit(ps): return any(hashlib.sha256(p).hexdigest() in truth for p in ps) # noqa: E306
if not partial: # the checks and the facts leave out zxing-cpp's reads from its smaller copies
geo, facts = own_reads(worker, frames, pool, geo, facts, hit, deadline)
checks = None if partial else _checks(worker, frames, w, pool, geo, hit, deadline)
code = dict(NO_FACTS) if partial else chosen(worker, frames, pool, geo, facts, hit, deadline)
finally:
self.free.put(worker)
reads = {n: [0] * len(FRAMES) for n in SCANNERS}
sizes = [None] * len(FRAMES)
for k, (fw, fh, labels, _) in enumerate(frames):
for f in labels:
fi = FRAMES.index(f)
sizes[fi] = [fw, fh]
for n in SCANNERS:
reads[n][fi] = int(hit(contents.get((n, k), [])))
not_run: dict[str, list[int]] = {} # the many-codes rule's decodes, by scanner: frame sizes, largest first
for k, n in sorted(off):
not_run.setdefault(n, []).extend(frames[k][2])
return {"size": [w, h], "frames": sizes, "reads": reads, "content": describe(content), "partial": partial,
"checks": checks, **code, "not_run": not_run, "ms": round(1000 * (time.monotonic() - t0))}