scripts/generate_photodiode_previews.py

#!/usr/bin/env python3
"""Generate photodiode preview videos from LPBF HDF5 scan data.

This script processes photodiode point data to create animated videos
showing the laser scan progression for each layer. Each video shows
the cumulative thermal intensity as the laser scans across the build.

Output: One MP4 video per layer in previews/photodiode/
"""

import h5py
import numpy as np
from pathlib import Path
from PIL import Image
import subprocess
import tempfile
import multiprocessing as mp
from functools import partial
import os

HDF5_PATH = Path(__file__).parent.parent / "source/2024-05-01 M2 AMMTO Fatigue Blanks 05.hdf5"
PREVIEW_DIR = Path(__file__).parent.parent / "previews"

# Video settings
FPS = 30
FRAME_DURATION = 0.5  # seconds of real time per video frame
IMG_SIZE = 1024

# Multiprocessing settings
NUM_WORKERS = max(1, mp.cpu_count() - 2)  # Leave 2 cores free


def generate_layer_video_worker(layer: int) -> tuple[int, bool]:
    """Worker function to generate a video for a single layer.

    Opens its own HDF5 file handle for thread safety.

    Args:
        layer: Layer index

    Returns:
        Tuple of (layer, success)
    """
    output_path = PREVIEW_DIR / "photodiode" / f"layer_{layer:04d}.mp4"

    if output_path.exists():
        return (layer, True)

    with tempfile.TemporaryDirectory() as temp_dir:
        temp_path = Path(temp_dir)

        try:
            with h5py.File(HDF5_PATH, "r") as f:
                success = _generate_layer_video(f, layer, output_path, temp_path)
        except Exception as e:
            print(f"  Layer {layer} error: {e}")
            success = False

    return (layer, success)


def _generate_layer_video(f: h5py.File, layer: int, output_path: Path, temp_dir: Path) -> bool:
    """Generate a video for a single layer from photodiode data.

    Args:
        f: Open HDF5 file handle
        layer: Layer index
        output_path: Path for output video
        temp_dir: Temporary directory for frames

    Returns:
        True if successful, False otherwise
    """
    point_key = f'{layer} point'
    line_key = f'{layer} line'

    if point_key not in f['scans'] or line_key not in f['scans']:
        return False

    point = f[f'scans/{point_key}'][:]
    line = f[f'scans/{line_key}'][:]

    if len(point) == 0 or len(line) == 0:
        return False

    x, y, intensity = point[:, 0], point[:, 1], point[:, 2]
    time = line[:, 4]

    t_min, t_max = time.min(), time.max()
    duration = t_max - t_min

    if duration <= 0:
        return False

    # Calculate bounds for rasterization
    x_min, x_max = x.min() - 5, x.max() + 5
    y_min, y_max = y.min() - 5, y.max() + 5

    # Points per frame
    n_frames = max(1, int(duration / FRAME_DURATION))
    points_per_frame = len(point) // n_frames

    if points_per_frame == 0:
        return False

    # Generate frames
    for frame_idx in range(n_frames):
        end_idx = min((frame_idx + 1) * points_per_frame, len(point))

        # Cumulative: show all points up to this time
        frame_x = x[:end_idx]
        frame_y = y[:end_idx]
        frame_i = intensity[:end_idx]

        # Rasterize to image
        img = np.zeros((IMG_SIZE, IMG_SIZE), dtype=np.float32)
        counts = np.zeros((IMG_SIZE, IMG_SIZE), dtype=np.float32)

        # Convert coordinates to pixel indices
        px = ((frame_x - x_min) / (x_max - x_min) * (IMG_SIZE - 1)).astype(int)
        py = ((frame_y - y_min) / (y_max - y_min) * (IMG_SIZE - 1)).astype(int)

        # Clip to valid range
        valid = (px >= 0) & (px < IMG_SIZE) & (py >= 0) & (py < IMG_SIZE)
        px, py, fi = px[valid], py[valid], frame_i[valid]

        # Accumulate intensities
        np.add.at(img, (py, px), fi)
        np.add.at(counts, (py, px), 1)

        # Average where we have data
        mask = counts > 0
        img[mask] /= counts[mask]

        # Normalize to uint8
        if img.max() > 0:
            img = (img / img.max() * 255).astype(np.uint8)
        else:
            img = img.astype(np.uint8)

        Image.fromarray(img).save(temp_dir / f'frame_{frame_idx:04d}.png')

    # Create video with ffmpeg
    cmd = [
        "ffmpeg",
        "-y",
        "-framerate", str(FPS),
        "-i", str(temp_dir / "frame_%04d.png"),
        "-c:v", "libx264",
        "-preset", "medium",
        "-crf", "23",
        "-pix_fmt", "yuv420p",
        str(output_path)
    ]

    result = subprocess.run(cmd, capture_output=True, text=True)
    return result.returncode == 0


def main():
    print("=" * 60)
    print("Photodiode Preview Generator")
    print("=" * 60)

    try:
        subprocess.run(["ffmpeg", "-version"], capture_output=True, check=True)
    except (subprocess.CalledProcessError, FileNotFoundError):
        print("Error: ffmpeg not found. Install with: sudo apt install ffmpeg")
        return

    output_dir = PREVIEW_DIR / "photodiode"
    output_dir.mkdir(parents=True, exist_ok=True)

    # Get list of layers to process
    with h5py.File(HDF5_PATH, "r") as f:
        scan_keys = list(f['scans'].keys())
        layers = sorted(set(int(k.split()[0]) for k in scan_keys))

    n_layers = len(layers)
    print(f"\nFound {n_layers} layers with scan data")

    # Filter to only layers that need processing
    layers_to_process = [
        layer for layer in layers
        if not (output_dir / f"layer_{layer:04d}.mp4").exists()
    ]

    n_existing = n_layers - len(layers_to_process)
    if n_existing > 0:
        print(f"  Skipping {n_existing} existing videos")

    if not layers_to_process:
        print("  All videos already exist!")
    else:
        print(f"  Processing {len(layers_to_process)} layers with {NUM_WORKERS} workers...")

        # Process in parallel
        completed = 0
        failed = 0

        with mp.Pool(NUM_WORKERS) as pool:
            for layer, success in pool.imap_unordered(generate_layer_video_worker, layers_to_process):
                if success:
                    completed += 1
                else:
                    failed += 1

                total_done = completed + failed
                if total_done % 50 == 0 or total_done == len(layers_to_process):
                    print(f"  Progress: {total_done}/{len(layers_to_process)} "
                          f"(completed: {completed}, failed: {failed})")

        print(f"\n  Results: {completed} completed, {failed} failed")

    print("\n" + "=" * 60)
    print("Photodiode preview generation complete!")
    print("=" * 60)


if __name__ == "__main__":
    main()