scripts/verify_rgb_graph_alignment.py

#!/usr/bin/env python3
"""Verify online GWAM graph / multi-view RGB / mask alignment on a live RoboCasa env.

This is an integration smoke for the team-facing contract:

  snapshot = extractor.extract_final_graph(...)
  snapshot['gnn_graph'] is the fused graph from the current state
  snapshot['rgb_frames'][v] is the current RGB image for view id v
  snapshot['rle_masks'][*]['v'] and visual_features_sparse['v'] use the same v

The default backend is fake so this can run without SAM2/CLIP while still
checking state/RGB/mask/feature plumbing. Use scripts/verify_realtime_final_graph.py
for the real SAM2/CLIP backend gate.
"""
from __future__ import annotations

import argparse
import gzip
import hashlib
import json
import sys
import tempfile
from pathlib import Path

import numpy as np

PACKAGE_ROOT = Path(__file__).resolve().parents[1]
if str(PACKAGE_ROOT) not in sys.path:
    sys.path.insert(0, str(PACKAGE_ROOT))

from examples.realtime_env_graph_eval_loop import FakeVisualBackend, make_env, zero_action  # noqa: E402
from realtime.gwam_realtime_env_graph import (  # noqa: E402
    RealtimeGWAMGraphExtractor,
    build_online_visual_features,
    render_rgb_frames,
    render_visibility_and_masks,
    save_realtime_graph_snapshot,
)


def state_digest(sim) -> str:
    h = hashlib.sha256()
    h.update(np.asarray(sim.data.qpos, dtype=np.float64).tobytes())
    h.update(np.asarray(sim.data.qvel, dtype=np.float64).tobytes())
    h.update(np.asarray([sim.data.time], dtype=np.float64).tobytes())
    return h.hexdigest()


def rle_key(row: dict) -> tuple[int, int, str]:
    return int(row["n"]), int(row["v"]), json.dumps(row["rle"], separators=(",", ":"))


def main() -> int:
    ap = argparse.ArgumentParser()
    ap.add_argument("--task", default="OpenDrawer")
    ap.add_argument("--robots", default="PandaOmron")
    args = ap.parse_args()

    env = make_env(args.task, args.robots)
    try:
        env.reset()
        extractor = RealtimeGWAMGraphExtractor(env)
        backend = FakeVisualBackend()
        before = state_digest(extractor.sim)
        snapshot = extractor.extract_final_graph(visual_backend=backend, include_masks=True)
        after = state_digest(extractor.sim)
        assert before == after, "extract_final_graph advanced or mutated sim state"

        graph = snapshot["gnn_graph"]
        assert graph["x"].shape[1] == 342, graph["x"].shape
        assert graph["edge_attr"].shape[1] == 8, graph["edge_attr"].shape
        assert snapshot["rgb_frame_cameras"] == ["robot0_agentview_right", "robot0_agentview_left", "robot0_eye_in_hand"]
        assert len(snapshot["rgb_frames"]) == 3
        for v, frame in snapshot["rgb_frames"].items():
            assert int(v) in (0, 1, 2)
            assert frame.shape == (256, 256, 3), frame.shape
            assert frame.dtype == np.uint8, frame.dtype

        # Re-render from the still-current state; RGB and segmentation/masks must match.
        rgb2 = render_rgb_frames(extractor.sim, cameras=extractor.cameras)
        for v in snapshot["rgb_frames"]:
            assert np.array_equal(snapshot["rgb_frames"][v], rgb2[v]), f"RGB view {v} changed without env.step"
        visible2, centroid2, area2, bbox2, rle2 = render_visibility_and_masks(
            extractor.sim, extractor.g2n, len(extractor.specs), cameras=extractor.cameras, include_rle=True
        )
        assert np.array_equal(snapshot["view_visible"], visible2)
        assert np.allclose(snapshot["view_centroid"], centroid2, equal_nan=True)
        assert np.allclose(snapshot["view_area"], area2, equal_nan=True)
        assert np.allclose(snapshot["view_bbox"], bbox2, equal_nan=True)
        assert sorted(map(rle_key, snapshot["rle_masks"])) == sorted(map(rle_key, rle2))

        # Sparse feature provenance: recomputing with returned RGB/masks matches.
        recomputed = build_online_visual_features(
            rgb_frames=snapshot["rgb_frames"],
            rle_rows=snapshot["rle_masks"],
            nodes=snapshot["graph_static"]["nodes"],
            visual_backend=backend,
            t=0,
        )
        visual = snapshot["visual_features_sparse"]
        for key in ["t", "n", "v", "feat", "type_clip32", "visual_computed", "invalid_t", "invalid_n", "invalid_v"]:
            assert np.array_equal(visual[key], recomputed[key]), key
        assert len(visual["n"]) + len(visual["invalid_n"]) == len(snapshot["rle_masks"])

        # Node-state visibility flags match the view_visible matrix for active nodes.
        active = snapshot["node_state"][:, 0] == 1
        assert np.array_equal(snapshot["node_state"][active, 19:22].astype(bool), snapshot["view_visible"][active])
        assert not any(e.get("rel") == "visibility_change" for e in snapshot["dynamic_edges"]), "first call should not have visibility_change edges"

        # Persistence contract: saved RGB, masks, node_state, cameras round-trip.
        with tempfile.TemporaryDirectory(prefix="gwam-rgb-align-") as td:
            out = Path(td)
            save_realtime_graph_snapshot(snapshot, out)
            manifest = json.loads((out / "rgb_manifest.json").read_text())
            assert [v["camera"] for v in manifest["views"]] == snapshot["rgb_frame_cameras"]
            for rec in manifest["views"]:
                arr = np.load(out / rec["path"])
                assert np.array_equal(arr, snapshot["rgb_frames"][int(rec["view_id"])])
            ve = np.load(out / "graph/view_evidence.npz")
            assert list(ve["cameras"]) == snapshot["rgb_frame_cameras"]
            assert np.array_equal(ve["view_visible"][0], snapshot["view_visible"])
            ns = np.load(out / "graph/node_state.npz")
            assert np.array_equal(ns["node_state"][0], snapshot["node_state"])
            with gzip.open(out / "graph/visible_masks_rle.jsonl.gz", "rt") as f:
                saved_masks = json.loads(f.readline())["masks"]
            assert sorted(map(rle_key, saved_masks)) == sorted(map(rle_key, snapshot["rle_masks"]))

        # Currency after one env step: t increments. RGB often changes even for zero action,
        # but we only require the extractor not to reuse stale t/cache.
        env.step(zero_action(env))
        snapshot2 = extractor.extract_final_graph(visual_backend=backend, include_masks=True)
        assert snapshot2["t"] == snapshot["t"] + 1
        assert len(snapshot2["rgb_frames"]) == 3

        result = {
            "ok": True,
            "N_real": int(graph["metadata"]["N_real"]),
            "D_node": int(graph["x"].shape[1]),
            "D_edge": int(graph["edge_attr"].shape[1]),
            "n_visible_pairs": int(len(snapshot["rle_masks"])),
            "n_feat_rows": int(len(visual["n"])),
            "rgb_cameras": snapshot["rgb_frame_cameras"],
        }
        print("verify_rgb_graph_alignment_ok", json.dumps(result, sort_keys=True))
        return 0
    finally:
        try:
            env.close()
        except Exception:
            pass


if __name__ == "__main__":
    raise SystemExit(main())