Download server/design_frames.py from devmandan/qr-scan-difficulty-check: direct link, hf CLI and curl.
- Browser
- Download file 5.96 kB
-
https://huggingface.co/spaces/devmandan/qr-scan-difficulty-check/resolve/main/server/design_frames.py
- Command line
-
hf download hf://spaces/devmandan/qr-scan-difficulty-check/server/design_frames.py
-
curl -L -o design_frames.py https://huggingface.co/spaces/devmandan/qr-scan-difficulty-check/resolve/main/server/design_frames.py
5.96 kB
| """The design test's frames (see design.py): a capture JPEG decoded as OpenCV decodes it (libjpeg-turbo's accurate | |
| integer IDCT), the whole-number shrink from the 1920 x 1440 capture to the 1280 x 960 grey frame every scanner reads, | |
| each frame's SHA-256 over its 1,228,800 bytes row by row, the box where the plain code's frame differs from the | |
| design's, the plain code's patch (its frame inside that box, as a grey PNG at compression level 1), the paste that | |
| rebuilds its frame from the design's, and a fallback frame: a whole frame as a grey PNG at level 1, built from what the | |
| server holds for its scene and checked against the scene's own hash before it is sent. | |
| The shrink: on each axis, output index i reads the source (3i + 1) >> 1 with weight 2/3 and 3(i >> 1) + 1 with weight | |
| 1/3. With a the source pixel weighted 2/3 both ways, b and c 2/3 one way and 1/3 the other, and d 1/3 both ways, a frame | |
| pixel is (4a + 2b + 2c + d + 4) div 9: OpenCV's INTER_AREA at this size, exactly, in whole numbers, so the page makes | |
| the same frames from the same JPEG on any processor. | |
| The test worker imports this module, and the server itself only for its first fallback frame: it never loads the scene | |
| renderer or the scanners. | |
| """ | |
| from __future__ import annotations | |
| import base64 | |
| import hashlib | |
| import cv2 | |
| import numpy as np | |
| CAPTURE = (1920, 1440) # width, height | |
| FRAME = (1280, 960) | |
| PNG = [cv2.IMWRITE_PNG_COMPRESSION, 1] | |
| _X, _Y = np.arange(FRAME[0]), np.arange(FRAME[1]) | |
| _X2, _X1 = (3 * _X + 1) >> 1, 3 * (_X >> 1) + 1 # each output's source weighted 2/3, and the one weighted 1/3 | |
| _Y2, _Y1 = (3 * _Y + 1) >> 1, 3 * (_Y >> 1) + 1 | |
| def decode_grey(jpeg: bytes) -> np.ndarray | None: | |
| """A JPEG's grey pixels as OpenCV decodes them; None when it doesn't decode.""" | |
| g = cv2.imdecode(np.frombuffer(jpeg, np.uint8), cv2.IMREAD_GRAYSCALE) | |
| return g if g is not None and g.dtype == np.uint8 and g.ndim == 2 else None | |
| def shrink(capture: np.ndarray) -> np.ndarray: | |
| """The 1280 x 960 frame of a 1920 x 1440 grey capture, by the whole-number rule.""" | |
| if capture.shape != (CAPTURE[1], CAPTURE[0]) or capture.dtype != np.uint8: | |
| raise ValueError(f"not a {CAPTURE[0]} x {CAPTURE[1]} grey capture: {capture.shape} {capture.dtype}") | |
| g = capture.astype(np.uint16) # at most 9 x 255: no overflow | |
| v = 2 * g[_Y2] + g[_Y1] | |
| t = 2 * v[:, _X2] + v[:, _X1] | |
| return ((t + 4) // 9).astype(np.uint8) | |
| def frame_of(jpeg: bytes) -> np.ndarray | None: | |
| """The frame the scanners read from a capture JPEG; None when it isn't a 1920 x 1440 grey JPEG.""" | |
| g = decode_grey(jpeg) | |
| return None if g is None or g.shape != (CAPTURE[1], CAPTURE[0]) else shrink(g) | |
| def sha256(frame: np.ndarray) -> str: | |
| """The SHA-256 of a frame's bytes, row by row, one byte a pixel.""" | |
| return hashlib.sha256(np.ascontiguousarray(frame, np.uint8).tobytes()).hexdigest() | |
| def box_of(plain: np.ndarray, design: np.ndarray) -> list[int]: | |
| """[x, y, w, h], in frame pixels, of where the plain code's frame differs from the design's; [0, 0, 0, 0] when | |
| they are equal.""" | |
| differ = plain != design | |
| rows = np.flatnonzero(differ.any(axis=1)) | |
| if rows.size == 0: | |
| return [0, 0, 0, 0] | |
| cols = np.flatnonzero(differ.any(axis=0)) | |
| return [int(cols[0]), int(rows[0]), int(cols[-1] + 1 - cols[0]), int(rows[-1] + 1 - rows[0])] | |
| def png_of(grey: np.ndarray) -> bytes: | |
| """A grey picture as a PNG at compression level 1.""" | |
| ok, enc = cv2.imencode(".png", np.ascontiguousarray(grey, np.uint8), PNG) | |
| if not ok: | |
| raise RuntimeError("PNG encoding failed") | |
| return enc.tobytes() | |
| def patch_of(plain: np.ndarray, box: list[int]) -> bytes | None: | |
| """The plain code's frame inside the box, as a grey PNG at level 1; None for an empty box.""" | |
| x, y, w, h = box | |
| return png_of(plain[y:y + h, x:x + w]) if w and h else None | |
| def decode_png(png: bytes, w: int, h: int) -> np.ndarray | None: | |
| """A grey PNG of exactly w x h pixels, one byte each; None otherwise.""" | |
| g = cv2.imdecode(np.frombuffer(png, np.uint8), cv2.IMREAD_UNCHANGED) | |
| return g if g is not None and g.dtype == np.uint8 and g.shape == (h, w) else None | |
| def paste(design: np.ndarray, patch: bytes | None, box: list[int]) -> np.ndarray | None: | |
| """The plain code's frame: a copy of the design's with the patch written at the box; the design's own for an | |
| empty box. None when the box doesn't lie inside the frame or the patch isn't exactly its size.""" | |
| x, y, w, h = box | |
| if not (w and h): | |
| return design.copy() | |
| if x < 0 or y < 0 or x + w > FRAME[0] or y + h > FRAME[1] or patch is None: | |
| return None | |
| p = decode_png(patch, w, h) | |
| if p is None: | |
| return None | |
| out = design.copy() | |
| out[y:y + h, x:x + w] = p | |
| return out | |
| def fallback(held: dict, plain: bool) -> bytes | None: | |
| """A scene's whole frame as a grey PNG at level 1: the design's (from its capture JPEG, or its PNG frame), or the | |
| plain code's (its patch pasted over the design's). None when what is held doesn't rebuild the frame to the scene's | |
| own hash, so a frame that fails is never sent.""" | |
| if held.get("png") is not None: | |
| design = decode_png(held["png"], *FRAME) | |
| else: | |
| design = frame_of(held["jpeg"]) if held.get("jpeg") is not None else None | |
| if design is None: | |
| return None | |
| frame = paste(design, held.get("patch"), held["box"]) if plain else design | |
| if frame is None or sha256(frame) != held["sha256"]["plain" if plain else "design"]: | |
| return None | |
| return png_of(frame) | |
| def block_means(frame: np.ndarray) -> str: | |
| """The frame's 32 x 32 block means, each round(16 x the mean), as 30 x 40 little-endian uint16 in base64: the | |
| start-up self-test's pixel check.""" | |
| m = frame.reshape(FRAME[1] // 32, 32, FRAME[0] // 32, 32).astype(np.float64).mean(axis=(1, 3)) | |
| return base64.b64encode(np.rint(16 * m).astype("<u2").tobytes()).decode("ascii") | |