scripts/previews/02_timelapse.py

#!/usr/bin/env python3
"""Render per-layer timelapse GIFs for each build.

Reads data/ticks/{build_id:03d}.parquet and writes:
  previews/{build_id:03d}/timelapse_chamber.gif
  previews/{build_id:03d}/timelapse_thermal.gif
  previews/{build_id:03d}/timelapse_galvo.gif
  previews/{build_id:03d}/timelapse_composite.gif  (1×3 panel: chamber | thermal | galvo)

Layer detection: positions.position.z2 is quantized in 100 µm buckets.
Only z2 > 0 rows are used — z2 stays at 0 during pre-print heating so this
naturally excludes the heating phase without needing to inspect the phase column.
The *last* non-null frame within each z2 bucket is the representative — that's
the most-recent view of the layer just before recoating begins.

Null-frame levels are forward-filled from the most recent non-null level of the
same kind, so the GIF never shows a blank panel mid-timelapse.

The thermal panel is rendered from the raw `bedmatrix` IR grid (inferno colormap
over a fixed absolute °C range; see _thermal.py) whenever it's present — builds
013+. The three earliest builds (001/002/012) predate the bedmatrix stream and
fall back to the legacy pre-rendered `frame_thermal` GIF.

Subsampled to at most MAX_FRAMES (default 300). At GIF_FPS=25 that gives
a max 12-second GIF. Builds with fewer detected layers are not padded.

Canvas is scaled to GIF_PANEL_HEIGHT=240 px (half the MP4 panel height) to
keep file sizes web-friendly for README embedding.

Usage:
    uv run scripts/previews/02_timelapse.py            # all builds in data/ticks/
    uv run scripts/previews/02_timelapse.py 26 28      # specific build ids
    uv run scripts/previews/02_timelapse.py 26 --kinds chamber,composite
"""
import io
import sys
from pathlib import Path

import pyarrow.parquet as pq
from PIL import Image, ImageStat

sys.path.insert(0, str(Path(__file__).parent.parent))
sys.path.insert(0, str(Path(__file__).parent))
from _lib import DATA_DIR
from _thermal import bedmatrix_to_image

OUTPUT_DIR = DATA_DIR.parent / "previews"
TICKS_DIR  = DATA_DIR / "ticks"

FRAME_KINDS        = ("chamber", "thermal", "galvo")
KIND_ROTATION_CW   = {"chamber": 90}  # degrees; see _decode_raw
# The thermal panel renders from the raw `bedmatrix` IR grid when present
# (builds 013+), falling back to the legacy `frame_thermal` GIF for the three
# earliest builds (001/002/012) that predate the bedmatrix stream.

GIF_FPS            = 25
GIF_DURATION_MS    = int(1000 / GIF_FPS)   # 40 ms per frame
MAX_FRAMES         = 300                    # subsample cap → max 12 s GIF
LAYER_QUANTIZE_UM  = 100                    # z2 bucket size in microns
GIF_PANEL_HEIGHT   = 240                    # panel height in pixels for GIF canvas
BATCH_ROWS         = 1000                   # pyarrow streaming batch size

# Halogen brightness filter — applies to chamber frames only.
# The halogens pulse on/off throughout a build; dark frames (halogens off) are
# uninformative for viewing. A frame is kept if its mean grayscale brightness is
# at least this fraction of the brightest frame seen in the same build.
# For the individual chamber GIF dark frames are dropped entirely; for the
# composite they are forward-filled from the last bright frame so thermal/galvo
# stay in layer-sync.
CHAMBER_BRIGHTNESS_RATIO = 0.5


# ---------------------------------------------------------------------------
# Image helpers (mirrors 01_render.py exactly)
# ---------------------------------------------------------------------------

def _decode_raw(b: bytes, kind: str) -> Image.Image | None:
    """Decode raw image bytes to PIL RGB with orientation correction."""
    if not b:
        return None
    try:
        img = Image.open(io.BytesIO(b)).convert("RGB")
    except Exception:
        return None
    rot = KIND_ROTATION_CW.get(kind, 0)
    if rot == 90:
        img = img.transpose(Image.Transpose.ROTATE_270)
    elif rot == 180:
        img = img.transpose(Image.Transpose.ROTATE_180)
    elif rot == 270:
        img = img.transpose(Image.Transpose.ROTATE_90)
    return img


def _decode_cell(cell, kind: str) -> Image.Image | None:
    """Decode one struct cell to a PIL RGB image, dispatching on struct shape:
    a `bedmatrix` struct (has 'values') renders as an inferno heatmap; a frame
    Image struct (has 'bytes') decodes + orientation-corrects. None when missing."""
    if cell is None:
        return None
    if "values" in cell:
        return bedmatrix_to_image(cell)
    return _decode_raw(cell.get("bytes"), kind)


def _thermal_column(parquet_path: Path) -> str:
    """Which column feeds the thermal panel for this build: 'bedmatrix' when the
    raw IR matrix has any non-null cell, else the legacy 'frame_thermal'. The
    bedmatrix stream started at build 013, so 001/002/012 fall back to the GIF."""
    pf = pq.ParquetFile(parquet_path)
    if "bedmatrix" not in {f.name for f in pf.schema_arrow}:
        return "frame_thermal"
    for batch in pf.iter_batches(columns=["bedmatrix"], batch_size=BATCH_ROWS):
        for cell in batch.column("bedmatrix").to_pylist():
            if cell is not None:
                return "bedmatrix"
    return "frame_thermal"


def _columns_for_build(parquet_path: Path) -> dict[str, str]:
    """Map each panel kind → the parquet column that feeds it for this build."""
    return {
        "chamber": "frame_chamber",
        "thermal": _thermal_column(parquet_path),
        "galvo":   "frame_galvo",
    }


def _canvas_width(cell, kind: str) -> int:
    """Decode one cell to determine the locked canvas width for this kind."""
    img = _decode_cell(cell, kind)
    if img is None:
        return GIF_PANEL_HEIGHT  # square fallback
    sw, sh = img.size
    return max(2, round(sw * GIF_PANEL_HEIGHT / sh))


def _fit_to_canvas(img: Image.Image, canvas_w: int) -> Image.Image:
    """Letterbox img into (canvas_w × GIF_PANEL_HEIGHT) with dark-gray fill."""
    sw, sh = img.size
    scale  = min(canvas_w / sw, GIF_PANEL_HEIGHT / sh)
    nw     = max(1, round(sw * scale))
    nh     = max(1, round(sh * scale))
    fitted = img.resize((nw, nh), Image.BILINEAR)
    canvas = Image.new("RGB", (canvas_w, GIF_PANEL_HEIGHT), (20, 20, 20))
    canvas.paste(fitted, ((canvas_w - nw) // 2, (GIF_PANEL_HEIGHT - nh) // 2))
    return canvas


def _placeholder(canvas_w: int) -> Image.Image:
    return Image.new("RGB", (canvas_w, GIF_PANEL_HEIGHT), (20, 20, 20))


def _mean_brightness(img: Image.Image) -> float:
    """Mean grayscale pixel value 0–255 (uses PIL ImageStat, no numpy)."""
    return ImageStat.Stat(img.convert("L")).mean[0]


def _chamber_threshold(decoded_frames: list[Image.Image | None]) -> float:
    """Return the brightness threshold for a build's chamber frames.
    25 % of the brightest frame seen; 0 if no frames (no filtering applied)."""
    brightnesses = [_mean_brightness(f) for f in decoded_frames if f is not None]
    return max(brightnesses) * CHAMBER_BRIGHTNESS_RATIO if brightnesses else 0.0


# ---------------------------------------------------------------------------
# Layer data collection
# ---------------------------------------------------------------------------

def collect_layer_cells(parquet_path: Path, kind: str, col: str) -> dict[int, dict]:
    """Single-pass stream → {z2_level: last_non_null_struct}.

    Only z2 > 0 rows are included. The dict is keyed by int(z2 / LAYER_QUANTIZE_UM);
    each entry holds the *last* non-null struct cell seen at that level (a frame
    Image struct, or a bedmatrix struct for the thermal panel). Reads only two
    parquet columns (z2 + the source column) for efficiency.
    """
    z2_col  = "positions.position.z2"
    pf      = pq.ParquetFile(parquet_path)
    present = {f.name for f in pf.schema_arrow}
    if col not in present or z2_col not in present:
        return {}

    layer_data: dict[int, dict] = {}
    for batch in pf.iter_batches(columns=[z2_col, col], batch_size=BATCH_ROWS):
        z2_list   = batch.column(z2_col).to_pylist()
        cell_list = batch.column(col).to_pylist()
        for z2, cell in zip(z2_list, cell_list):
            if z2 is None or z2 <= 0:
                continue
            if cell is not None:
                layer_data[int(z2 / LAYER_QUANTIZE_UM)] = cell
    return layer_data


def collect_all_kinds(parquet_path: Path, cols_map: dict[str, str]) -> dict[str, dict[int, dict]]:
    """Single streaming pass collecting all three kinds simultaneously.

    Used by render_timelapse_composite so we don't make three separate passes
    through (potentially 17+ GB) parquet files. Reads four columns: z2 + each
    kind's source column. Each kind gets its own {z2_level: struct} dict.
    """
    z2_col    = "positions.position.z2"
    pf        = pq.ParquetFile(parquet_path)
    present   = {f.name for f in pf.schema_arrow}
    read_cols = [c for c in ([z2_col] + [cols_map[k] for k in FRAME_KINDS]) if c in present]
    if z2_col not in read_cols:
        return {k: {} for k in FRAME_KINDS}

    layer_data: dict[str, dict[int, dict]] = {k: {} for k in FRAME_KINDS}
    for batch in pf.iter_batches(columns=read_cols, batch_size=BATCH_ROWS):
        z2_list = batch.column(z2_col).to_pylist()
        for kind in FRAME_KINDS:
            col = cols_map[kind]
            if col not in read_cols:
                continue
            cell_list = batch.column(col).to_pylist()
            for z2, cell in zip(z2_list, cell_list):
                if z2 is None or z2 <= 0:
                    continue
                if cell is not None:
                    layer_data[kind][int(z2 / LAYER_QUANTIZE_UM)] = cell
    return layer_data


# ---------------------------------------------------------------------------
# Subsampling and forward-fill
# ---------------------------------------------------------------------------

def _subsample(levels: list[int]) -> list[int]:
    """Evenly subsample sorted levels down to at most MAX_FRAMES."""
    if len(levels) <= MAX_FRAMES:
        return levels
    step = len(levels) / MAX_FRAMES
    return [levels[round(i * step)] for i in range(MAX_FRAMES)]


def _forward_fill(layer_bytes: dict[int, bytes],
                  target_levels: list[int]) -> list[bytes | None]:
    """For each target level, return the bytes at that level or the most
    recent non-null bytes seen so far (forward-fill across gaps)."""
    out: list[bytes | None] = []
    last: bytes | None = None
    for lvl in target_levels:
        b = layer_bytes.get(lvl)
        if b is not None:
            last = b
        out.append(last)
    return out


# ---------------------------------------------------------------------------
# GIF writer
# ---------------------------------------------------------------------------

def _write_gif(frames: list[Image.Image], out_path: Path) -> None:
    """Palette-quantize and save frames as an animated GIF."""
    out_path.parent.mkdir(parents=True, exist_ok=True)
    palette_frames = [
        f.quantize(colors=256, method=Image.Quantize.MEDIANCUT,
                   dither=Image.Dither.FLOYDSTEINBERG)
        for f in frames
    ]
    palette_frames[0].save(
        out_path,
        format="GIF",
        save_all=True,
        append_images=palette_frames[1:],
        loop=0,
        duration=GIF_DURATION_MS,
        optimize=False,
    )


# ---------------------------------------------------------------------------
# Per-build renderers
# ---------------------------------------------------------------------------

def render_timelapse_kind(parquet_path: Path, kind: str, out_path: Path, col: str) -> int:
    """Write timelapse_{kind}.gif. Returns number of GIF frames written.

    Chamber only: dark frames (halogens off) are dropped entirely so the GIF
    shows only moments where the part is visible. Thermal and galvo are
    unaffected — they don't depend on halogen lighting.
    """
    layer_cells = collect_layer_cells(parquet_path, kind, col)
    if not layer_cells:
        print(f"  {kind:8s}: no printing-phase frames (z2 > 0), skipping")
        return 0

    sorted_levels = sorted(layer_cells)
    target_levels = _subsample(sorted_levels)
    fill_cells    = _forward_fill(layer_cells, target_levels)
    canvas_w      = _canvas_width(next(c for c in fill_cells if c), kind)

    # Decode all selected frames up front (needed for brightness scan on chamber).
    decoded = [_decode_cell(c, kind) for c in fill_cells]

    if kind == "chamber":
        # Compute brightness once per decoded frame, then threshold and filter.
        brightnesses = [_mean_brightness(img) if img is not None else None
                        for img in decoded]
        threshold = _chamber_threshold(decoded)
        pil_frames = [
            _fit_to_canvas(img, canvas_w)
            for img, b in zip(decoded, brightnesses)
            if img is not None and b is not None and b >= threshold
        ]
        dark_dropped = sum(
            1 for img, b in zip(decoded, brightnesses)
            if img is not None and b is not None and b < threshold
        )
        if dark_dropped:
            print(f"  {kind:8s}: dropped {dark_dropped} dark frames "
                  f"(threshold {threshold:.1f}/255)")
    else:
        pil_frames = [
            _fit_to_canvas(img, canvas_w) if img else _placeholder(canvas_w)
            for img in decoded
        ]

    if not pil_frames:
        print(f"  {kind:8s}: no frames survived brightness filter, skipping")
        return 0

    _write_gif(pil_frames, out_path)
    return len(pil_frames)


def render_timelapse_composite(parquet_path: Path, out_path: Path,
                               cols_map: dict[str, str]) -> int:
    """Write timelapse_composite.gif (1×3 panel). Single parquet pass.

    Thermal and galvo show the actual frame for every layer (unaffected by
    halogens). The chamber panel forward-fills from the last *bright* frame
    when the current layer's chamber frame is dark — this keeps all three
    panels in layer-sync while never displaying a dark chamber view.
    """
    all_cells = collect_all_kinds(parquet_path, cols_map)

    all_levels = sorted(set().union(*(set(d) for d in all_cells.values())))
    if not all_levels:
        print("  composite: no printing-phase frames (z2 > 0), skipping")
        return 0

    target_levels = _subsample(all_levels)
    fill_per_kind = {k: _forward_fill(all_cells[k], target_levels) for k in FRAME_KINDS}

    canvas_widths: dict[str, int] = {}
    for kind in FRAME_KINDS:
        first_c = next((c for c in fill_per_kind[kind] if c), None)
        canvas_widths[kind] = (
            _canvas_width(first_c, kind) if first_c else GIF_PANEL_HEIGHT
        )
    total_w = sum(canvas_widths.values())

    # Pre-decode chamber frames once; compute adaptive brightness threshold.
    chamber_decoded = [
        _decode_cell(c, "chamber") for c in fill_per_kind["chamber"]
    ]
    chamber_threshold = _chamber_threshold(chamber_decoded)

    last_bright_chamber: Image.Image | None = None
    pil_frames: list[Image.Image] = []
    for i in range(len(target_levels)):
        composite = Image.new("RGB", (total_w, GIF_PANEL_HEIGHT), (20, 20, 20))
        x = 0
        for kind in FRAME_KINDS:
            if kind == "chamber":
                img = chamber_decoded[i]
                # Update the running bright-chamber reference when this frame is bright.
                if img is not None and _mean_brightness(img) >= chamber_threshold:
                    last_bright_chamber = img
                # Always use the last bright frame (forward-fill); placeholder until
                # the first bright frame arrives.
                panel_img = last_bright_chamber
            else:
                panel_img = _decode_cell(fill_per_kind[kind][i], kind)

            panel = (
                _fit_to_canvas(panel_img, canvas_widths[kind])
                if panel_img else _placeholder(canvas_widths[kind])
            )
            composite.paste(panel, (x, 0))
            x += canvas_widths[kind]
        pil_frames.append(composite)

    _write_gif(pil_frames, out_path)
    return len(pil_frames)


def process_build(build_id: int, kinds: set[str]) -> None:
    parquet_path = TICKS_DIR / f"{build_id:03d}.parquet"
    if not parquet_path.exists():
        print(f"build {build_id:03d}: no parquet, skipping")
        return

    build_dir = OUTPUT_DIR / f"{build_id:03d}"
    print(f"build {build_id:03d}: timelapse GIFs → {build_dir.relative_to(Path.cwd())}/")
    cols_map = _columns_for_build(parquet_path)
    if ("thermal" in kinds or "composite" in kinds):
        print(f"  thermal source: {cols_map['thermal']}")

    for kind in FRAME_KINDS:
        if kind not in kinds:
            continue
        out = build_dir / f"timelapse_{kind}.gif"
        n = render_timelapse_kind(parquet_path, kind, out, cols_map[kind])
        if out.exists():
            size = out.stat().st_size
            print(f"  {kind:8s}: {n:>4} frames → {out.name}  ({size:,} bytes)")

    if "composite" in kinds:
        out = build_dir / "timelapse_composite.gif"
        n = render_timelapse_composite(parquet_path, out, cols_map)
        if out.exists():
            size = out.stat().st_size
            print(f"  composite: {n:>4} frames → {out.name}  ({size:,} bytes)")


def main():
    import argparse
    parser = argparse.ArgumentParser(
        description=__doc__,
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument("build_ids", nargs="*", type=int,
                        help="Build IDs to render (default: all in data/ticks/)")
    parser.add_argument(
        "--kinds", default="chamber,thermal,galvo,composite",
        help="Comma-separated outputs to render. "
             "Valid: chamber, thermal, galvo, composite. Default: all four.",
    )
    args   = parser.parse_args()
    kinds  = set(args.kinds.split(","))
    unknown = kinds - (set(FRAME_KINDS) | {"composite"})
    if unknown:
        parser.error(f"unknown --kinds values: {sorted(unknown)}")

    targets = args.build_ids or sorted(int(p.stem) for p in TICKS_DIR.glob("*.parquet"))
    for bid in targets:
        process_build(bid, kinds)


if __name__ == "__main__":
    main()