| |
| """Install HOTC2026-Modal and optionally join it to the official HOTC 2026 data.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import hashlib |
| import json |
| import os |
| import shutil |
| import struct |
| import tempfile |
| import zipfile |
| from pathlib import Path |
|
|
|
|
| RELEASE_FORMAT = "hotc2026-modal-release-manifest-v1" |
| VIDEO_FORMAT = "hotc2026-modal-video-annotation-v1" |
| INSTALLED_FORMAT = "hotc2026-modal-installed-v1" |
| INTEGRATED_FORMAT = "hotc2026-modal-integrated-v1" |
|
|
| FALSE_COLOR_DIRS = { |
| "training": { |
| "nir": "HSI-NIR-FalseColor", |
| "rednir": "HSI-RedNIR-FalseColor", |
| "vis": "HSI-VIS-FalseColor_25", |
| }, |
| "update": { |
| "nir": "HSI-NIR-FalseColor", |
| "rednir": "HSI-RedNIR-FalseColor", |
| "vis": "HSI-VIS-FalseColor", |
| }, |
| "validation": { |
| "nir": "HSI-NIR-FalseColor", |
| "rednir": "HSI-RedNIR-FalseColor", |
| "vis": "HSI-VIS-FalseColor", |
| }, |
| } |
| HSI_DIRS = { |
| "nir": "HSI-NIR", |
| "rednir": "HSI-RedNIR", |
| "vis": "HSI-VIS", |
| } |
|
|
|
|
| def sha256_file(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def atomic_write(path: Path, data: bytes) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| descriptor, temporary = tempfile.mkstemp(prefix=path.name, suffix=".tmp", dir=path.parent) |
| try: |
| with os.fdopen(descriptor, "wb") as handle: |
| handle.write(data) |
| os.replace(temporary, path) |
| finally: |
| if os.path.exists(temporary): |
| os.unlink(temporary) |
|
|
|
|
| def portable(path: Path, base: Path) -> str: |
| try: |
| return path.resolve().relative_to(base).as_posix() |
| except ValueError: |
| return str(path.resolve()) |
|
|
|
|
| def parse_id(identifier: str) -> tuple[str, str, int]: |
| sequence_id, separator, frame_text = identifier.rpartition("_") |
| if not separator or not frame_text.isdigit(): |
| raise ValueError(f"invalid HOTC ID: {identifier!r}") |
| sensor, separator, sequence = sequence_id.partition("-") |
| if not separator or sensor not in HSI_DIRS or not sequence: |
| raise ValueError(f"invalid HOTC ID: {identifier!r}") |
| return sensor, sequence, int(frame_text) |
|
|
|
|
| def read_csv(path: Path, validation: bool) -> dict[tuple[str, str, str], list[dict]]: |
| videos: dict[tuple[str, str, str], list[dict]] = {} |
| collection = "validation" if validation else "training" |
| previous_frame: int | None = None |
| with path.open(newline="", encoding="utf-8-sig") as handle: |
| reader = csv.DictReader(handle) |
| if reader.fieldnames != ["ID", "x", "y", "width", "height"]: |
| raise ValueError(f"unexpected columns in {path}: {reader.fieldnames}") |
| for row in reader: |
| sensor, sequence, frame_number = parse_id(row["ID"]) |
| if not validation and previous_frame is not None and frame_number < previous_frame: |
| if collection == "update": |
| raise ValueError(f"multiple collection resets in {path}") |
| collection = "update" |
| previous_frame = frame_number |
| bbox = None |
| if not validation: |
| bbox = [int(row[name]) for name in ("x", "y", "width", "height")] |
| videos.setdefault((collection, sensor, sequence), []).append( |
| { |
| "frame_key": f"{collection}/{row['ID']}", |
| "frame_number": frame_number, |
| "official_amodal_bbox_xywh": bbox, |
| } |
| ) |
| return videos |
|
|
|
|
| def numbered_files(directory: Path, suffixes: set[str]) -> list[Path]: |
| files = [ |
| path for path in directory.iterdir() |
| if path.is_file() and path.suffix.lower() in suffixes and path.stem.isdigit() |
| ] |
| return sorted(files, key=lambda path: int(path.stem)) |
|
|
|
|
| def find_frame_directory( |
| roots: list[Path], expected_count: int, suffixes: set[str] |
| ) -> Path: |
| matches = [] |
| for root in roots: |
| if not root.is_dir(): |
| continue |
| candidates = [root, *(path for path in root.rglob("*") if path.is_dir())] |
| for candidate in candidates: |
| if len(numbered_files(candidate, suffixes)) == expected_count: |
| matches.append(candidate.resolve()) |
| matches = sorted(set(matches)) |
| if len(matches) != 1: |
| raise FileNotFoundError( |
| f"expected exactly one directory with {expected_count} frames under {roots}; " |
| f"found {len(matches)}: {matches}" |
| ) |
| return matches[0] |
|
|
|
|
| def sequence_roots( |
| training_roots: list[Path], |
| validation_roots: list[Path], |
| collection: str, |
| sensor: str, |
| sequence: str, |
| ) -> tuple[list[Path], list[Path]]: |
| if collection == "validation": |
| bases = validation_roots |
| elif collection == "update": |
| bases = [root / "update" for root in training_roots] |
| elif collection == "training": |
| bases = training_roots |
| else: |
| raise ValueError(f"unsupported collection: {collection!r}") |
| return ( |
| [base / FALSE_COLOR_DIRS[collection][sensor] / sequence for base in bases], |
| [base / HSI_DIRS[sensor] / sequence for base in bases], |
| ) |
|
|
|
|
| def png_size(path: Path) -> tuple[int, int]: |
| with path.open("rb") as handle: |
| header = handle.read(24) |
| if len(header) < 24 or header[:8] != b"\x89PNG\r\n\x1a\n" or header[12:16] != b"IHDR": |
| raise ValueError(f"invalid PNG: {path}") |
| return struct.unpack(">II", header[16:24]) |
|
|
|
|
| def jpeg_size(path: Path) -> tuple[int, int]: |
| with path.open("rb") as handle: |
| if handle.read(2) != b"\xff\xd8": |
| raise ValueError(f"invalid JPEG: {path}") |
| while True: |
| byte = handle.read(1) |
| while byte == b"\xff": |
| byte = handle.read(1) |
| if not byte: |
| break |
| marker = byte[0] |
| if marker in {0xD8, 0xD9} or 0xD0 <= marker <= 0xD7: |
| continue |
| length_data = handle.read(2) |
| if len(length_data) != 2: |
| break |
| length = struct.unpack(">H", length_data)[0] |
| if marker in { |
| 0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, |
| 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF, |
| }: |
| dimensions = handle.read(5) |
| if len(dimensions) != 5: |
| break |
| height, width = struct.unpack(">HH", dimensions[1:5]) |
| return width, height |
| handle.seek(length - 2, 1) |
| raise ValueError(f"JPEG dimensions not found: {path}") |
|
|
|
|
| def image_size(path: Path) -> tuple[int, int]: |
| if path.suffix.lower() == ".png": |
| return png_size(path) |
| if path.suffix.lower() in {".jpg", ".jpeg"}: |
| return jpeg_size(path) |
| raise ValueError(f"unsupported image type: {path}") |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("snapshot", type=Path, help="downloaded Hugging Face snapshot") |
| parser.add_argument("--output", type=Path, default=Path("hotc2026-modal-v1")) |
| parser.add_argument( |
| "--training-root", type=Path, action="append", |
| help="training directory; repeat if modalities are split across roots", |
| ) |
| parser.add_argument( |
| "--validation-root", type=Path, action="append", |
| help="validation directory; repeat if modalities are split across roots", |
| ) |
| parser.add_argument("--training-csv", type=Path) |
| parser.add_argument("--sample-csv", type=Path) |
| parser.add_argument( |
| "--path-base", type=Path, default=Path.cwd(), |
| help="make official-data paths relative to this directory when possible", |
| ) |
| args = parser.parse_args() |
| integration_values = ( |
| args.training_root, args.validation_root, args.training_csv, args.sample_csv |
| ) |
| if any(value is not None for value in integration_values) and not all( |
| value is not None for value in integration_values |
| ): |
| parser.error( |
| "--training-root, --validation-root, --training-csv, and --sample-csv " |
| "must be supplied together" |
| ) |
| return args |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| snapshot = args.snapshot.resolve() |
| output = args.output.resolve() |
| path_base = args.path_base.resolve() |
| release = json.loads((snapshot / "release-manifest.json").read_text(encoding="utf-8")) |
| if release.get("format") != RELEASE_FORMAT: |
| raise ValueError("unsupported release manifest") |
|
|
| integrate = args.training_root is not None |
| official_rows: dict[tuple[str, str, str], list[dict]] = {} |
| training_roots = validation_roots = None |
| if integrate: |
| training_roots = [path.resolve() for path in args.training_root] |
| validation_roots = [path.resolve() for path in args.validation_root] |
| official_rows.update(read_csv(args.training_csv.resolve(), validation=False)) |
| official_rows.update(read_csv(args.sample_csv.resolve(), validation=True)) |
|
|
| output.mkdir(parents=True, exist_ok=True) |
| index_path = output / "frames.jsonl" |
| index_handle = index_path.open("w", encoding="utf-8") if integrate else None |
| videos = [] |
| total_frames = 0 |
| try: |
| for video_index, video in enumerate(release["videos"], start=1): |
| collection = video["collection"] |
| sensor = video["sensor"] |
| sequence = video["sequence_name"] |
| identity = (collection, sensor, sequence) |
| archive_path = snapshot / video["path"] |
| if archive_path.stat().st_size != video["size_bytes"]: |
| raise ValueError(f"archive size mismatch: {archive_path}") |
| if sha256_file(archive_path) != video["sha256"]: |
| raise ValueError(f"archive checksum mismatch: {archive_path}") |
|
|
| video_root = output / collection / sensor / sequence |
| with zipfile.ZipFile(archive_path) as archive: |
| annotation = json.loads(archive.read("annotation.json")) |
| if annotation.get("format") != VIDEO_FORMAT: |
| raise ValueError(f"unsupported archive: {archive_path}") |
| annotation_identity = tuple( |
| annotation.get(name) for name in ("collection", "sensor", "sequence_name") |
| ) |
| if annotation_identity != identity: |
| raise ValueError(f"archive identity mismatch: {archive_path}") |
| frames = annotation["frames"] |
| if len(frames) != video["frame_count"]: |
| raise ValueError(f"archive frame count mismatch: {archive_path}") |
|
|
| image_files = hsi_files = rows = None |
| if integrate: |
| rows = official_rows.get(identity) |
| if rows is None or len(rows) != len(frames): |
| raise ValueError( |
| f"official CSV rows do not match {'/'.join(identity)}: " |
| f"{0 if rows is None else len(rows)} != {len(frames)}" |
| ) |
| false_color_root, hsi_root = sequence_roots( |
| training_roots, validation_roots, collection, sensor, sequence |
| ) |
| image_directory = find_frame_directory( |
| false_color_root, len(frames), {".jpg", ".jpeg"} |
| ) |
| hsi_directory = find_frame_directory(hsi_root, len(frames), {".png"}) |
| image_files = numbered_files(image_directory, {".jpg", ".jpeg"}) |
| hsi_files = numbered_files(hsi_directory, {".png"}) |
|
|
| for frame_offset, frame in enumerate(frames): |
| mask_path = video_root / frame["mask_path"] |
| mask_bytes = archive.read(frame["mask_path"]) |
| if hashlib.sha256(mask_bytes).hexdigest() != frame["mask_sha256"]: |
| raise ValueError(f"mask checksum mismatch: {frame['frame_key']}") |
| if not mask_path.is_file() or sha256_file(mask_path) != frame["mask_sha256"]: |
| atomic_write(mask_path, mask_bytes) |
|
|
| if integrate: |
| row = rows[frame_offset] |
| if row["frame_key"] != frame["frame_key"]: |
| raise ValueError( |
| f"frame-key mismatch: {row['frame_key']} != {frame['frame_key']}" |
| ) |
| image_path = image_files[frame_offset] |
| hsi_path = hsi_files[frame_offset] |
| if image_size(mask_path) != image_size(image_path): |
| raise ValueError( |
| f"mask/image size mismatch for {frame['frame_key']}: " |
| f"{image_size(mask_path)} != {image_size(image_path)}" |
| ) |
| record = { |
| "frame_key": frame["frame_key"], |
| "frame_number": frame["frame_number"], |
| "collection": collection, |
| "sensor": sensor, |
| "sequence_name": sequence, |
| "false_color_image": portable(image_path, path_base), |
| "hsi_mosaic": portable(hsi_path, path_base), |
| "mask": portable(mask_path, path_base), |
| "official_amodal_bbox_xywh": row["official_amodal_bbox_xywh"], |
| "modal_bbox_xywh": frame["modal_bbox_xywh"], |
| } |
| index_handle.write(json.dumps(record, ensure_ascii=False) + "\n") |
|
|
| annotation_path = video_root / "annotation.json" |
| atomic_write( |
| annotation_path, |
| (json.dumps(annotation, ensure_ascii=False, indent=2) + "\n").encode(), |
| ) |
|
|
| total_frames += len(frames) |
| video_record = { |
| "collection": collection, |
| "sensor": sensor, |
| "sequence_name": sequence, |
| "frame_count": len(frames), |
| "annotation": portable(annotation_path, output), |
| } |
| if integrate: |
| video_record["false_color_directory"] = portable(image_directory, path_base) |
| video_record["hsi_directory"] = portable(hsi_directory, path_base) |
| videos.append(video_record) |
| if video_index % 25 == 0 or video_index == len(release["videos"]): |
| print(f"processed {video_index}/{len(release['videos'])} videos", flush=True) |
| finally: |
| if index_handle is not None: |
| index_handle.close() |
|
|
| manifest = { |
| "format": INTEGRATED_FORMAT if integrate else INSTALLED_FORMAT, |
| "source": "ryo818/HOTC2026-Modal", |
| "video_count": len(videos), |
| "frame_count": total_frames, |
| "collections": { |
| name: sum(video["collection"] == name for video in videos) |
| for name in ("training", "update", "validation") |
| }, |
| "frame_index": "frames.jsonl" if integrate else None, |
| "official_data_linked": integrate, |
| "videos": videos, |
| } |
| atomic_write( |
| output / "manifest.json", |
| (json.dumps(manifest, ensure_ascii=False, indent=2) + "\n").encode(), |
| ) |
| print( |
| f"installed {len(videos)} videos / {total_frames} frames under {output}; " |
| f"official data linked: {integrate}", |
| flush=True, |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
