Download server/reading.py from devmandan/qr-scan-difficulty-check: direct link, hf CLI and curl.
- Browser
- Download file 9.96 kB
-
https://huggingface.co/spaces/devmandan/qr-scan-difficulty-check/resolve/main/server/reading.py
- Command line
-
hf download hf://spaces/devmandan/qr-scan-difficulty-check/server/reading.py
-
curl -L -o reading.py https://huggingface.co/spaces/devmandan/qr-scan-difficulty-check/resolve/main/server/reading.py
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))} | |