"""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