File size: 7,727 Bytes
b8ea052
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Render inspectable geometry emitted by structured-contract checkers.

The renderer deliberately consumes only evidence already used by the checker.
It does not run another detector or alter the decision. This keeps review
overlays faithful to the exact regions, instances, and lines behind a score.
"""

from __future__ import annotations

import math
from pathlib import Path
from typing import Any, Iterable, Mapping

from PIL import Image, ImageDraw, ImageFont


BOX_TOKENS = ("bbox", "bboxes", "roi", "rois", "zone", "zones", "cell", "cells", "grid")
POINT_TOKENS = ("pivot_xy", "centroid", "center_xy")
MAX_PRIMITIVES = 48


def _numbers(value: Any, length: int) -> list[float] | None:
    if not isinstance(value, (list, tuple)) or len(value) != length:
        return None
    if not all(isinstance(item, (int, float)) for item in value):
        return None
    return [float(item) for item in value]


def _polygon_numbers(value: Any) -> list[float] | None:
    if not isinstance(value, (list, tuple)) or len(value) < 3:
        return None
    points = [_numbers(point, 2) for point in value]
    if any(point is None for point in points):
        return None
    return [coordinate for point in points if point is not None for coordinate in point]


def _label(path: tuple[str, ...]) -> str:
    return "/".join(path[-3:])


def extract_primitives(evidence: Mapping[str, Any], image_size: tuple[int, int]) -> list[dict[str, Any]]:
    """Extract pixel-space boxes, points, and line segments from evidence."""

    width, height = image_size
    primitives: list[dict[str, Any]] = []
    seen: set[tuple[Any, ...]] = set()

    def add(kind: str, values: Iterable[float], label: str) -> None:
        rounded = tuple(round(float(item), 2) for item in values)
        identity = (kind, rounded, label)
        if identity in seen:
            return
        seen.add(identity)
        primitives.append({"kind": kind, "values": list(rounded), "label": label})

    def walk(value: Any, path: tuple[str, ...]) -> None:
        key_scope = "/".join(path).lower()
        polygon = _polygon_numbers(value)
        if polygon is not None and any(token in key_scope for token in ("polygon", "zone")):
            xs, ys = polygon[0::2], polygon[1::2]
            if min(xs) >= 0 and max(xs) <= width * 1.02 and min(ys) >= 0 and max(ys) <= height * 1.02:
                add("polygon", polygon, _label(path))
                return
        box = _numbers(value, 4)
        if box is not None and any(token in key_scope for token in BOX_TOKENS):
            x0, y0, x1, y1 = box
            if 0 <= x0 < x1 <= width * 1.02 and 0 <= y0 < y1 <= height * 1.02:
                add("box", box, _label(path))
                return
        point = _numbers(value, 2)
        if point is not None and any(token in key_scope for token in POINT_TOKENS):
            x, y = point
            if 0 <= x <= width and 0 <= y <= height:
                add("point", point, _label(path))
                return
        if isinstance(value, Mapping):
            for child_key, child in value.items():
                walk(child, (*path, str(child_key)))
        elif isinstance(value, list):
            for index, child in enumerate(value):
                walk(child, (*path, str(index)))

    walk(evidence, ())

    parser = str(evidence.get("parser") or "")
    if parser.startswith("lower_gauge_radial_parser"):
        pivot = _numbers(evidence.get("pivot_xy"), 2)
        angle = evidence.get("output_angle_degrees")
        if pivot and isinstance(angle, (int, float)):
            radius = min(width, height) * 0.125
            end = [
                pivot[0] + math.cos(math.radians(float(angle))) * radius,
                pivot[1] + math.sin(math.radians(float(angle))) * radius,
            ]
            add("line", [*pivot, *end], "output needle")
    elif parser.startswith("watch_registered_hand_parser"):
        pivot = _numbers(evidence.get("output_pivot_xy"), 2)
        radius = min(width, height) * 0.22
        for name, values, fraction in (
            ("output hour hand", evidence.get("hour_angles"), 0.65),
            ("output minute hand", evidence.get("minute_angles"), 0.95),
        ):
            if pivot and isinstance(values, (list, tuple)) and len(values) >= 2 and isinstance(values[1], (int, float)):
                angle = math.radians(float(values[1]))
                end = [pivot[0] + math.cos(angle) * radius * fraction, pivot[1] + math.sin(angle) * radius * fraction]
                add("line", [*pivot, *end], name)

    overlay = evidence.get("overlay_geometry")
    if isinstance(overlay, Mapping) and isinstance(overlay.get("segments"), Mapping):
        for name, segment in overlay["segments"].items():
            values = _numbers(segment, 4)
            if values is not None:
                add("line", values, str(name))
    primitives.sort(
        key=lambda item: (
            int("component" in item["label"] or "assignments/" in item["label"]),
            int("detection" in item["label"]),
        )
    )
    return primitives[:MAX_PRIMITIVES]


def render_overlay(
    image_path: Path,
    evidence: Mapping[str, Any],
    output_path: Path,
    *,
    title: str,
    status: str,
) -> dict[str, Any]:
    """Draw evidence geometry and return a compact render manifest."""

    with Image.open(image_path).convert("RGB") as source:
        image = source.copy()
    draw = ImageDraw.Draw(image)
    font = ImageFont.load_default()
    primitives = extract_primitives(evidence, image.size)
    status_color = {
        "pass": "#12B76A", "clean": "#12B76A",
        "partial": "#F79009", "partial_trigger": "#F79009",
        "fail": "#F04438", "triggered": "#F04438",
        "unknown": "#667085", "uncertain": "#667085",
    }.get(status, "#175CD3")
    palette = (status_color, "#2E90FA", "#7A5AF8", "#EE46BC", "#15B79E")

    for index, primitive in enumerate(primitives):
        label = primitive["label"]
        label_lower = label.lower()
        color = (
            "#FEC84B" if "zone_polygons/yellow" in label_lower
            else "#06AED4" if "zone_polygons/cyan" in label_lower
            else palette[index % len(palette)]
        )
        values = primitive["values"]
        if primitive["kind"] == "box":
            draw.rectangle(values, outline=color, width=max(2, min(image.size) // 320))
            x, y = values[0], max(35, values[1] - 13)
        elif primitive["kind"] == "polygon":
            points = list(zip(values[0::2], values[1::2]))
            draw.line([*points, points[0]], fill=color, width=max(3, min(image.size) // 220), joint="curve")
            x, y = points[0]
        elif primitive["kind"] == "point":
            x, y = values
            radius = max(4, min(image.size) // 180)
            draw.ellipse((x - radius, y - radius, x + radius, y + radius), outline=color, width=2)
        else:
            draw.line(values, fill=color, width=max(3, min(image.size) // 220))
            x, y = values[2], values[3]
        if index < 24 and "component" not in label and "assignments/" not in label:
            text_box = draw.textbbox((x, y), label, font=font)
            draw.rectangle(text_box, fill="#101828")
            draw.text((x, y), label, fill="white", font=font)

    draw.rectangle((0, 0, image.width, 34), fill="#101828")
    draw.text((8, 9), f"{status.upper()} | {title}", fill=status_color, font=font)
    output_path.parent.mkdir(parents=True, exist_ok=True)
    image.save(output_path, "JPEG", quality=90, optimize=True)
    return {
        "image": str(output_path), "source": str(image_path), "status": status,
        "primitive_count": len(primitives), "primitives": primitives,
    }