| |
| """ |
| Generate MP4 and GIF preview videos from HuggingFace parquet files. |
| |
| Reads the top_down_preview and volume_preview image columns from each |
| parquet file and stitches them into MP4 and GIF videos. |
| |
| Output structure: |
| previews/<config>/<case>/top_down.mp4 |
| previews/<config>/<case>/top_down.gif |
| previews/<config>/<case>/volume.mp4 |
| previews/<config>/<case>/volume.gif |
| |
| Already-existing files are skipped automatically. |
| """ |
|
|
| import argparse |
| import io |
| import multiprocessing |
| import subprocess |
| import tempfile |
| from pathlib import Path |
|
|
| import imageio |
| import pyarrow.parquet as pq |
| from PIL import Image |
| from tqdm import tqdm |
|
|
| CONFIGS = [ |
| "temperature", |
| "fraction_of_fluid", |
| "liquid_label", |
| "melt_region", |
| "pressure", |
| "temperature_gradient", |
| "velocity_magnitude", |
| "gradient_magnitude", |
| "vx_vy_vz", |
| "dtdx_dtdy_dtdz", |
| ] |
|
|
| FPS = 20 |
| MAX_FRAMES = 200 |
|
|
|
|
| def frames_to_mp4(frames: list[bytes], mp4_path: Path, fps: int) -> None: |
| """Pipe PNG frames to ffmpeg to produce an MP4.""" |
| mp4_path.parent.mkdir(parents=True, exist_ok=True) |
|
|
| |
| img = Image.open(io.BytesIO(frames[0])) |
| w, h = img.size |
|
|
| |
| w_pad = w + (w % 2) |
| h_pad = h + (h % 2) |
|
|
| proc = subprocess.Popen( |
| [ |
| "ffmpeg", "-y", |
| "-f", "image2pipe", |
| "-framerate", str(fps), |
| "-i", "-", |
| "-vf", f"pad={w_pad}:{h_pad}", |
| "-c:v", "libx264", |
| "-pix_fmt", "yuv420p", |
| "-movflags", "faststart", |
| "-loglevel", "error", |
| str(mp4_path), |
| ], |
| stdin=subprocess.PIPE, |
| ) |
| for frame_bytes in frames: |
| proc.stdin.write(frame_bytes) |
| proc.stdin.close() |
| proc.wait() |
| if proc.returncode != 0: |
| raise RuntimeError(f"ffmpeg failed for {mp4_path}") |
|
|
|
|
| def frames_to_gif(frames: list[bytes], gif_path: Path, fps: int) -> None: |
| """Convert PNG frame bytes to an animated GIF.""" |
| gif_path.parent.mkdir(parents=True, exist_ok=True) |
| images = [imageio.v3.imread(io.BytesIO(f)) for f in frames] |
| imageio.mimsave(str(gif_path), images, fps=fps, loop=0) |
|
|
|
|
| def process_parquet(args: tuple) -> str: |
| """Process one parquet file → MP4s and GIFs (top_down + volume).""" |
| parquet_path, previews_dir, config, case_name, fps, max_frames = args |
|
|
| out_dir = previews_dir / config / case_name |
| td_mp4 = out_dir / "top_down.mp4" |
| td_gif = out_dir / "top_down.gif" |
| vol_mp4 = out_dir / "volume.mp4" |
| vol_gif = out_dir / "volume.gif" |
|
|
| |
| if td_mp4.exists() and td_gif.exists() and vol_mp4.exists() and vol_gif.exists(): |
| return case_name |
|
|
| table = pq.read_table( |
| parquet_path, |
| columns=["top_down_preview", "volume_preview"], |
| ) |
|
|
| n_rows = len(table) |
| stride = max(1, n_rows // max_frames) |
|
|
| td_frames = [] |
| vol_frames = [] |
|
|
| for i in range(0, n_rows, stride): |
| td_data = table.column("top_down_preview")[i].as_py() |
| vol_data = table.column("volume_preview")[i].as_py() |
| td_frames.append(td_data["bytes"]) |
| vol_frames.append(vol_data["bytes"]) |
|
|
| if td_frames: |
| if not td_mp4.exists(): |
| frames_to_mp4(td_frames, td_mp4, fps) |
| if not td_gif.exists(): |
| frames_to_gif(td_frames, td_gif, fps) |
|
|
| if vol_frames: |
| if not vol_mp4.exists(): |
| frames_to_mp4(vol_frames, vol_mp4, fps) |
| if not vol_gif.exists(): |
| frames_to_gif(vol_frames, vol_gif, fps) |
|
|
| return f"{config}/{case_name}" |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser( |
| description="Generate MP4 preview videos from parquet files." |
| ) |
| parser.add_argument( |
| "cases", nargs="*", |
| help="Case names (default: all cases)", |
| ) |
| parser.add_argument( |
| "--config", type=str, default=None, |
| help="Process only this config (default: all configs)", |
| ) |
| parser.add_argument("--fps", type=int, default=FPS) |
| parser.add_argument("--max-frames", type=int, default=MAX_FRAMES) |
| parser.add_argument( |
| "--workers", type=int, |
| default=max(1, multiprocessing.cpu_count() // 4), |
| help="Parallel worker processes (default: cpu_count // 4)", |
| ) |
| args = parser.parse_args() |
|
|
| root = Path(__file__).parent.parent |
| data_dir = root / "data" |
| previews_dir = root / "previews" |
|
|
| configs = [args.config] if args.config else CONFIGS |
|
|
| |
| todo = [] |
| for config in configs: |
| config_dir = data_dir / config |
| if not config_dir.exists(): |
| continue |
| parquets = sorted(config_dir.glob("*.parquet")) |
| for pq_path in parquets: |
| case_name = pq_path.stem |
| if args.cases and case_name not in args.cases: |
| continue |
| out_dir = previews_dir / config / case_name |
| td_mp4 = out_dir / "top_down.mp4" |
| td_gif = out_dir / "top_down.gif" |
| vol_mp4 = out_dir / "volume.mp4" |
| vol_gif = out_dir / "volume.gif" |
| if td_mp4.exists() and td_gif.exists() and vol_mp4.exists() and vol_gif.exists(): |
| continue |
| todo.append((pq_path, previews_dir, config, case_name, args.fps, args.max_frames)) |
|
|
| if not todo: |
| print("Nothing to do.") |
| return |
|
|
| print(f"Generating MP4/GIF previews for {len(todo)} parquet files with {args.workers} workers\n") |
|
|
| with multiprocessing.Pool(args.workers) as pool: |
| for done in tqdm( |
| pool.imap_unordered(process_parquet, todo), |
| total=len(todo), desc="Previews", |
| ): |
| pass |
|
|
| print(f"\nDone. MP4s written to {previews_dir}/") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
