procthor_engine/sim.py

"""ProcTHOR/AI2-THOR rollout wrapper — generate one episode end-to-end.

Lifecycle:
    eng = ProcTHOREngine(width=512, height=512, fov=90, device=3)
    eng.start()                                 # spins up CloudRendering controller
    for ep_idx in range(N):
        ep = eng.run_one(seed=ep_idx)           # returns EpisodeRecord (schema.EpisodeRecord)
        write_episode(ep, ...)
    eng.stop()

`run_one` does:
    1) Generate procthor house
    2) Pick start position + a reachable goal object
    3) GetShortestPath → list of waypoints
    4) Walk the path. At each step:
        a) Take an action (forward / left / right) chosen to follow the path
        b) Record RGB + depth + agent pose
        c) Record visible objects with projected (u, v)
        d) Compute waypoint_uv (path[t + lookahead] projected to FOV)
        e) Compute goal_uv (goal centroid projected)
        f) Generate QA pairs
        g) Sample an action chunk (next K poses → body-frame vels)
    5) Segment actions → phases
    6) Build PhaseFacts per phase → render subcommands
    7) Return EpisodeRecord
"""
from __future__ import annotations
import math
import random
import time
from pathlib import Path
from typing import Dict, List, Optional, Tuple

import numpy as np

from .schema import StepRecord, EpisodeRecord
from .projection import CameraIntrinsics, CameraPose, project_point, project_points_batch
from .phase_segment import segment_actions, FORWARD, LEFT, RIGHT, STOP
from .subcommands import PhaseFacts, render_episode, stitch_instruction
from .descriptions import pick_canonical, _type_to_noun
from . import qa as qa_mod


# ---------------------------------------------------------------- #
# Controller-level helpers                                          #
# ---------------------------------------------------------------- #

class ProcTHOREngine:
    def __init__(self,
                 width: int = 512, height: int = 512,
                 fov_vertical_deg: float = 90,
                 device_id: int = 0,
                 quality: str = "Low",
                 grid_size: float = 0.25,
                 horizon: float = 0.0,
                 split: str = "train",
                 frames_root: Optional[str] = None,
                 save_depth: bool = False):
        self.width = width
        self.height = height
        self.fov = fov_vertical_deg
        self.device_id = device_id
        self.quality = quality
        self.grid_size = grid_size
        self.horizon = horizon
        self.split = split
        self.frames_root = frames_root          # if set, save RGB (and optionally depth) per step
        self.save_depth = save_depth
        self.controller = None
        self.intr = CameraIntrinsics(width, height, fov_vertical_deg)
        self._hg = None                          # procthor.generation.HouseGenerator

    # ------------ lifecycle ------------ #
    def start(self):
        from ai2thor.controller import Controller
        from procthor.generation import HouseGenerator, PROCTHOR10K_ROOM_SPEC_SAMPLER
        from procthor.constants import PROCTHOR_INITIALIZATION
        # PROCTHOR_INITIALIZATION = dict(branch="main", scene="Procedural")
        # branch="main" makes ai2thor fetch the latest main-branch build that has the
        # `SpawnAsset` / `CreateHouse` / `Procedural` actions procthor relies on.
        # scene="Procedural" puts the controller into procedural-house mode.
        self.controller = Controller(
            platform="CloudRendering",
            width=self.width, height=self.height,
            fieldOfView=self.fov,
            quality=self.quality,
            renderDepthImage=True,
            renderInstanceSegmentation=True,
            gridSize=self.grid_size,
            visibilityDistance=10,
            **PROCTHOR_INITIALIZATION,
        )
        self._hg = HouseGenerator(split=self.split, seed=0, controller=self.controller,
                                    room_spec_sampler=PROCTHOR10K_ROOM_SPEC_SAMPLER)

    def stop(self):
        if self.controller is not None:
            try: self.controller.stop()
            except Exception: pass
            self.controller = None

    # ------------ one episode ------------ #
    def run_one(self,
                episode_idx: int,
                house_seed: int,
                max_steps: int = 60,
                lookahead: int = 5,
                k_chunk: int = 10,
                action_chunk_dt_s: float = 0.1,
                rng_seed: Optional[int] = None
                ) -> Optional[EpisodeRecord]:
        """One episode end-to-end. Returns None if the rollout fails (e.g. no path)."""
        c = self.controller
        rng = random.Random(rng_seed if rng_seed is not None else episode_idx)
        self._current_episode_id = f"procthor_{episode_idx:07d}"

        # 1) Reset to a clean Procedural scene, then generate a house
        c.reset(scene="Procedural")
        house, _ = self._hg.sample()
        if hasattr(house, "data"):
            house_dict = house.data
        elif hasattr(house, "to_house_dict"):
            house_dict = house.to_house_dict()
        else:
            house_dict = house
        ev = c.step(action="CreateHouse", house=house_dict)
        if not ev.metadata.get("lastActionSuccess", False):
            print(f"  [run_one ep{episode_idx}] CreateHouse failed: "
                  f"{ev.metadata.get('errorMessage', '')[:120]}", flush=True)
            return None

        # 2) Teleport to the house's nominal agent spawn (in house.metadata.agent)
        agent_meta = house_dict.get("metadata", {}).get("agent", {})
        spawn_pos = agent_meta.get("position", {"x": 0, "y": 0.9, "z": 0})
        c.step(action="Teleport",
               position=spawn_pos,
               rotation=agent_meta.get("rotation", dict(x=0, y=0, z=0)),
               horizon=agent_meta.get("horizon", self.horizon))
        positions = c.step(action="GetReachablePositions").metadata.get("actionReturn", [])
        if not positions:
            self._diag = "no_reachable"; return None

        # Try up to N (start_pos, goal_obj) pairs until we find one with a quality route.
        # Quality criteria: goal >=2.5m away (Euclidean), path planner returns >=3 corners
        # (means there's an actual turn, not just walk-in-a-line). Filters out the trivial
        # "0.2m straight-to-goal" episodes that produce 2-step rollouts.
        start_pos = None
        goal_obj = None
        path = []
        for attempt in range(12):
            sp = rng.choice(positions)
            c.step(action="Teleport",
                   position=sp,
                   rotation=dict(x=0, y=rng.choice([0, 90, 180, 270]), z=0),
                   horizon=self.horizon)
            ev = c.step(action="Pass")
            cand_goal = self._pick_goal_object(
                ev.metadata.get("objects", []), sp, rng, min_dist=2.5)
            if cand_goal is None: continue
            cand_path = self._get_path(sp, cand_goal["position"], cand_goal["objectId"])
            if cand_path and len(cand_path) >= 3:
                start_pos = sp; goal_obj = cand_goal; path = cand_path
                break
        if start_pos is None:
            self._diag = "no_pathable_start_goal_pair"; return None
        goal_pos = goal_obj["position"]

        # 4) Walk the path, recording per-step data
        steps: List[StepRecord] = []
        actions: List[int] = []
        path_idx = 1                              # index into `path` we're currently heading to
        for t in range(max_steps):
            ev = c.step(action="Pass")            # refresh metadata at current pose
            agent = ev.metadata["agent"]
            pose_xyz = [agent["position"]["x"], agent["position"]["y"], agent["position"]["z"]]
            yaw = agent["rotation"]["y"]
            pitch = ev.metadata.get("cameraHorizon", self.horizon)

            # Decide action: forward if facing the next waypoint, else turn toward it
            if path_idx >= len(path):
                action_id = STOP
            else:
                tgt = path[path_idx]
                action_id = self._next_action_toward(pose_xyz, yaw, tgt)

            actions.append(action_id)

            # Project + record before stepping (so this frame matches the action we're about to emit)
            self._record_step(t, action_id, ev, pose_xyz, yaw, pitch,
                              goal_obj, path, path_idx, lookahead, steps, rng)

            # Step
            if action_id == STOP: break
            cmd = {1: "MoveAhead", 2: "RotateLeft", 3: "RotateRight"}[action_id]
            c.step(action=cmd)

            # Advance path_idx if we're close enough to current target
            if path_idx < len(path):
                tgt = path[path_idx]
                d = math.hypot(tgt[0] - pose_xyz[0], tgt[2] - pose_xyz[2])
                if d < self.grid_size * 1.5:
                    path_idx += 1

        # Add a final stop record so STOP is the last action
        if actions and actions[-1] != STOP:
            actions.append(STOP)

        # 5) Segment actions → phases
        spans, kinds = segment_actions(actions)

        # 6) Build per-phase facts from rollout knowledge + render subcommands
        phase_facts = self._build_phase_facts(
            spans, kinds, actions, steps, goal_obj, path, rng)
        subs = render_episode(phase_facts, rng)
        instruction = stitch_instruction(subs)

        # 7) Compute action chunks per step (forward-diff agent poses → body-frame vels)
        self._fill_action_chunks(steps, k_chunk, action_chunk_dt_s)

        # 8) Goal description fact (for the final subcommand stitching, already used above)
        return EpisodeRecord(
            episode_id=f"procthor_{episode_idx:07d}",
            house_seed=house_seed,
            goal_object=goal_obj["objectId"],
            instruction=instruction,
            subcommands=subs,
            phase_spans=[list(s) for s in spans],
            phase_kinds=kinds,
            actions=actions,
            steps=steps,
            camera_intrinsics=self.intr.as_dict(),
            video_dir="",                          # caller fills this in
            meta={
                "goal_object_type": goal_obj.get("objectType", ""),
                "goal_pos": goal_pos,
                "start_pos": [start_pos["x"], start_pos["y"], start_pos["z"]],
                "path_len_m": self._path_len(path),
                "n_steps": len(actions),
            },
        )

    # ---------------------------------------------------------------- #
    # internals                                                        #
    # ---------------------------------------------------------------- #
    def _pick_goal_object(self, objects: List[Dict], start_pos, rng, min_dist: float = 1.0):
        """Pick a reasonable goal: salient object at least `min_dist` m from start."""
        SKIP = {"Floor", "Wall", "Ceiling", "Window", "Door", "Doorway",
                "Doorframe", "RoomDecal", ""}
        cand = []
        for o in objects:
            if not o.get("position"): continue
            d = math.hypot(o["position"]["x"] - start_pos["x"],
                            o["position"]["z"] - start_pos["z"])
            if d < min_dist: continue
            ty = o.get("objectType", "")
            if ty in SKIP: continue
            cand.append(o)
        if not cand: return None
        return rng.choice(cand)

    def _get_path(self, start_pos, goal_pos, goal_object_id) -> List[Tuple[float, float, float]]:
        """Use AI2-THOR's GetShortestPath to find a discrete path. Returns list of (x,y,z)."""
        try:
            ev = self.controller.step(
                action="GetShortestPath",
                objectId=goal_object_id,
                position=start_pos,
            )
            corners = ev.metadata.get("actionReturn", {}).get("corners", [])
        except Exception:
            corners = []
        out = []
        for c in corners:
            out.append((c["x"], c["y"], c["z"]))
        return out

    def _path_len(self, path):
        d = 0.0
        for i in range(1, len(path)):
            dx = path[i][0] - path[i-1][0]
            dz = path[i][2] - path[i-1][2]
            d += math.hypot(dx, dz)
        return d

    def _next_action_toward(self, pose_xyz, yaw_deg, tgt) -> int:
        """Choose between MoveAhead / RotateLeft / RotateRight to head toward `tgt`."""
        dx = tgt[0] - pose_xyz[0]
        dz = tgt[2] - pose_xyz[2]
        # AI2-THOR yaw: 0 = +Z, 90 = +X, etc (clockwise from N looking down)
        target_yaw = (math.degrees(math.atan2(dx, dz)) + 360) % 360
        # delta in [-180, 180]
        delta = ((target_yaw - yaw_deg + 540) % 360) - 180
        if abs(delta) < 15: return FORWARD       # within tolerance, go forward
        return RIGHT if delta > 0 else LEFT

    def _record_step(self, t, action_id, ev, pose_xyz, yaw, pitch,
                     goal_obj, path, path_idx, lookahead, steps, rng):
        # AI2-THOR convention: rotation.y=0 means agent faces world +Z.
        # Our projection's yaw=0 means camera looks along world -Z (OpenGL).
        # Add 180° to convert AI2-THOR yaw → projection yaw.
        cam = CameraPose(x=pose_xyz[0], y=pose_xyz[1] + 0.675, z=pose_xyz[2],
                         yaw_deg=yaw + 180.0, pitch_deg=pitch)
        # waypoint_uv: project path[path_idx + lookahead - 1] (or last point)
        wp_idx = min(path_idx + max(0, lookahead - 1), len(path) - 1)
        wp = path[wp_idx]
        wu, wv, wd = project_point(np.array(wp), cam, self.intr)
        waypoint_uv = [wu, wv] if wu is not None else None

        # goal_uv
        gpos = goal_obj["position"]
        gu, gv, gd = project_point(
            np.array([gpos["x"], gpos["y"], gpos["z"]]), cam, self.intr)
        goal_uv = [gu, gv] if gu is not None else None

        # visible objects with projected centroids — filter walls/typeless from QA pool
        SKIP_TYPES = {"Floor", "Wall", "Ceiling", "Window", "Door", "Doorway",
                      "Doorframe", "RoomDecal", ""}
        vis_objs = []
        for o in ev.metadata.get("objects", []):
            if not o.get("visible", False): continue
            ty = o.get("objectType", "")
            if ty in SKIP_TYPES: continue
            p = o["position"]
            u, v, d = project_point(np.array([p["x"], p["y"], p["z"]]), cam, self.intr)
            if u is None: continue
            vis_objs.append({
                "name": o.get("name", ""),
                "object_type": ty,
                "uv": [u, v],
                "depth_m": d,
                "pos_3d": [p["x"], p["y"], p["z"]],
                "salientMaterials": o.get("salientMaterials", []),
                "mainColor": o.get("color", o.get("mainColor", None)),
                "roomType": o.get("roomType", None),
            })

        # Save RGB (and optionally depth) for this step if a frames_root was set.
        if self.frames_root is not None:
            from PIL import Image
            from pathlib import Path
            ep_dir = Path(self.frames_root) / self._current_episode_id / "rgb"
            ep_dir.mkdir(parents=True, exist_ok=True)
            frame = ev.frame
            if frame is not None:
                Image.fromarray(frame).save(ep_dir / f"{t:05d}.jpg", quality=85)
            if self.save_depth and ev.depth_frame is not None:
                d_dir = Path(self.frames_root) / self._current_episode_id / "depth"
                d_dir.mkdir(parents=True, exist_ok=True)
                np.save(d_dir / f"{t:05d}.npy", ev.depth_frame.astype(np.float32))

        # Next-action hint for QA: same action_id we just decided
        qa_pairs = qa_mod.for_step(
            visible_objects=vis_objs,
            goal_object=goal_obj,
            goal_uv=goal_uv,
            intrinsics_w=self.intr.width,
            intrinsics_h=self.intr.height,
            next_action=action_id,
            rng=rng,
        )

        steps.append(StepRecord(
            t=t, action=action_id, pose=[*pose_xyz, 0.0, yaw, pitch],
            visible_objects=vis_objs,
            waypoint_uv=waypoint_uv,
            goal_uv=goal_uv,
            qa_pairs=qa_pairs,
        ))

    def _fill_action_chunks(self, steps: List[StepRecord], k: int, dt_s: float):
        """For each step t, compute body-frame [vx, vy, ωz] chunks over t..t+k.

        Currently writes the chunks into a sibling list (returned via the EpisodeRecord
        wrap by the caller); attached here as a `.chunk` attribute for convenience.
        """
        N = len(steps)
        for t in range(N):
            chunk = []
            for j in range(k):
                tj = t + j; tj_next = t + j + 1
                if tj_next >= N:
                    chunk.append([0.0, 0.0, 0.0])
                    continue
                p0 = steps[tj].pose; p1 = steps[tj_next].pose
                dx_w = p1[0] - p0[0]; dz_w = p1[2] - p0[2]
                yaw_rad = math.radians(p0[4])
                # body frame: forward = local +Z, right = local +X
                vx_body = (dx_w * math.sin(yaw_rad) + dz_w * math.cos(yaw_rad)) / dt_s
                vy_body = (dx_w * math.cos(yaw_rad) - dz_w * math.sin(yaw_rad)) / dt_s
                dyaw = (p1[4] - p0[4] + 540) % 360 - 180
                wz = math.radians(dyaw) / dt_s
                chunk.append([vx_body, vy_body, wz])
            steps[t].__dict__["action_chunk"] = chunk          # attach (not in dataclass)

    def _build_phase_facts(self, spans, kinds, actions, steps, goal_obj,
                           path, rng) -> List[PhaseFacts]:
        facts: List[PhaseFacts] = []
        for i, ((s, e), k) in enumerate(zip(spans, kinds)):
            is_final = (i == len(spans) - 1)
            # Salient landmarks seen during the phase (deduped by name)
            seen = {}
            for t in range(s, min(e, len(steps))):
                for o in steps[t].visible_objects:
                    ty = o.get("object_type", "")
                    if ty in ("Floor", "Wall", "Ceiling", "Window", ""): continue
                    nm = o["name"]
                    if nm not in seen: seen[nm] = o
            # Sort by depth (closest = most salient)
            seen_l = sorted(seen.values(), key=lambda o: o.get("depth_m", 1e9))
            landmarks_passed = [pick_canonical(o) for o in seen_l[:3]]

            landmark_at_turn = None
            if k in ("left", "right") and seen_l:
                landmark_at_turn = pick_canonical(seen_l[0])

            target_desc = None
            next_room = None
            if is_final:
                target_desc = pick_canonical(goal_obj)
                next_room = (goal_obj.get("roomType", "") or "").replace("_", " ").lower() or None

            facts.append(PhaseFacts(
                kind=k,
                n_steps=e - s,
                length_m=0.0,                       # could compute from poses, skipping for now
                landmarks_passed=landmarks_passed,
                landmark_at_turn=landmark_at_turn,
                is_final_phase=is_final,
                target_description=target_desc,
                next_room=next_room,
                actions=actions[s:e],
            ))
        return facts