File size: 11,235 Bytes
5b3cd1e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
811648d
 
 
5b3cd1e
 
 
 
 
 
811648d
5b3cd1e
 
 
 
811648d
 
 
5b3cd1e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
"""The design test's rules (see design.py): its settings, read once at start-up from web/data/test.json (the page's own
file, so the page and the server never disagree) and sizes.json's needs; each scanner's answer; the size check from a
picture's header, before it is opened; the start-up self-test's judgement against its pinned values
(design_pins.json); and, in the test worker, the setup's checks on zxing-cpp's reads of a picture
(design_worker._setup): its reads at the picture's own size, copies of one code, polarity and mirroring.
"""

from __future__ import annotations

import base64
import json
import struct
from math import comb, inf
from pathlib import Path
from types import SimpleNamespace

from .reading_facts import _copy_of, own_reads
from .reading_worker import _corners

PINS = Path(__file__).with_name("design_pins.json")


def answer(b: int, c: int, t: int, d: int, inv: int = 20, cost: int = 2, q: int = 16) -> str:
    """One scanner's answer over the paired scenes: b counts the scenes where it read the plain code and missed the
    design, c the reverse, t and d the scenes where it read the plain code and the design. "worse": a one-sided exact
    sign test on (b, c) under 1 / inv, in whole numbers (inv x the tail's count below 2 ** (b + c)); "like": a cost
    b - c of at most `cost`, with the plain code or the design read in at least q scenes; otherwise "close" (a cost
    over `cost`) or "few"."""
    n = b + c
    if inv * sum(comb(n, k) for k in range(b, n + 1)) < 2 ** n:
        return "worse"
    if b - c <= cost and (t >= q or d >= q):
        return "like"
    return "close" if b - c > cost else "few"


def picture_size(data: bytes) -> tuple[int, int] | None:
    """(width, height) from a PNG's, a JPEG's or a WebP's header; None when the header doesn't say."""
    try:
        if data[:8] == b"\x89PNG\r\n\x1a\n" and data[12:16] == b"IHDR":
            return struct.unpack(">II", data[16:24])
        if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
            if data[12:16] == b"VP8 ":   # a key frame: its start code, then 14-bit width and height
                w, h = struct.unpack("<HH", data[26:30])
                return w & 0x3FFF, h & 0x3FFF
            if data[12:16] == b"VP8L":
                bits = int.from_bytes(data[21:25], "little")
                return (bits & 0x3FFF) + 1, ((bits >> 14) & 0x3FFF) + 1
            if data[12:16] == b"VP8X":
                return int.from_bytes(data[24:27], "little") + 1, int.from_bytes(data[27:30], "little") + 1
            return None
        i = 2 if data[:2] == b"\xff\xd8" else len(data)
        while i + 9 <= len(data) and data[i] == 0xFF:
            m = data[i + 1]
            if m == 0xFF:   # a fill byte
                i += 1
            elif m == 0x01 or 0xD0 <= m <= 0xD7:   # TEM and RST0-7 carry no length, as libjpeg reads them
                i += 2
            elif 0xC0 <= m <= 0xCF and m not in (0xC4, 0xC8, 0xCC):   # a frame header: height, then width
                h, w = struct.unpack(">HH", data[i + 5:i + 9])
                return w, h
            elif m == 0xDA:   # scan data before any frame header
                return None
            else:
                i += 2 + struct.unpack(">H", data[i + 2:i + 4])[0]
    except struct.error:
        return None
    return None


def settings(test_json: Path, sizes_json: Path) -> dict:
    """The test's settings; raises on a missing or invalid file."""
    tj = json.loads(test_json.read_text(encoding="utf-8"))
    needs = json.loads(sizes_json.read_text(encoding="utf-8"))["needs"]
    sv, lim, rule, check = tj["server"], tj["limits"], tj["rule"], tj["check"]
    n, seeds, inv = int(tj["scenes"]["s"]), [int(s) for s in tj["scenes"]["seeds"]], round(1 / rule["alpha"])
    if len(seeds) != n or abs(1 / inv - rule["alpha"]) > 1e-12 or not needs:
        raise ValueError("test.json: its scenes, or its rule's alpha")
    if int(lim["max_version"]) > max(int(x["version"]) for x in needs):   # p(v) is the next measured version up
        raise ValueError("test.json: max_version beyond sizes.json's needs")
    lo, hi = (int(x) for x in sv["retry_s"])
    return {
        "n": n, "nice": int(sv["nice"]), "scene_wait_s": float(sv["scene_wait_s"]),
        "readings_switch": bool(sv["busy_while_readings_wait"]),
        "rule": {"inv": inv, "cost": int(rule["like_cost"]), "q": int(rule["q"])},
        "worker": {"max_version": int(lim["max_version"]), "min_ppm": float(lim["min_ppm"]),
                   "min_ppm_v1": float(lim["min_ppm_v1"]), "max_pixels": int(lim["max_pixels"]), "needs": needs,
                   "seeds": seeds},
        "queue": {"n": n, "deadline_s": float(sv["deadline_s"]), "hold_s": int(sv["slot_hold_s"]),
                  "ticket_extra_s": float(sv["ticket_extra_s"]), "idle_s": float(sv["idle_s"]),
                  "after_deadline_s": float(sv["after_deadline_s"]), "retry_s": (lo, hi),
                  "max_tickets": int(sv["max_tickets"]), "held_max": int(sv["held_mb_max"]) * 1_000_000},
        "check": {"png": base64.b64decode(check["png"]["b64"]), "jpeg": base64.b64decode(check["jpeg"]["b64"]),
                  "jpeg_grey_sha256": check["jpeg"]["grey_sha256"]},
    }


def _near(a: str, b: str, tolerance: int) -> bool:
    """Two frames' block means (base64 of little-endian uint16, x16) within the tolerance everywhere."""
    x, y = base64.b64decode(a), base64.b64decode(b)
    if len(x) != len(y) or not x or len(x) % 2:
        return False
    x, y = struct.unpack(f"<{len(x) // 2}H", x), struct.unpack(f"<{len(y) // 2}H", y)
    return max(abs(i - j) for i, j in zip(x, y, strict=True)) <= tolerance


def judge(got: dict | None, pins: dict, jpeg_grey_sha256: str) -> tuple[bool, bool | None]:
    """(passed, same_frames) for the self-test's result: the code's facts and both scanners' reads as pinned, every
    frame's 32 x 32 block means within the tolerance, each patch rebuilding its frame to its hash, and the working
    check's JPEG decoding to the hash test.json pins. same_frames: whether the four frames also equal the bytes pinned
    from one machine, all four the Mac's or all four x86's (frame_sha256's "mac" and "x86"); None when no scene came
    back."""
    got = got or {}
    facts, scenes, want = got.get("facts") or {}, got.get("scenes") or [], pins["scenes"]
    if not scenes or len(scenes) != len(want):
        return False, None
    ok = all(facts.get(k) == pins["facts"][k] for k in ("version", "ec_level", "mask", "raw_sha256"))
    ok = ok and got.get("check_jpeg_grey_sha256") == jpeg_grey_sha256
    same = dict.fromkeys(("mac", "x86"), True)
    for g, p in zip(scenes, want, strict=True):
        ok = ok and g["seed"] == p["seed"] and g["reads"] == p["reads"] and g["paste_ok"] is True
        for kind in ("plain", "design"):
            ok = ok and _near(g["block_means_x16_b64"][kind], p["block_means_x16_b64"][kind], pins["tolerance_x16"])
            for m in same:
                same[m] = same[m] and g["frame_sha256"][kind] == p["frame_sha256"].get(m, {}).get(kind)
    return bool(ok), any(same.values())


# ---- the setup's checks, in the test worker: T holds its OpenCV, numpy, scene renderer and quality.py -------------

def _inverted(T, gray, corners, n: int) -> bool:
    """Light on dark: the three finders' outer rings (24 squares each) sampled lighter than their separators, the light
    strips between each finder and the rest of the code (15 squares each), at the squares' centres through the read's
    corners."""
    np, cv2 = T.np, T.cv2
    ring = [(r0 + i, c0 + j) for r0, c0 in ((0, 0), (0, n - 7), (n - 7, 0)) for i in range(7) for j in range(7)
            if i in (0, 6) or j in (0, 6)]
    e = n - 8
    sep = ([(7, j) for j in range(8)] + [(i, 7) for i in range(7)] + [(7, e + j) for j in range(8)]
           + [(i, e) for i in range(7)] + [(e, j) for j in range(8)] + [(e + 1 + i, 7) for i in range(7)])
    hm = cv2.getPerspectiveTransform(np.float32([[0, 0], [n, 0], [n, n], [0, n]]), np.float32(corners))

    def mean(cells):
        xy = cv2.perspectiveTransform(np.float32([[[c + 0.5, r + 0.5] for r, c in cells]]), hm)[0]
        x = np.clip(np.floor(xy[:, 0]).astype(int), 0, gray.shape[1] - 1)
        y = np.clip(np.floor(xy[:, 1]).astype(int), 0, gray.shape[0] - 1)
        return float(gray[y, x].mean())
    return mean(ring) > mean(sep)


def _mirrored(T, r, twin, n: int) -> bool:
    """zxing-cpp gives a mirrored code's squares transposed: its two copies of the format information, set by the error
    correction and mask alone (the data squares can differ from the twin's), match the twin's better transposed."""
    np = T.np
    try:
        seen = np.asarray(r.to_image(scale=1, add_quiet_zones=False)) < 128
    except Exception:  # noqa: BLE001 - no squares to compare: not found mirrored
        return False
    k = twin.shape[0] // (n + 2 * T.scene.QUIET)
    at = (T.scene.QUIET + np.arange(n)) * k + k // 2
    plain, f = twin[np.ix_(at, at)] < 128, np.zeros((n, n), bool)
    f[8, [*range(6), 7, 8, *range(n - 8, n)]] = f[[*range(6), 7, *range(n - 7, n)], 8] = True
    return seen.shape == (n, n) and int((seen.T != plain)[f].sum()) < int((seen != plain)[f].sum())


def _corners_of(T, r):
    """A zxing-cpp read's corners as the reading takes them (reading_worker._corners)."""
    return _corners(T.quality, "zxing-cpp", lambda y: (y.position, y.extra), r)


def _copy(T, d, r) -> bool:
    """zxing-cpp's read d is a copy of r's code by the reading's own rule (reading_facts.chosen's copies): the same
    content, error correction and mask (with the version: scene.same_code), and, where both have corners as the reading
    takes them (reading_worker._corners), the same squares across and a mean side within COPY_SIDE of r's."""
    return T.scene.same_code(d) == T.scene.same_code(r) and _copy_of(_corners_of(T, d), _corners_of(T, r))


def _own(T, gray, reads: list) -> list:
    """The reads (zxing-cpp's at library defaults) less those it made in its own smaller copies of the picture, by the
    reading's own-size rule (reading_facts.own_reads) for the content of the read nearest the centre: where zxing-cpp
    read that content two or more times, the picture is read again at its own size alone (try_downscale off), and only
    the reads that look repeats exactly (the same bytes and corners) are kept, all of them when none does. zxing-cpp
    reads copies a third the size only while the picture itself gave it fewer than 255 codes, as it can on another
    processor; a read there has coarse corners, and were it the one nearest the centre, the test would take it and the
    twin's scale would follow it."""
    key, content = (0, "zxing-cpp"), bytes(T.scene.nearest(reads, gray.shape).bytes)
    look = SimpleNamespace(second_look=lambda g, how: [(bytes(x.bytes), _corners_of(T, x), None)
                                                       for x in T.scene.qr_reads(g, **how)])
    _, kept = own_reads(look, [(None, None, None, gray)], {key: [bytes(r.bytes) for r in reads]},
                        {key: [_corners_of(T, r) for r in reads]}, {key: list(reads)}, lambda ps: content in ps, inf)
    return [r for r in kept[key] if r is not None]