File size: 5,575 Bytes
72cdf8f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 | #!/usr/bin/env python3
"""
Generate delta CSV from a directory of frame files.
Outputs left_delta and right_delta in seconds. Nulls only on scene change.
Usage:
python clean_delta.py /path/to/rgb_dir -o delta.csv
python clean_delta.py /path/to/rgb_dir -o delta.csv --fps-json fps.json
"""
import argparse
import csv
import json
from pathlib import Path
DEFAULT_FPS: dict[str, float] = {
# part0 scenes
"atanasie_DJI_0652_full": 29.97,
"gradistei_DJI_0787_0788_0789_combined_sliced_3510_13110": 29.97,
"herculane_DJI_0021_full": 29.97,
"jupiter_DJI_0703_0704_0705_combined_sliced_10650_21715": 29.97,
"olanesti_DJI_0416_full": 29.97,
"petrova_DJI_0525_0526_combined_sliced_2850_11850": 29.97,
"slanic_DJI_0956_0957_combined_sliced_780_9780": 29.97,
# part1 scenes
# (slanic_DJI_0956_0957_combined_sliced_780_9780 already included above)
}
def parse_frame_name(name: str) -> tuple[str, int] | None:
"""
Parse 'scene_prefix_123' into ('scene_prefix', 123).
Returns None if name is empty or doesn't end with a number.
"""
if not name:
return None
parts = name.rsplit("_", maxsplit=1)
if len(parts) != 2:
return None
scene_prefix, frame_number_str = parts
if not frame_number_str.isdigit():
return None
return scene_prefix, int(frame_number_str)
def get_fps(scene: str, fps_map: dict[str, float]) -> float:
"""Get FPS for a scene, default to 29.97 if not found."""
return fps_map.get(scene, 29.97)
def compute_delta_seconds(
current: str,
neighbor: str,
fps_map: dict[str, float],
) -> float | None:
"""
Compute delta in seconds between current and neighbor.
Returns None if different scenes.
"""
current_stem = Path(current).stem
neighbor_stem = Path(neighbor).stem
current_parsed = parse_frame_name(current_stem)
neighbor_parsed = parse_frame_name(neighbor_stem)
if current_parsed is None or neighbor_parsed is None:
return None
current_scene, current_frame = current_parsed
neighbor_scene, neighbor_frame = neighbor_parsed
if current_scene != neighbor_scene:
return None
fps = get_fps(current_scene, fps_map)
frame_delta = neighbor_frame - current_frame
return round(frame_delta / fps, 6)
def load_frame_names(rgb_directory: Path) -> list[str]:
"""Load and sort frame names from rgb directory."""
frame_names: list[str] = []
for file_path in rgb_directory.iterdir():
if file_path.is_file():
frame_names.append(file_path.name)
def sort_key(full_name: str) -> tuple[str, int]:
stem = Path(full_name).stem
parsed = parse_frame_name(stem)
if parsed is None:
return (full_name, 0)
return parsed
return sorted(frame_names, key=sort_key)
def generate_delta_csv(
rgb_directory: Path,
output_path: Path,
fps_map: dict[str, float],
) -> None:
"""Generate delta CSV from rgb directory of frames."""
frame_names = load_frame_names(rgb_directory)
total_frames = len(frame_names)
if total_frames == 0:
print(f"No frames found in {rgb_directory}")
return
nulled_left = 0
nulled_right = 0
rows: list[dict[str, str | float]] = []
for i, name in enumerate(frame_names):
left_name = frame_names[i - 1] if i > 0 else ""
right_name = frame_names[i + 1] if i < total_frames - 1 else ""
row: dict[str, str | float] = {"name": name}
if left_name:
left_delta = compute_delta_seconds(name, left_name, fps_map)
if left_delta is not None:
row["left_name"] = left_name
row["left_delta"] = left_delta
else:
row["left_name"] = ""
row["left_delta"] = ""
nulled_left += 1
else:
row["left_name"] = ""
row["left_delta"] = ""
if right_name:
right_delta = compute_delta_seconds(name, right_name, fps_map)
if right_delta is not None:
row["right_name"] = right_name
row["right_delta"] = right_delta
else:
row["right_name"] = ""
row["right_delta"] = ""
nulled_right += 1
else:
row["right_name"] = ""
row["right_delta"] = ""
rows.append(row)
fieldnames = ["name", "left_name", "left_delta", "right_name", "right_delta"]
with open(output_path, "w", newline="") as f:
writer = csv.DictWriter(f, fieldnames=fieldnames)
writer.writeheader()
writer.writerows(rows)
print(f"Created {output_path}")
print(f"Total frames: {total_frames}")
print(f"Nulled left: {nulled_left} (scene change)")
print(f"Nulled right: {nulled_right} (scene change)")
def main() -> None:
parser = argparse.ArgumentParser(description="Generate delta CSV from frame files.")
parser.add_argument("rgb_directory", type=Path, help="RGB directory containing frame files (e.g., .../rgb/part0)")
parser.add_argument("-o", "--output", type=Path, default=Path("delta.csv"), help="Output CSV path")
parser.add_argument("--fps-json", type=Path, help="JSON file mapping scene prefix to FPS")
args = parser.parse_args()
fps_map = DEFAULT_FPS.copy()
if args.fps_json:
with open(args.fps_json) as f:
fps_map.update(json.load(f))
generate_delta_csv(args.rgb_directory, args.output, fps_map)
if __name__ == "__main__":
main()
|