code/scripts/make_correction_animation.py

#!/usr/bin/env python
"""Renders an animated GIF of a LiDAR projection smoothly correcting from a
miscalibrated stage back to ground truth (SE(3) interpolation between the two
extrinsics), for a README/webpage hero visual.

Usage:
    python scripts/make_correction_animation.py \\
        --metadata-parquet data/train.parquet --assets-parquet assets_scratch/shards/data/frames_train-00000-of-00044.parquet \\
        --sequence 00 --frame 120 --stage 1 --output docs/assets/correction_animation.gif
"""

from __future__ import annotations

import argparse
import io
import sys
from pathlib import Path

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
import pyarrow.parquet as pq
from PIL import Image
from scipy.spatial.transform import Rotation, Slerp

sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))

from kitti_c2l.geometry import project_to_image, transform_points  # noqa: E402
from kitti_c2l.loader.dataset import (  # noqa: E402
    decode_image_png,
    decode_points_bin,
    row_extrinsic,
)

MIN_DEPTH_CM = 200.0
MAX_DEPTH_CM = 8000.0


def _interpolate_transforms(r_start: np.ndarray, t_start: np.ndarray, r_end: np.ndarray, t_end: np.ndarray, num_steps: int):
    key_rots = Rotation.from_matrix(np.stack([r_start, r_end]))
    slerp = Slerp([0.0, 1.0], key_rots)
    fractions = np.linspace(0.0, 1.0, num_steps)
    rotations = slerp(fractions).as_matrix()
    translations = t_start[None, :] + fractions[:, None] * (t_end - t_start)[None, :]
    return rotations, translations, fractions


def _render_frame(
    image: np.ndarray, points_cm: np.ndarray, rotation: np.ndarray, translation: np.ndarray, intrinsics: np.ndarray,
    title: str, max_points: int = 18000, rng: np.random.Generator | None = None,
) -> np.ndarray:
    height, width = image.shape[:2]
    points_cam = transform_points(points_cm, rotation, translation)
    pixels = project_to_image(points_cam, intrinsics)
    depths = points_cam[:, 2]

    valid = (
        (depths > MIN_DEPTH_CM) & (depths < MAX_DEPTH_CM)
        & (pixels[:, 0] >= 0) & (pixels[:, 0] < width)
        & (pixels[:, 1] >= 0) & (pixels[:, 1] < height)
    )
    pixels, depths = pixels[valid], depths[valid]
    if pixels.shape[0] > max_points:
        rng = rng or np.random.default_rng(0)
        keep = rng.choice(pixels.shape[0], size=max_points, replace=False)
        pixels, depths = pixels[keep], depths[keep]

    # Render at half native resolution: smaller file, and softens the raw
    # 64-beam scan-line banding that's distractingly sharp at full res.
    scale = 0.5
    fig, ax = plt.subplots(figsize=(width * scale / 100, height * scale / 100 + 0.45), dpi=100)
    fig.subplots_adjust(top=0.88, bottom=0.0, left=0.0, right=1.0)
    ax.imshow(image)
    if pixels.shape[0] > 0:
        order = np.argsort(-depths)
        ax.scatter(pixels[order, 0], pixels[order, 1], c=depths[order] / 100.0, cmap="turbo", s=10, alpha=0.5, linewidths=0, vmin=2, vmax=80)
    ax.set_title(title, fontsize=10, fontweight="bold", color="#212121")
    ax.axis("off")
    ax.set_xlim(0, width)
    ax.set_ylim(height, 0)

    buf = io.BytesIO()
    fig.savefig(buf, format="png")
    plt.close(fig)
    buf.seek(0)
    return np.array(Image.open(buf).convert("RGB"))


def make_animation(
    metadata_parquet: Path,
    assets_parquet: Path,
    sequence: str,
    frame: int,
    stage: int,
    output_path: Path,
    num_steps: int = 36,
    hold_frames: int = 8,
    fps: int = 20,
) -> Path:
    meta_rows = pq.read_table(metadata_parquet).to_pylist()
    row = next(r for r in meta_rows if r["sequence"] == sequence and r["frame_index"] == frame and r["stage"] == stage)

    asset_rows = pq.read_table(assets_parquet).to_pylist()
    frame_id = f"{sequence}_{frame:06d}"
    asset_row = next(r for r in asset_rows if r["frame_id"] == frame_id)

    image = decode_image_png(asset_row["image_png"])
    points_cm = decode_points_bin(asset_row["points_bin"])
    intrinsics = np.array(row["camera_intrinsics"], dtype=np.float64).reshape(3, 3)

    r_gt, t_gt = row_extrinsic(row, use_ground_truth=True)
    r_miscal, t_miscal = row_extrinsic(row, use_ground_truth=False)

    rotations, translations, fractions = _interpolate_transforms(r_miscal, t_miscal, r_gt, t_gt, num_steps)

    frames = []
    for i, (rotation, translation, frac) in enumerate(zip(rotations, translations, fractions, strict=True)):
        progress_pct = int(round(frac * 100))
        title = f"seq {sequence} frame {frame}  |  correcting stage {stage} miscalibration  ({progress_pct}%)"
        frames.append(_render_frame(image, points_cm, rotation, translation, intrinsics, title))
        print(f"  rendered {i + 1}/{num_steps}")

    pil_frames = [Image.fromarray(f) for f in frames]
    pil_frames = [pil_frames[0]] * hold_frames + pil_frames + [pil_frames[-1]] * hold_frames

    # Shared adaptive palette across all frames: much smaller file than per-frame
    # palettes, and avoids color flicker between frames.
    palette_source = pil_frames[len(pil_frames) // 2].quantize(colors=192, method=Image.MEDIANCUT)
    pil_frames = [f.quantize(palette=palette_source, dither=Image.FLOYDSTEINBERG) for f in pil_frames]

    output_path.parent.mkdir(parents=True, exist_ok=True)
    pil_frames[0].save(
        output_path, save_all=True, append_images=pil_frames[1:], duration=int(1000 / fps), loop=0, optimize=True
    )
    return output_path


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--metadata-parquet", required=True)
    parser.add_argument("--assets-parquet", required=True)
    parser.add_argument("--sequence", required=True)
    parser.add_argument("--frame", type=int, required=True)
    parser.add_argument("--stage", type=int, default=1)
    parser.add_argument("--output", default="docs/assets/correction_animation.gif")
    parser.add_argument("--num-steps", type=int, default=36)
    parser.add_argument("--fps", type=int, default=20)
    args = parser.parse_args()

    output_path = make_animation(
        Path(args.metadata_parquet), Path(args.assets_parquet), args.sequence, args.frame, args.stage,
        Path(args.output), num_steps=args.num_steps, fps=args.fps,
    )
    print(f"wrote {output_path}")
    return 0


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