core/inputs.py

"""User input loader.

Expected directory layout under ``--input-dir``:

    inputs/case_xxx/
      first_frame.png              (H, W, 3) uint8
      prompt.txt                   text prompt (scene description)
      geometry.npz                 keys: poses_c2w (N, 4, 4), K (3, 3),
                                         intrinsics_size (2,)  optional
      pointcloud.npz               keys: points (M, 3) float32
      fg_mask_first.png            optional, single-channel; >0 = foreground
      bg_projection.mp4            required when condition_source="mp4"
      fg_projection.mp4            optional FG conditioning video

For the CSV / four-field path (``load_user_inputs_from_paths``), only
``input_image``, ``text``, ``bg_projection``, ``fg_projection`` are required;
dummy identity poses + a tiny point cloud are synthesized so the existing
``condition_source="mp4"`` pipeline path still works (geometry is unused for
scene rendering in that mode).

All geometry must be in the same world coordinate system; intrinsics ``K`` is
defined at ``intrinsics_size`` (defaults to first_frame resolution).
"""
from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
from typing import Optional, Tuple, Union

import cv2
import numpy as np
from PIL import Image


@dataclass
class UserInputs:
    first_frame: np.ndarray            # (H, W, 3) uint8 at target_hw
    first_frame_pil: Image.Image       # PIL image at target_hw
    prompt: str
    poses_c2w: np.ndarray              # (N, 4, 4) float32
    K: np.ndarray                      # (3, 3) float32 at intrinsics_size
    intrinsics_size: Tuple[int, int]   # (H, W) of K's reference resolution
    points_world: np.ndarray           # (M, 3) float32
    fg_mask: Optional[np.ndarray]      # (H, W) bool at target_hw, or None
    # Precomputed projection videos (condition_source="mp4"). Each is
    # (T, H, W, 3) uint8 at target_hw, or None if the file was absent.
    scene_proj_frames: Optional[np.ndarray] = None   # from bg_projection.mp4
    fg_proj_frames: Optional[np.ndarray] = None       # from fg_projection.mp4


def _load_image_rgb(path: Path) -> np.ndarray:
    img_bgr = cv2.imread(str(path), cv2.IMREAD_COLOR)
    if img_bgr is None:
        raise FileNotFoundError(f"Cannot read image: {path}")
    return cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)


def _maybe_resize_image(img: np.ndarray, target_hw: Tuple[int, int]) -> np.ndarray:
    H, W = target_hw
    if img.shape[:2] == (H, W):
        return img
    return cv2.resize(img, (W, H), interpolation=cv2.INTER_LINEAR)


def _maybe_resize_mask(mask: np.ndarray, target_hw: Tuple[int, int]) -> np.ndarray:
    H, W = target_hw
    if mask.shape[:2] == (H, W):
        return mask
    return cv2.resize(mask.astype(np.uint8), (W, H),
                      interpolation=cv2.INTER_NEAREST).astype(bool)


def _scale_intrinsics(K: np.ndarray,
                      src_hw: Tuple[int, int],
                      dst_hw: Tuple[int, int]) -> np.ndarray:
    if src_hw == dst_hw:
        return K.astype(np.float32)
    sh, sw = src_hw
    dh, dw = dst_hw
    K_new = K.copy().astype(np.float32)
    K_new[0, 0] *= dw / sw
    K_new[1, 1] *= dh / sh
    K_new[0, 2] *= dw / sw
    K_new[1, 2] *= dh / sh
    return K_new


def make_dummy_geometry(n_poses: int,
                        target_hw: Tuple[int, int]
                        ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
    """Synthesize identity poses + a pinhole K + a tiny point cloud.

    Used by the CSV / four-field path when ``condition_source="mp4"``: scene
    and FG come from precomputed videos, so real geometry is unused for
    rendering. The loader / pipeline still expect these arrays to exist
    (anchors + optional multi-iter IoU), so we fill safe placeholders.
    """
    if n_poses < 1:
        raise ValueError(f"n_poses must be >= 1, got {n_poses}")
    H, W = int(target_hw[0]), int(target_hw[1])
    poses = np.eye(4, dtype=np.float32)[None].repeat(n_poses, axis=0)
    # Mild wide-ish pinhole covering the frame; unused under mp4 conditioning.
    fx = fy = float(max(H, W))
    K = np.array([[fx, 0.0, W / 2.0],
                  [0.0, fy, H / 2.0],
                  [0.0, 0.0, 1.0]], dtype=np.float32)
    # One point in front of the camera so IoU / coloring never hit empty arrays.
    points = np.array([[0.0, 0.0, 2.0]], dtype=np.float32)
    return poses, K, points


def _resolve_prompt(text: str) -> str:
    """Accept either an inline prompt string or a path to a ``.txt`` file."""
    raw = str(text).strip()
    if not raw:
        raise ValueError("empty text / prompt")
    p = Path(raw)
    if p.is_file() and p.suffix.lower() in {".txt", ".prompt"}:
        raw = p.read_text(encoding="utf-8").strip()
        if not raw:
            raise ValueError(f"Empty prompt file: {p}")
    return raw


def load_user_inputs_from_paths(
        input_image: Union[str, Path],
        text: str,
        bg_projection: Union[str, Path],
        fg_projection: Optional[Union[str, Path]] = None,
        target_hw: Tuple[int, int] = (480, 832),
        n_poses: Optional[int] = None,
) -> UserInputs:
    """Load the four-field CSV-style inputs directly (no case folder needed).

    Parameters
    ----------
    input_image:
        Path to the first-frame RGB image.
    text:
        Inline prompt, or a path to a ``.txt`` prompt file.
    bg_projection:
        Path to ``bg_projection.mp4`` (static / scene conditioning).
    fg_projection:
        Optional path to ``fg_projection.mp4``. Pass ``None`` / empty to skip.
    target_hw:
        Inference resolution ``(H, W)``.
    n_poses:
        Length of the dummy pose trajectory. Defaults to
        ``len(bg_frames)`` so indexing never overflows the video length.
    """
    from .precomputed import read_video_frames

    img_path = Path(input_image)
    bg_path = Path(bg_projection)
    if not img_path.exists():
        raise FileNotFoundError(f"input_image missing: {img_path}")
    if not bg_path.exists():
        raise FileNotFoundError(f"bg_projection missing: {bg_path}")

    prompt = _resolve_prompt(text)

    first_frame_raw = _load_image_rgb(img_path)
    first_frame = _maybe_resize_image(first_frame_raw, target_hw)
    first_frame_pil = Image.fromarray(first_frame)

    scene_proj_frames = read_video_frames(bg_path, target_hw)
    fg_proj_frames: Optional[np.ndarray] = None
    if fg_projection:
        fg_path = Path(fg_projection)
        if str(fg_path).strip() and fg_path.exists():
            fg_proj_frames = read_video_frames(fg_path, target_hw)
        elif str(fg_path).strip():
            raise FileNotFoundError(f"fg_projection missing: {fg_path}")

    n = int(n_poses) if n_poses is not None else max(1, len(scene_proj_frames))
    poses_c2w, K, points_world = make_dummy_geometry(n, target_hw)

    return UserInputs(
        first_frame=first_frame,
        first_frame_pil=first_frame_pil,
        prompt=prompt,
        poses_c2w=poses_c2w,
        K=K,
        intrinsics_size=tuple(target_hw),
        points_world=points_world,
        fg_mask=None,
        scene_proj_frames=scene_proj_frames,
        fg_proj_frames=fg_proj_frames,
    )


def load_user_inputs(input_dir: str | Path,
                     target_hw: Tuple[int, int],
                     *,
                     allow_dummy_geometry: bool = False) -> UserInputs:
    """Load all user-provided inputs and align them to target resolution.

    target_hw is the (H, W) at which inference runs (typically 480x832 for the
    14B LiveWorld checkpoint). First frame and fg_mask are resized to this.
    Intrinsics K is rescaled from its source resolution to target_hw and stored
    at target_hw (so intrinsics_size in the returned object == target_hw).

    If ``allow_dummy_geometry=True`` and ``geometry.npz`` / ``pointcloud.npz``
    are missing but ``bg_projection.mp4`` is present, identity poses + a tiny
    PC are synthesized (for ``condition_source="mp4"`` only).
    """
    root = Path(input_dir)
    if not root.is_dir():
        raise FileNotFoundError(f"input-dir not found: {root}")

    first_frame_path = root / "first_frame.png"
    prompt_path = root / "prompt.txt"
    geometry_path = root / "geometry.npz"
    pointcloud_path = root / "pointcloud.npz"
    fg_mask_path = root / "fg_mask_first.png"
    bg_video_path = root / "bg_projection.mp4"
    fg_video_path = root / "fg_projection.mp4"

    for p in (first_frame_path, prompt_path):
        if not p.exists():
            raise FileNotFoundError(f"Required input missing: {p}")

    missing_geom = (not geometry_path.exists()) or (not pointcloud_path.exists())
    if missing_geom and not (allow_dummy_geometry and bg_video_path.exists()):
        for p in (geometry_path, pointcloud_path):
            if not p.exists():
                raise FileNotFoundError(f"Required input missing: {p}")

    first_frame_raw = _load_image_rgb(first_frame_path)
    src_hw = first_frame_raw.shape[:2]
    first_frame = _maybe_resize_image(first_frame_raw, target_hw)
    first_frame_pil = Image.fromarray(first_frame)

    prompt = prompt_path.read_text(encoding="utf-8").strip()
    if not prompt:
        raise ValueError(f"Empty prompt: {prompt_path}")

    # Precomputed projection videos (optional; required when
    # condition_source="mp4"). Loaded early so dummy-geometry length can match.
    scene_proj_frames: Optional[np.ndarray] = None
    fg_proj_frames: Optional[np.ndarray] = None
    if bg_video_path.exists() or fg_video_path.exists():
        from .precomputed import read_video_frames
        if bg_video_path.exists():
            scene_proj_frames = read_video_frames(bg_video_path, target_hw)
        if fg_video_path.exists():
            fg_proj_frames = read_video_frames(fg_video_path, target_hw)

    if missing_geom:
        n = max(1, len(scene_proj_frames) if scene_proj_frames is not None else 1)
        poses_c2w, K, points_world = make_dummy_geometry(n, target_hw)
        print(f"[input] dummy geometry: poses={poses_c2w.shape}, "
              f"points={points_world.shape} (mp4-only path)")
    else:
        geom = np.load(geometry_path)
        if "poses_c2w" in geom.files:
            poses_c2w = geom["poses_c2w"].astype(np.float32)
        elif "poses" in geom.files:
            poses_c2w = geom["poses"].astype(np.float32)
        elif "c2w" in geom.files:
            poses_c2w = geom["c2w"].astype(np.float32)
        else:
            raise KeyError(f"No poses_c2w/poses/c2w in {geometry_path}")

        if "K" in geom.files:
            K_raw = geom["K"].astype(np.float32)
        elif "intrinsics" in geom.files:
            K_raw = geom["intrinsics"].astype(np.float32)
        else:
            raise KeyError(f"No K/intrinsics in {geometry_path}")
        if K_raw.shape != (3, 3):
            raise ValueError(f"K must be (3, 3), got {K_raw.shape}")

        if "intrinsics_size" in geom.files:
            intr_src_hw = tuple(int(v) for v in geom["intrinsics_size"].tolist())
            if len(intr_src_hw) != 2:
                raise ValueError(f"intrinsics_size must be (H, W), got {intr_src_hw}")
        else:
            intr_src_hw = src_hw  # assume K is at first_frame's source resolution

        K = _scale_intrinsics(K_raw, intr_src_hw, target_hw)

        pc = np.load(pointcloud_path)
        if "points" not in pc.files:
            raise KeyError(f"No 'points' in {pointcloud_path}")
        points_world = pc["points"].astype(np.float32)
        if points_world.ndim != 2 or points_world.shape[1] != 3:
            raise ValueError(f"points must be (M, 3), got {points_world.shape}")

    fg_mask: Optional[np.ndarray] = None
    if fg_mask_path.exists():
        m_raw = cv2.imread(str(fg_mask_path), cv2.IMREAD_GRAYSCALE)
        if m_raw is None:
            raise RuntimeError(f"Failed to read fg_mask: {fg_mask_path}")
        fg_mask = _maybe_resize_mask(m_raw > 0, target_hw)

    return UserInputs(
        first_frame=first_frame,
        first_frame_pil=first_frame_pil,
        prompt=prompt,
        poses_c2w=poses_c2w,
        K=K,
        intrinsics_size=tuple(target_hw),
        points_world=points_world,
        fg_mask=fg_mask,
        scene_proj_frames=scene_proj_frames,
        fg_proj_frames=fg_proj_frames,
    )