| """Monitor PhysInOne render directories and run EXR post-processing. |
| |
| The processor records completion per scene and requires ``points3d.ply`` by |
| default. The PLY uses the first frame of every static camera. The processor |
| never samples validation views and never writes any transforms_train.json, |
| transforms_val.json, or transforms_test.json file. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| from datetime import datetime |
| import json |
| import os |
| from pathlib import Path |
| import sys |
| import time |
|
|
| PACKAGE_ROOT = Path(__file__).resolve().parent.parent |
| if str(PACKAGE_ROOT) not in sys.path: |
| sys.path.insert(0, str(PACKAGE_ROOT)) |
|
|
| from common.paths import parse_scene_path |
| from postprocess.exr_to_dataset import PASS_PATTERNS, classify, convert_directory |
| from postprocess.point_cloud import generate_points3d, valid_ply |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| source = parser.add_mutually_exclusive_group(required=True) |
| source.add_argument("--render-dir", type=Path, action="append") |
| source.add_argument("--render-list", type=Path, help="One render directory per line.") |
| source.add_argument("--level-list", type=Path, help="One canonical UE level path per line.") |
| parser.add_argument( |
| "--project-root", |
| type=Path, |
| help="PhysInOne project root; required with --level-list.", |
| ) |
| parser.add_argument("--watch", action="store_true", help="Keep polling until every scene succeeds.") |
| parser.add_argument("--interval", type=float, default=60.0) |
| parser.add_argument("--workers", type=int, default=8) |
| parser.add_argument("--jpeg-quality", type=int, default=95) |
| parser.add_argument("--channels", default="rgb,depth,seg") |
| parser.add_argument("--delete-source-exr", action="store_true") |
| parser.add_argument("--skip-ply", action="store_true", help="Do not require or generate points3d.ply.") |
| parser.add_argument("--force-ply", action="store_true", help="Regenerate points3d.ply even when a valid file exists.") |
| parser.add_argument("--depth-threshold", type=float, default=20.0) |
| parser.add_argument("--max-points", type=int, default=100_000) |
| parser.add_argument("--ply-seed", type=int, default=0) |
| parser.add_argument("--log-dir", type=Path, default=Path("render_processor_logs")) |
| return parser.parse_args() |
|
|
|
|
| def read_nonempty_lines(path: Path) -> list[str]: |
| with path.open("r", encoding="utf-8-sig") as handle: |
| return [line.strip() for line in handle if line.strip() and not line.lstrip().startswith("#")] |
|
|
|
|
| def resolve_directories(args: argparse.Namespace) -> dict[str, Path]: |
| if args.render_dir: |
| return {str(path): path.expanduser().resolve() for path in args.render_dir} |
| if args.render_list: |
| return { |
| line: Path(line).expanduser().resolve() |
| for line in read_nonempty_lines(args.render_list) |
| } |
| if args.project_root is None: |
| raise ValueError("--project-root is required with --level-list.") |
| project_root = args.project_root.expanduser().resolve() |
| return { |
| level: parse_scene_path(level).render_directory(project_root) |
| for level in read_nonempty_lines(args.level_list) |
| } |
|
|
|
|
| def expected_cameras(render_dir: Path) -> dict[str, int]: |
| expected: dict[str, int] = {} |
| for path in sorted(render_dir.glob("blender_CineCamera_*.json")): |
| try: |
| with path.open("r", encoding="utf-8") as handle: |
| document = json.load(handle) |
| frames = document.get("frames", []) |
| total = int(document.get("total_frames", len(frames))) |
| if total > 0: |
| expected[path.stem.removeprefix("blender_")] = total |
| except (OSError, ValueError, TypeError, json.JSONDecodeError): |
| continue |
| return expected |
|
|
|
|
| def converted_complete(render_dir: Path, channels: set[str]) -> bool: |
| cameras = expected_cameras(render_dir) |
| if not cameras: |
| return False |
| for camera, frame_count in cameras.items(): |
| for channel in channels: |
| extension = ".jpg" if channel == "rgb" else ".npz" |
| folder = render_dir / camera / channel |
| files = [path for path in folder.glob(f"*{extension}") if path.stat().st_size > 0] |
| if len(files) != frame_count: |
| return False |
| return True |
|
|
|
|
| def raw_render_complete(render_dir: Path, channels: set[str]) -> tuple[bool, str]: |
| cameras = expected_cameras(render_dir) |
| if not cameras: |
| return False, "camera metadata is not ready" |
| for camera, frame_count in cameras.items(): |
| folder = render_dir / camera |
| if not folder.is_dir(): |
| return False, f"missing camera directory: {camera}" |
| counts = {channel: 0 for channel in channels} |
| frame_ids = {channel: set() for channel in channels} |
| for path in folder.glob("*.exr"): |
| identified = classify(path) |
| if identified is None: |
| continue |
| channel, frame = identified |
| if channel in channels: |
| counts[channel] += 1 |
| frame_ids[channel].add(frame) |
| for channel in channels: |
| if counts[channel] != frame_count or len(frame_ids[channel]) != frame_count: |
| return ( |
| False, |
| f"{camera}/{channel}: found {counts[channel]} unique={len(frame_ids[channel])}, " |
| f"expected {frame_count}", |
| ) |
| return True, "ready" |
|
|
|
|
| def ensure_points3d(render_dir: Path, args: argparse.Namespace) -> dict[str, int | float | str]: |
| output = render_dir / "points3d.ply" |
| if not args.force_ply and valid_ply(output): |
| return {"output": str(output), "status": "already valid"} |
| return generate_points3d( |
| render_dir, |
| output=output, |
| depth_threshold=args.depth_threshold, |
| max_points=args.max_points, |
| seed=args.ply_seed, |
| ) |
|
|
|
|
| class Journal: |
| def __init__(self, directory: Path): |
| self.directory = directory.resolve() |
| self.directory.mkdir(parents=True, exist_ok=True) |
| self.progress = self.directory / "progress.log" |
| self.success = self.directory / "success_scenes.tsv" |
| self.failure = self.directory / "failed_attempts.tsv" |
| self.completed = self._load_completed() |
|
|
| def _load_completed(self) -> set[str]: |
| if not self.success.exists(): |
| return set() |
| completed = set() |
| with self.success.open("r", encoding="utf-8") as handle: |
| for line in handle: |
| parts = line.rstrip("\n").split("\t") |
| if len(parts) >= 2: |
| completed.add(parts[1]) |
| return completed |
|
|
| @staticmethod |
| def timestamp() -> str: |
| return datetime.now().astimezone().isoformat(timespec="seconds") |
|
|
| @staticmethod |
| def append(path: Path, fields: list[str]) -> None: |
| with path.open("a", encoding="utf-8") as handle: |
| handle.write("\t".join(field.replace("\t", " ").replace("\n", " ") for field in fields) + "\n") |
| handle.flush() |
| os.fsync(handle.fileno()) |
|
|
| def log(self, message: str) -> None: |
| text = f"[{self.timestamp()}] {message}" |
| print(text, flush=True) |
| self.append(self.progress, [text]) |
|
|
| def mark_success(self, key: str, directory: Path, detail: str) -> None: |
| self.append(self.success, [self.timestamp(), key, str(directory), detail]) |
| self.completed.add(key) |
|
|
| def mark_failure(self, key: str, directory: Path, detail: str) -> None: |
| self.append(self.failure, [self.timestamp(), key, str(directory), detail]) |
|
|
|
|
| def main() -> int: |
| args = parse_args() |
| channels = {item.strip().lower() for item in args.channels.split(",") if item.strip()} |
| unknown = channels - set(PASS_PATTERNS) |
| if not channels or unknown: |
| raise ValueError(f"Invalid --channels value; unknown={sorted(unknown)}") |
| if not args.skip_ply and not {"rgb", "depth"}.issubset(channels): |
| raise ValueError("PLY generation requires both rgb and depth; use --skip-ply otherwise.") |
| if args.interval <= 0: |
| raise ValueError("--interval must be positive.") |
|
|
| targets = resolve_directories(args) |
| journal = Journal(args.log_dir) |
| pending = {} |
| for key, path in targets.items(): |
| outputs_valid = converted_complete(path, channels) |
| ply_valid = args.skip_ply or (valid_ply(path / "points3d.ply") and not args.force_ply) |
| if key not in journal.completed or not outputs_valid or not ply_valid: |
| pending[key] = path |
| journal.log( |
| f"Loaded {len(targets)} target(s); completed={len(targets) - len(pending)}, " |
| f"pending={len(pending)}." |
| ) |
|
|
| while pending: |
| for key, render_dir in list(pending.items()): |
| if converted_complete(render_dir, channels): |
| try: |
| ply = None if args.skip_ply else ensure_points3d(render_dir, args) |
| detail = "already converted and verified" |
| if ply is not None: |
| detail += "; points3d=" + json.dumps(ply, sort_keys=True) |
| journal.mark_success(key, render_dir, detail) |
| journal.log(f"[SUCCESS] {key}: {detail}") |
| pending.pop(key) |
| except Exception as exc: |
| journal.mark_failure(key, render_dir, str(exc)) |
| journal.log(f"[FAILED] {key}: PLY generation failed: {exc}") |
| continue |
|
|
| ready, reason = raw_render_complete(render_dir, channels) |
| if not ready: |
| journal.log(f"[WAITING] {key}: {reason}") |
| continue |
|
|
| try: |
| counts = convert_directory( |
| render_dir, |
| None, |
| channels, |
| args.workers, |
| args.jpeg_quality, |
| args.delete_source_exr, |
| ) |
| if not converted_complete(render_dir, channels): |
| raise RuntimeError("converted files did not pass the full camera/frame check") |
| if not args.skip_ply: |
| counts["points3d"] = ensure_points3d(render_dir, args) |
| detail = json.dumps(counts, sort_keys=True) |
| journal.mark_success(key, render_dir, detail) |
| journal.log(f"[SUCCESS] {key}: {detail}") |
| pending.pop(key) |
| except Exception as exc: |
| journal.mark_failure(key, render_dir, str(exc)) |
| journal.log(f"[FAILED] {key}: {exc}") |
|
|
| if not pending or not args.watch: |
| break |
| journal.log(f"Waiting {args.interval:g}s; {len(pending)} target(s) remain.") |
| time.sleep(args.interval) |
|
|
| if pending: |
| journal.log(f"Finished one scan with {len(pending)} pending target(s).") |
| return 2 |
| journal.log("All targets completed successfully.") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
