| """Step through an instrument's front-panel menu and save the screen after every step. |
| |
| python examples/preview_menu.py aqualab_4te btn3=MENU down btn2=ENTER up btn2=SAVE |
| python examples/preview_menu.py ika_plate_rctdigital menu_key turn:knob_speed:1 speed_push_key menu_key |
| python examples/preview_menu.py julabo_corio_cd200f --list |
| python examples/preview_menu.py mt_xpr204e tap:Methods tap:Tests tap:Close --out preview_xpr |
| |
| The instrument starts at its home screen (power on, world set up). Each step is one gesture, sent through the |
| agent session of the instrument's runtime with the contract's panel capabilities: |
| |
| KEY or press:KEY[:SECONDS] panel.press a key, or a knob's push key (SECONDS >= hold time = long press) |
| turn:KNOB:DETENTS panel.turn an encoder or knob, signed detents (+ = clockwise) |
| switch:SWITCH:POSITION panel.switch a switch, e.g. switch:power_switch:off |
| touch:DISPLAY:X,Y[:SECONDS] panel.touch a touch screen, pixel coordinates of that display |
| touch:DISPLAY:X,Y>X2,Y2 panel.touch drag from (X, Y) to (X2, Y2) |
| tap:LABEL panel.touch touch the centre of the button (or list row) labelled LABEL |
| wait:SECONDS - let simulated time pass (timeouts, warm-up, blinking) |
| STEP=CAPTION any step with its own caption in strip.png, e.g. btn3=MENU |
| |
| After each step the screen is captured with panel.capture (what a camera on the display would see) and written as |
| <out>/NN_<step>.png; <out>/strip.png puts all frames side by side with the step under each. --list prints the |
| inputs, displays and, for touch screens, the labelled buttons on the current page. |
| |
| tap:LABEL looks the button up in the structured screen (panel.frame), which is an evaluator-only view; an agent |
| policy that should rely on pixels only uses touch:DISPLAY:X,Y instead. Everything else uses the agent view. |
| The script finds assets/ and scripts/ next to its own folder, so it runs from anywhere. Needs numpy and Pillow. |
| """ |
| import argparse |
| import inspect |
| import importlib |
| import json |
| import re |
| import shutil |
| import sys |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| for p in (ROOT, ROOT / "scripts"): |
| if str(p) not in sys.path: |
| sys.path.insert(0, str(p)) |
| TABLE = json.load(open(Path(__file__).resolve().parent / "panel_instruments.json", encoding="utf-8"))["instruments"] |
| PRESSABLE = ("button", "key", "tab", "tile", "toggle", "checkbox", "radio", "icon_button", "softkey") |
|
|
|
|
| class Instrument: |
| """One runtime host with an agent session (gestures, screens) and an evaluator session (world set-up).""" |
|
|
| def __init__(self, slug, instance_id=None): |
| self.slug, self.cfg = slug, TABLE[slug] |
| self.iid = instance_id or f"{slug}_01" |
| self.t = 0.0 |
| self._n = 0 |
| h = self.cfg["host"] |
| cls = getattr(importlib.import_module(h["module"]), h["cls"]) |
| params = inspect.signature(cls.__init__).parameters |
| kw = dict(h.get("ctor") or {}) |
| if "scene_adapter" in params and h.get("ctor_scene_adapter", True): |
| kw["scene_adapter"] = lambda instance, updates: None |
| if h.get("advance") is None and "clock" in params: |
| kw["clock"] = lambda: self.t |
| if h.get("instance_kw"): |
| kw[h["instance_kw"]] = self.iid |
| self.host = cls(**kw) |
| else: |
| self.host = cls(self.iid, **kw) if h.get("instance_in_ctor") else cls(**kw) |
| create = h.get("create") |
| if create == "type": |
| self.host.create_instance(self.iid, self.cfg["asset_type_id"]) |
| elif create == "plain": |
| self.host.create_instance(self.iid) |
| elif create == "scene": |
| self.host.create_instance(self.iid, lambda instance, updates: None) |
| if h.get("host_is_session"): |
| self.agent = self.lab = self.host |
| else: |
| self.agent = self._session("preview_agent", "agent", h) |
| self.lab = self._session("preview_lab", "evaluator", h) |
| self.contract = json.load(open(ROOT / self.cfg["contract"], encoding="utf-8")) |
| self.spec = json.load(open(ROOT / self.cfg["panel_spec"], encoding="utf-8")) |
|
|
| def _session(self, name, visibility, h): |
| if visibility == "agent" and h.get("agent_session_default"): |
| return self.host.session() |
| if visibility == "evaluator" and h.get("evaluator_register_positional"): |
| self.host.register_principal(name) |
| else: |
| try: |
| self.host.register_principal(name, visibility=visibility) |
| except TypeError: |
| self.host.register_principal(name, visibility) |
| return self.host.session(name) |
|
|
| def call(self, capability, arguments=None, evaluator=False): |
| self._n += 1 |
| s = self.lab if evaluator else self.agent |
| return s.invoke(instance_id=self.iid, capability_id=capability, arguments=dict(arguments or {}), |
| request_id=f"preview-{self._n}") |
|
|
| def advance(self, seconds, dt=1.0): |
| """Advance the simulated clock in steps of at most dt seconds, with the runtime's own clock call.""" |
| mode, h = self.cfg["host"].get("advance"), self.host |
| left = float(seconds) |
| while left > 1e-9: |
| d = min(dt, left) |
| t_new = self.t + d |
| if mode == "step_dt": |
| h.step(d) |
| elif mode == "host_step_dt": |
| h.host_step(d) |
| elif mode == "host_step_dt_world": |
| h.host_step(d, world_time_s=t_new) |
| elif mode == "step_dt_world": |
| h.step(d, world_time_s=t_new) |
| elif mode == "host_step_abs": |
| h.host_step(t_new) |
| elif mode == "host_advance_abs": |
| h.host_advance(t_new) |
| elif mode == "host_set_clock_abs": |
| h.host_set_clock(t_new) |
| elif mode == "vici_set_time": |
| h.host_set_time(world_time_s=t_new, request_id=f"preview-clock-{self._n}-{t_new:.3f}") |
| self.t = t_new |
| left -= d |
|
|
| def bring_up(self): |
| caps = self.contract.get("capabilities") or {} |
| for st in self.cfg["bringup"]: |
| if "advance_s" in st: |
| self.advance(st["advance_s"]) |
| continue |
| args = st.get("arguments") |
| if args == "contract_example": |
| args = (caps.get(st["capability"]) or {}).get("example_arguments") or {} |
| r = self.call(st["capability"], args, evaluator=bool(st.get("evaluator"))) |
| if r.get("status") not in ("succeeded", "accepted", "running"): |
| print(f" note: bring-up step {st['capability']} -> {r.get('status')} {(r.get('error') or {}).get('code')}") |
|
|
| def capture(self, display, dst): |
| """panel.capture of one display into dst; display 'all' puts every display side by side (LED-only panels).""" |
| if display != "all": |
| shutil.copyfile(self._capture_one(display), dst) |
| return dst |
| from PIL import Image, ImageDraw |
| ims = [(d, Image.open(self._capture_one(d)).convert("RGB")) for d in self.spec["displays"]] |
| h = max(im.height for _, im in ims) |
| k = max(1, 96 // h) |
| ims = [(d, im.resize((im.width * k, im.height * k), Image.NEAREST)) for d, im in ims] |
| w = max(max(im.width for _, im in ims), 72) |
| out = Image.new("RGB", (len(ims) * (w + 8) + 8, h * k + 30), (40, 44, 50)) |
| dr = ImageDraw.Draw(out) |
| for i, (d, im) in enumerate(ims): |
| x = 8 + i * (w + 8) + (w - im.width) // 2 |
| out.paste(im, (x, 6)) |
| dr.text((8 + i * (w + 8), h * k + 12), d.removeprefix("led_")[:12], fill=(220, 224, 230)) |
| out.save(dst) |
| return dst |
|
|
| def _capture_one(self, display): |
| r = self.call("panel.capture", {"display_id": display}) |
| if r.get("status") != "succeeded": |
| raise SystemExit(f"panel.capture {display}: {r.get('status')} {r.get('error')}") |
| return r["result"]["image"]["path"] |
|
|
| def frame(self): |
| r = self.call("panel.frame", {}, evaluator=True) |
| return (r.get("result") or {}).get("frame") or {} |
|
|
| def schema(self, capability): |
| d = self.agent.describe(instance_id=self.iid)["capabilities"] |
| caps = d if isinstance(d, dict) else {c.get("capability_id"): c for c in d} |
| return ((caps.get(capability) or {}).get("input_schema") or {}).get("properties") or {} |
|
|
|
|
| |
| def touch_targets(frame, display): |
| """Labelled, enabled buttons and list rows on the current page of a touch display: [(label, x, y)].""" |
| out = [] |
| d = (frame.get("displays") or {}).get(display) or {} |
| for w in d.get("widgets") or []: |
| if not w.get("enabled", True) or not w.get("rect"): |
| continue |
| x, y, ww, hh = w["rect"] |
| if w.get("type") in PRESSABLE and str(w.get("text") or "").strip(): |
| out.append((str(w["text"]).strip(), x + ww // 2, y + hh // 2)) |
| rh = w.get("row_h") |
| for i, row in enumerate(w.get("rows") or []): |
| if rh and isinstance(row, str) and row.strip(): |
| cy = y + (i - int(w.get("scroll") or 0)) * rh + rh // 2 |
| if y <= cy < y + hh: |
| label = (w.get("cells") or [[row]])[i][0] if w.get("cells") else row |
| out.append((str(label).strip(), x + ww // 2, cy)) |
| return out |
|
|
|
|
| def parse_step(text, inst): |
| """'press:menu_key:2' -> (capability, arguments, label); ('wait', seconds, label) for wait steps.""" |
| parts = text.split(":") |
| verb = parts[0].lower() |
| if verb not in ("press", "turn", "switch", "touch", "tap", "wait"): |
| verb, parts = "press", ["press"] + parts |
| if verb == "wait": |
| return "wait", float(parts[1]), f"wait {parts[1]} s" |
| if verb == "press": |
| args = {"input_id": parts[1]} |
| if len(parts) > 2: |
| args["duration_s"] = float(parts[2]) |
| return "panel.press", args, ("hold " if len(parts) > 2 and float(parts[2]) >= 1 else "") + parts[1] |
| if verb == "turn": |
| n = int(parts[2]) |
| return "panel.turn", {"input_id": parts[1], "detents": n}, f"turn {parts[1]} {n:+d}" |
| if verb == "switch": |
| return "panel.switch", {"input_id": parts[1], "position": parts[2]}, f"{parts[1]} {parts[2]}" |
| if verb == "touch": |
| m = re.fullmatch(r"(\d+),(\d+)(?:>(\d+),(\d+))?", parts[2]) |
| if not m: |
| raise SystemExit(f"touch needs X,Y or X,Y>X2,Y2: {text}") |
| args = {"display_id": parts[1], "x": int(m.group(1)), "y": int(m.group(2))} |
| if m.group(3): |
| args.update(to_x=int(m.group(3)), to_y=int(m.group(4))) |
| if len(parts) > 3: |
| args["duration_s"] = float(parts[3]) |
| return "panel.touch", args, f"touch {m.group(0)}" |
| |
| label = text.split(":", 1)[1] |
| disp = [k for k, v in inst.spec["displays"].items() if v["kind"] == "touch_tft"] |
| frame = inst.frame() |
| for d in disp: |
| hits = [t for t in touch_targets(frame, d) if t[0].lower() == label.lower()] or \ |
| [t for t in touch_targets(frame, d) if t[0].lower().startswith(label.lower())] |
| if hits: |
| _, x, y = hits[0] |
| return "panel.touch", {"display_id": d, "x": int(x), "y": int(y)}, f"tap {label}" |
| raise SystemExit(f"no button labelled {label!r} on the current page (see --list)") |
|
|
|
|
| def safe(s): |
| return re.sub(r"[^A-Za-z0-9_.+-]+", "_", s).strip("_")[:40] or "step" |
|
|
|
|
| def strip_image(frames, path, height=None, cols=None): |
| """Frames in reading order (one row, or wrapped after cols frames), same height (pixel-exact scaling for small displays), |
| the step and whether the instrument accepted it written under each frame.""" |
| from PIL import Image, ImageDraw, ImageFont |
| ims = [Image.open(f).convert("RGB") for f, _, _ in frames] |
| h = height or max(240, min(480, max(im.height for im in ims))) |
| scaled = [] |
| for im in ims: |
| k = h / im.height |
| res = Image.NEAREST if k >= 2 else Image.LANCZOS |
| scaled.append(im.resize((max(1, round(im.width * k)), h), res)) |
| try: |
| font = ImageFont.load_default(size=max(16, h // 11)) |
| except TypeError: |
| font = ImageFont.load_default() |
| pad, cap = 14, max(34, h // 7) |
| w = max(im.width for im in scaled) |
| if not cols: |
| fit = max(1, min(len(scaled), 2400 // (w + pad))) |
| cols = -(-len(scaled) // -(-len(scaled) // fit)) |
| rows = -(-len(scaled) // cols) |
| out = Image.new("RGB", (cols * (w + pad) + pad, rows * (h + cap + pad) + pad), (246, 247, 249)) |
| dr = ImageDraw.Draw(out) |
| for i, (im, (_, label, ok)) in enumerate(zip(scaled, frames)): |
| x, y = pad + (i % cols) * (w + pad), pad + (i // cols) * (h + cap + pad) |
| out.paste(im, (x, y)) |
| dr.rectangle([x - 1, y - 1, x + im.width, y + h], outline=(200, 204, 210)) |
| txt = f"{i}. {label}" if i else label |
| if ok is False: |
| txt += " (ignored)" |
| dr.text((x, y + h + 8), txt, fill=(21, 32, 42) if ok is not False else (160, 60, 40), font=font) |
| out.save(path) |
| return path |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| ap.add_argument("instrument", help="slug, e.g. ika_plate_rctdigital (examples/panel_instruments.json lists all)") |
| ap.add_argument("steps", nargs="*", help="gestures, see above") |
| ap.add_argument("--out", help="output folder (default: menu_preview/<slug>)") |
| ap.add_argument("--display", help="display to capture, or 'all' (default: the main screen; 'all' on LED-only panels)") |
| ap.add_argument("--settle", type=float, default=1.0, |
| help="simulated seconds after each gesture (default 1.0, which also keeps blinking fields in their visible phase)") |
| ap.add_argument("--cols", type=int, help="frames per row in strip.png (default: as many as fit in 2400 px)") |
| ap.add_argument("--list", action="store_true", help="print inputs, displays and touch targets, then stop") |
| ap.add_argument("--no-bringup", action="store_true", help="start powered off, without the home-screen set-up") |
| args = ap.parse_args() |
| slug = args.instrument.split(".", 1)[-1] |
| if slug not in TABLE: |
| raise SystemExit(f"{slug}: no front-panel menu in this release (see examples/panel_instruments.json)") |
| inst = Instrument(slug) |
| if not args.no_bringup: |
| inst.bring_up() |
| display = args.display or inst.cfg["main_display"] |
|
|
| if args.list: |
| print(f"{slug}: {inst.cfg['panel_ui'].replace('_', ' ')} panel; capabilities {', '.join(inst.cfg['panel_capabilities'])}") |
| for cap in ("panel.press", "panel.turn"): |
| p = inst.schema(cap) |
| if p: |
| names = [f"{k} ({inst.spec['inputs'][k]['label']})" if inst.spec["inputs"].get(k, {}).get("label") not in (None, k) else k |
| for k in p["input_id"]["enum"]] |
| print(f" {cap:13s} {', '.join(names)}") |
| for k in inst.schema("panel.switch").get("input_id", {}).get("enum", []): |
| print(f" panel.switch {k}: {' / '.join(inst.spec['inputs'][k].get('positions', []))}") |
| for did, d in inst.spec["displays"].items(): |
| size = "x".join(str(v) for v in d.get("size", [])) or "-" |
| print(f" display {did:16s} {d['kind']:12s} {size}{' (main)' if did == display or display == 'all' else ''}") |
| fr = inst.frame() |
| print(f" current screen: {fr.get('screen')}") |
| for did, d in inst.spec["displays"].items(): |
| if d["kind"] == "touch_tft": |
| for label, x, y in touch_targets(fr, did): |
| print(f" tap:{label:24s} = touch:{did}:{x},{y}") |
| return |
|
|
| out = Path(args.out or f"menu_preview/{slug}") |
| out.mkdir(parents=True, exist_ok=True) |
| for old in list(out.glob("[0-9][0-9]_*.png")) + [out / "strip.png"]: |
| old.unlink(missing_ok=True) |
| frames = [(inst.capture(display, out / "00_start.png"), "start", None)] |
| for i, text in enumerate(args.steps, 1): |
| text, _, caption = text.partition("=") |
| cap, a, label = parse_step(text, inst) |
| label = caption or label |
| ok = None |
| if cap == "wait": |
| inst.advance(a) |
| else: |
| r = inst.call(cap, a) |
| if r.get("status") != "succeeded": |
| raise SystemExit(f"step {i} {text}: {r.get('status')} {(r.get('error') or {}).get('code')} " |
| f"{(r.get('error') or {}).get('message')}") |
| ok = bool((r.get("result") or {}).get("accepted")) |
| inst.advance(args.settle) |
| f = inst.capture(display, out / f"{i:02d}_{safe(label)}.png") |
| frames.append((f, label, ok)) |
| print(f"{i:2d}. {label:28s} {'' if ok is None else ('accepted' if ok else 'ignored by the instrument')} -> {f.name}") |
| strip_image(frames, out / "strip.png", cols=args.cols) |
| print("strip:", out / "strip.png") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
