qr-scan-difficulty-check / server /reading_worker.py
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
13.7 kB
"""The decoder worker process (see reading.py): it stages each picture's frames, zxing-cpp, WeChat's scanner and
OpenCV's two detectors read them in it, and the picture-quality checks (quality.py) run in it. _Worker, in the
server, starts one, talks to it, and replaces it when it gets stuck or dies.
"""
from __future__ import annotations
import os
import time
from pathlib import Path
from .reading_facts import read_facts, second_look
from .reading_rules import (
MANY_CODES,
MEASURE_TIMEOUT_S,
POOL,
STAGE_TIMEOUT_S,
TIMEOUT_S,
VENDOR,
PictureError,
frame_sizes,
)
class _TooBig(Exception):
"""More pixels than OPENCV_IO_MAX_IMAGE_PIXELS."""
# ---- the worker process: zxing-cpp, WeChat's scanner, OpenCV's two detectors --------------------------------------
def _corners(quality, scanner: str, take, *args):
"""quality.corners_from(scanner, *take(*args)) as plain data (four [x, y] floats, and squares per side or None), or
None: take reads the scanner's own result (zxing-cpp's position and extra, WeChat's or OpenCV's points) inside this
guard, so that an error in the corners never costs a read and the worker's message always pickles."""
try:
got = quality.corners_from(scanner, *take(*args))
if got is None:
return None
corners = [[float(x), float(y)] for x, y in got[0]]
return (corners, None if got[1] is None else int(got[1])) if len(corners) == 4 else None
except Exception: # noqa: BLE001 - the corners are optional
return None
def _decoders(wechat_dir: str, quality):
"""Per scanner, a function from a frame to (contents, corners): one corners entry per content, what
quality.corners_from makes of the scanner's own result for that code, or None. The contents are as measured.
zxing-cpp's also takes a list, which it fills with each content's facts (reading_facts.read_facts), and options
for the looks only (reading_facts.second_look: another of its binarizers, by name, or the frame's own size alone):
the reading uses the library's defaults."""
import cv2
import zxingcpp
cv2.setNumThreads(1)
d = Path(wechat_dir)
wechat = cv2.wechat_qrcode.WeChatQRCode(str(d / "detect.prototxt"), str(d / "detect.caffemodel"),
str(d / "sr.prototxt"), str(d / "sr.caffemodel"))
qr_format = zxingcpp.BarcodeFormat.QRCode # in zxing-cpp 3 this also returns Micro QR and rMQR, dropped below
dropped = (zxingcpp.BarcodeFormat.MicroQRCode, zxingcpp.BarcodeFormat.RMQRCode)
def zxing_cpp(bgr, facts=None, how=None):
out, geo = [], []
how = {k: getattr(zxingcpp.Binarizer, v) if k == "binarizer" else v for k, v in (how or {}).items()}
for r in zxingcpp.read_barcodes(cv2.cvtColor(bgr, cv2.COLOR_BGR2GRAY), formats=qr_format, **how):
if r.format in dropped or not getattr(r, "valid", True):
continue
out.append(bytes(r.bytes) if r.bytes is not None else (r.text or "").encode("utf-8"))
geo.append(_corners(quality, "zxing-cpp", lambda x: (x.position, x.extra), r))
if facts is not None:
facts.append(read_facts(r))
return out, geo
def wechat_qr(bgr):
try:
texts, points = wechat.detectAndDecode(bgr)
except UnicodeDecodeError as e: # binary content: OpenCV's binding fails to make text of it
return [bytes(e.object)], [None]
out = [t.encode("utf-8") for t in texts if t]
return out, [_corners(quality, "wechat", lambda i: (points[i],), i) for i, t in enumerate(texts) if t]
def single(name, detector): # detectAndDecode, the single-code call apps make
def read(bgr):
gray = cv2.cvtColor(bgr, cv2.COLOR_BGR2GRAY)
try:
text, points, straight = detector.detectAndDecode(gray)
raw = text.encode("utf-8") if text else b""
except UnicodeDecodeError: # bytes that aren't UTF-8 (kanji mode, binary); the error's own stop at a
raw, points, straight = detector.detectAndDecodeBytes(gray) # NUL, so its bytes call reads them all
return ([bytes(raw)], [_corners(quality, name, lambda: (points, straight))]) if raw else ([], [])
return read
return cv2, {"zxing-cpp": zxing_cpp, "wechat": wechat_qr, "opencv": single("opencv", cv2.QRCodeDetector()),
"opencv-aruco": single("opencv-aruco", cv2.QRCodeDetectorAruco())}
def _open(cv2, path: str):
"""The picture in gray as the measurement opened it, any transparent part on white; None if it can't be opened."""
import numpy as np
try:
gray = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
if gray is None or not path.endswith((".png", ".webp")):
return gray
full = cv2.imread(path, cv2.IMREAD_UNCHANGED) # gray (or colour) with alpha comes back as 4 channels
except cv2.error as e: # past OPENCV_IO_MAX_IMAGE_PIXELS OpenCV raises, rather than return None
if "MAX_IMAGE_PIXELS" in str(e):
raise _TooBig from e
return None
if full is None or full.ndim != 3 or full.shape[2] != 4:
return gray
top = np.iinfo(full.dtype).max
if full[..., 3].min() == top: # no pixel is transparent: the measured path, unchanged
return gray
a = full[..., 3].astype(np.float32) / top
g = cv2.cvtColor(full[..., :3], cv2.COLOR_BGR2GRAY).astype(np.float32) / top
return np.rint(255 * (g * a + (1 - a))).astype(np.uint8)
def _child(conn, wechat_dir: str) -> None:
try:
from . import quality # in the worker only, as OpenCV
cv2, decoders = _decoders(wechat_dir, quality)
except Exception as e: # noqa: BLE001 - reported to the parent, which refuses to start
conn.send(("broken", repr(e)))
return
conn.send(("ready",))
while True:
try:
msg = conn.recv()
except EOFError:
return
if msg[0] == "stage":
_, path, outdir = msg
try:
gray = _open(cv2, path)
if gray is None:
conn.send(("unreadable",))
continue
frames = []
for k, ((w, h), labels) in enumerate(frame_sizes(*gray.shape).items()):
g = gray if (h, w) == gray.shape else cv2.resize(gray, (w, h), interpolation=cv2.INTER_AREA)
p = os.path.join(outdir, f"{k}.png")
cv2.imwrite(p, g, [cv2.IMWRITE_PNG_COMPRESSION, 1])
frames.append((w, h, labels, p))
conn.send(("staged", gray.shape[1], gray.shape[0], frames))
except _TooBig:
conn.send(("too big",))
except Exception: # noqa: BLE001 - a picture that can't be staged (out of memory, say) is refused
conn.send(("unreadable",))
elif msg[0] == "decode":
_, frames, skip, many = msg # many: OpenCV's newer detector is off from here on (MANY_CODES)
for k, (_, _, _, p) in enumerate(frames):
todo = [n for n in POOL if (k, n) not in skip]
if not todo:
continue
bgr = cv2.cvtColor(cv2.imread(p, cv2.IMREAD_GRAYSCALE), cv2.COLOR_GRAY2BGR)
for n in todo:
if many and n == "opencv-aruco":
conn.send(("off", k, n))
continue
conn.send(("start", k, n))
facts = [] if n == "zxing-cpp" else None # its facts, one per content (reading_facts)
try:
payloads, corners = decoders[n](bgr) if facts is None else decoders[n](bgr, facts)
except Exception: # noqa: BLE001 - a decoder that fails reads nothing, as in the measurement
payloads, corners, facts = [], [], None
if facts is None or len(facts) != len(payloads):
facts = [None] * len(payloads)
conn.send(("done", k, n, payloads, corners, facts))
many = many or (n == "zxing-cpp" and len(payloads) >= MANY_CODES)
conn.send(("end",))
elif msg[0] == "measure":
conn.send(("measured", quality.measure_staged(*msg[1:])))
elif msg[0] == "look":
conn.send(("look", second_look(cv2, decoders["zxing-cpp"], *msg[1:])))
class _Worker:
"""One decoder worker process. A stuck one is killed; a new one starts when the next message is sent."""
def __init__(self, ctx):
self._ctx = ctx
self._spawn()
def _spawn(self) -> None:
self.conn, child = self._ctx.Pipe()
self.proc = self._ctx.Process(target=_child, args=(child, str(VENDOR / "wechat")), daemon=True)
self.proc.start()
child.close()
msg = self._recv(180)
if msg is None or msg[0] != "ready":
raise RuntimeError(f"decoder worker did not start: {msg}")
def close(self) -> None:
self.proc.kill()
self.proc.join(5)
self.conn.close()
def alive(self) -> bool:
return not self.conn.closed and self.proc.is_alive()
def _send(self, msg) -> None:
"""Send to a live worker: one that was killed, or died while idle (killed for memory, say), is replaced."""
if self.conn.closed or not self.proc.is_alive():
self.close()
self._spawn()
try:
self.conn.send(msg)
except OSError: # it died just now
self.close()
self._spawn()
self.conn.send(msg)
def _recv(self, timeout: float):
try:
if not self.conn.poll(timeout):
return None
return self.conn.recv()
except (EOFError, OSError):
return None
def stage(self, path: str, outdir: str):
t0 = time.monotonic()
self._send(("stage", path, outdir))
msg = self._recv(STAGE_TIMEOUT_S)
if msg is None: # too slow, or the worker crashed on this picture
slow = time.monotonic() - t0 >= STAGE_TIMEOUT_S
self.close()
raise PictureError("This picture took too long to open." if slow else "This picture could not be opened.")
if msg[0] == "too big":
raise PictureError("This picture is over 50 megapixels.")
if msg[0] == "unreadable":
raise PictureError("This picture could not be opened.")
return msg[1], msg[2], msg[3]
def decode(self, frames, deadline: float):
"""{(frame index, scanner): payloads}, the same for the corners (one per payload) and the facts (zxing-cpp's,
reading_facts.read_facts; None for the others), whether the deadline (or crashes) cut the reading short, and
the decodes the many-codes rule (MANY_CODES) left out, kept across a replaced worker."""
got: dict[tuple[int, str], list[bytes]] = {}
geo: dict[tuple[int, str], list] = {}
facts: dict[tuple[int, str], list] = {}
missed: set[tuple[int, str]] = set()
off, many, crashes = set(), False, 0
while True:
self._send(("decode", frames, missed | off | set(got), many))
current = None
while True:
msg = self._recv(max(0.0, min(TIMEOUT_S, deadline - time.monotonic())))
if msg is None:
break
if msg[0] == "start":
current = (msg[1], msg[2])
elif msg[0] == "done":
got[(msg[1], msg[2])] = msg[3]
geo[(msg[1], msg[2])] = msg[4]
facts[(msg[1], msg[2])] = msg[5]
many = many or (msg[2] == "zxing-cpp" and len(msg[3]) >= MANY_CODES)
current = None
elif msg[0] == "off":
off.add((msg[1], msg[2]))
elif msg[0] == "end":
return got, geo, facts, False, off
# silence: a decode ran past TIMEOUT_S (a miss), the worker died, or the deadline passed
self.close()
if time.monotonic() >= deadline:
return got, geo, facts, True, off
if current is not None:
missed.add(current)
else:
crashes += 1
if crashes > 1:
return got, geo, facts, True, off
def measure(self, path: str, found: dict, sizes: list, scale: dict) -> dict | None:
"""The picture-quality checks, by quality.measure_staged in this worker (see _ask)."""
return self._ask(("measure", path, found, sizes, scale), "measured")
def second_look(self, path: str, how: dict | None = None) -> list | None:
"""zxing-cpp's second look at a staged frame, or its look with how, by reading_facts.second_look (see _ask)."""
return self._ask(("look", path, how), "look")
def _ask(self, msg: tuple, reply: str):
"""A diagnostic's answer from this worker; None when it isn't running (diagnostics never start one), or when
it fails or runs past MEASURE_TIMEOUT_S: it is then closed, and replaced at the next send, as after a stuck
decode."""
if not self.alive():
return None
try:
self.conn.send(msg)
got = self._recv(MEASURE_TIMEOUT_S)
if got is not None and got[0] == reply:
return got[1]
except Exception: # noqa: BLE001 - diagnostics never cost a reading
pass
self.close()
return None