"""Convert an unzipped Cafca dataset chunk into three WebDataset tiers: 1. view tier key = SUBJECT/EXPR_ENV/CAM -> rgb.png, mask.png, seg.png, cam.json, landmark.npz, env.json 2. scene-mesh tier key = SUBJECT/EXPR_ENV -> mesh.obj, mesh.mtl, mesh.jpg 3. flame-params tier key = SUBJECT/ENV -> flame.npz Deliberately excluded (see plan): segmentation_rgb, eval_100/image_grid/*, *.log fitting logs. Usage: python convert_to_webdataset.py --input-dir ./data/single_subject_00060 --output-dir ./data/shards_single_subject """ import argparse import io import re import sys from pathlib import Path import numpy as np import webdataset as wds EXPR_ENV_RE = re.compile(r"^(\d{5})_(\d{3})$") FLAME_DIR_RE = re.compile(r"^flame_2023_(\d{3})$") CAM_JSON_RE = re.compile(r"^(C\d{2})\.json$") def find_expr_env_dirs(root: Path): """Yields (subject, expr, env, path) for every SUBJECT/EXPR_ENV directory under root.""" for path in sorted(root.rglob("*")): if not path.is_dir(): continue m = EXPR_ENV_RE.match(path.name) if not m: continue expr, env = m.group(1), m.group(2) subject = path.parent.name if not re.match(r"^\d{5}$", subject): raise ValueError(f"Expected 5-digit SUBJECT parent dir, got {path.parent} for {path}") yield subject, expr, env, path def find_flame_dirs(root: Path): """Yields (subject, env, path) for every SUBJECT/flame_2023_ENV directory under root.""" for path in sorted(root.rglob("flame_2023_*")): if not path.is_dir(): continue m = FLAME_DIR_RE.match(path.name) if not m: continue env = m.group(1) subject = path.parent.name if not re.match(r"^\d{5}$", subject): raise ValueError(f"Expected 5-digit SUBJECT parent dir, got {path.parent} for {path}") yield subject, env, path def load_landmark_npz_normalized(path: Path) -> bytes: """STAR landmark npz files have mixed float32/float64 dtypes across the source dataset (confirmed: bounding_box and face_landmark_2d vary even within the same scene). Normalize to float32 so the full shard set has one consistent Arrow schema when loaded via HF `datasets` (it infers schema across all samples upfront, unlike the lazy `webdataset` lib). This is the one field we don't copy byte-verbatim; documented in the dataset card. """ with np.load(path) as d: arrays = {k: d[k].astype(np.float32) for k in d.files} buf = io.BytesIO() np.savez(buf, **arrays) return buf.getvalue() def cameras_in(scene_dir: Path): """Returns sorted camera names (e.g. ['C00', 'C01', ...]) found in cameras_json/.""" cam_dir = scene_dir / "cameras_json" cams = [] for f in cam_dir.iterdir(): m = CAM_JSON_RE.match(f.name) if m: cams.append(m.group(1)) return sorted(cams) def convert_view_tier(root: Path, out_dir: Path, shard_size_bytes: int): seen_keys = set() (out_dir / "views").mkdir(parents=True, exist_ok=True) pattern = str(out_dir / "views" / "shard-%06d.tar") n_written = 0 with wds.ShardWriter(pattern, maxsize=shard_size_bytes) as sink: for subject, expr, env, scene_dir in find_expr_env_dirs(root): expr_env = f"{expr}_{env}" env_json_path = scene_dir / "color_image" / "environment.json" if not env_json_path.exists(): raise FileNotFoundError(f"Missing environment.json: {env_json_path}") env_json_bytes = env_json_path.read_bytes() cams = cameras_in(scene_dir) if not cams: raise ValueError(f"No cameras found under {scene_dir}/cameras_json") for cam in cams: key = f"{subject}/{expr_env}/{cam}" if key in seen_keys: raise ValueError(f"Duplicate view-tier key: {key}") seen_keys.add(key) rgb_path = scene_dir / "color_image" / f"{cam}.png" mask_path = scene_dir / "foreground_mask" / f"{cam}.png" seg_path = scene_dir / "segmentation" / f"{cam}.png" cam_json_path = scene_dir / "cameras_json" / f"{cam}.json" landmark_path = scene_dir / "landmark2d" / "STAR" / f"{cam}.npz" for p in (rgb_path, mask_path, seg_path, cam_json_path, landmark_path): if not p.exists(): raise FileNotFoundError(f"Missing expected file for {key}: {p}") sink.write({ "__key__": key, "rgb.png": rgb_path.read_bytes(), "mask.png": mask_path.read_bytes(), "seg.png": seg_path.read_bytes(), "cam.json": cam_json_path.read_bytes(), "landmark.npz": load_landmark_npz_normalized(landmark_path), "env.json": env_json_bytes, }) n_written += 1 print(f"[view tier] wrote {n_written} samples, {len(seen_keys)} unique keys") def convert_scene_mesh_tier(root: Path, out_dir: Path, shard_size_bytes: int): seen_keys = set() (out_dir / "scene_mesh").mkdir(parents=True, exist_ok=True) pattern = str(out_dir / "scene_mesh" / "shard-%06d.tar") n_written = 0 with wds.ShardWriter(pattern, maxsize=shard_size_bytes) as sink: for subject, env, flame_dir in find_flame_dirs(root): mesh_dir = flame_dir / "eval_100" / "mesh" if not mesh_dir.exists(): raise FileNotFoundError(f"Missing mesh dir: {mesh_dir}") obj_files = sorted(mesh_dir.glob("frame_*.obj")) if not obj_files: raise ValueError(f"No mesh .obj files found under {mesh_dir}") for obj_path in obj_files: m = re.match(r"^frame_(\d{5})\.obj$", obj_path.name) if not m: raise ValueError(f"Unexpected mesh filename: {obj_path}") expr = m.group(1) expr_env = f"{expr}_{env}" key = f"{subject}/{expr_env}" if key in seen_keys: raise ValueError(f"Duplicate scene-mesh-tier key: {key}") seen_keys.add(key) mtl_path = mesh_dir / f"frame_{expr}.mtl" jpg_path = mesh_dir / f"frame_{expr}.jpg" for p in (mtl_path, jpg_path): if not p.exists(): raise FileNotFoundError(f"Missing expected mesh file for {key}: {p}") sink.write({ "__key__": key, "mesh.obj": obj_path.read_bytes(), "mesh.mtl": mtl_path.read_bytes(), "mesh.jpg": jpg_path.read_bytes(), }) n_written += 1 print(f"[scene-mesh tier] wrote {n_written} samples, {len(seen_keys)} unique keys") def convert_flame_params_tier(root: Path, out_dir: Path, shard_size_bytes: int): seen_keys = set() (out_dir / "flame_params").mkdir(parents=True, exist_ok=True) pattern = str(out_dir / "flame_params" / "shard-%06d.tar") n_written = 0 with wds.ShardWriter(pattern, maxsize=shard_size_bytes) as sink: for subject, env, flame_dir in find_flame_dirs(root): key = f"{subject}/{env}" if key in seen_keys: raise ValueError(f"Duplicate flame-params-tier key: {key}") seen_keys.add(key) npz_path = flame_dir / "tracked_flame_params_100.npz" if not npz_path.exists(): raise FileNotFoundError(f"Missing FLAME params file: {npz_path}") sink.write({ "__key__": key, "flame.npz": npz_path.read_bytes(), }) n_written += 1 print(f"[flame-params tier] wrote {n_written} samples, {len(seen_keys)} unique keys") def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--input-dir", required=True, type=Path, help="Root of an unzipped Cafca chunk (searched recursively for SUBJECT/EXPR_ENV and SUBJECT/flame_2023_ENV dirs)") parser.add_argument("--output-dir", required=True, type=Path, help="Output dir; will contain views/, scene_mesh/, flame_params/ shard subfolders") parser.add_argument("--shard-size-mb", type=int, default=500, help="Target shard size in MB (default: 500)") args = parser.parse_args() if not args.input_dir.exists(): print(f"ERROR: input dir does not exist: {args.input_dir}", file=sys.stderr) sys.exit(1) args.output_dir.mkdir(parents=True, exist_ok=True) shard_size_bytes = args.shard_size_mb * 1_000_000 convert_view_tier(args.input_dir, args.output_dir, shard_size_bytes) convert_scene_mesh_tier(args.input_dir, args.output_dir, shard_size_bytes) convert_flame_params_tier(args.input_dir, args.output_dir, shard_size_bytes) if __name__ == "__main__": main()