| """Read the HandDiffuse relative-path episode layout without modifying data. |
| |
| NumPy is needed only for load_motion(). No MANO models, renderer, video decoder, |
| or machine-specific paths are required. See README.md for the draft's limits. |
| """ |
| from __future__ import annotations |
|
|
| import csv |
| import json |
| from dataclasses import dataclass |
| from fractions import Fraction |
| from pathlib import Path, PurePosixPath |
| from typing import Callable, Iterator |
|
|
|
|
| @dataclass(frozen=True) |
| class Frame: |
| motion_index: int |
| video_index: int | None |
| video_pts: int | None |
| video_time_base: Fraction | None |
| video_timestamp_seconds: str | None |
| quality_flags: tuple[str, ...] = () |
| alignment_certainty: str = 'SUPPORTED_BY_RECORDED_EVIDENCE' |
| alternative_video_index: int | None = None |
| alternative_video_pts: int | None = None |
| alternative_video_timestamp_seconds: str | None = None |
|
|
| @property |
| def has_approximate_timing(self) -> bool: |
| return self.alignment_certainty == 'APPROXIMATE_ADJACENT_FRAME_SELECTION' |
|
|
| @property |
| def available(self) -> bool: |
| return self.video_index is not None |
|
|
| @property |
| def passes_recorded_screens(self) -> bool: |
| """Availability and recorded screens only; not an accuracy guarantee.""" |
| return self.available and not self.quality_flags |
|
|
|
|
| def _relative(value: str) -> PurePosixPath: |
| path = PurePosixPath(value) |
| if not value or path.is_absolute() or '..' in path.parts or '\\' in value: |
| raise ValueError(f'Expected a confined relative package path: {value!r}') |
| return path |
|
|
|
|
| class Episode: |
| """One selected pair of hands and explicitly listed camera views. |
| |
| root is the package root containing episodes/. An optional resolver maps |
| package-relative paths to existing read-only files for curation without |
| staging media. Published datasets use the default relative-path resolver. |
| """ |
|
|
| def __init__(self, root: str | Path, episode_id: str, |
| resolver: Callable[[str], Path] | None = None): |
| if len(_relative(episode_id).parts) != 1 or episode_id in ('.', ''): |
| raise ValueError('episode_id must be one directory name') |
| self.root = Path(root).resolve() |
| self.prefix = PurePosixPath('episodes') / episode_id |
| self._resolver = resolver |
| self.metadata = self._json(self.path('metadata.json')) |
| if self.metadata['episode_id'] != episode_id: |
| raise ValueError('Episode ID differs from metadata') |
| self.frames = int(self.metadata['motion']['frames']) |
| if self.frames < 0: |
| raise ValueError('Negative motion length') |
| self.cameras = {} |
| for camera in self.metadata['cameras']: |
| uid = camera['camera_uid'] |
| if uid in self.cameras: |
| raise ValueError(f'Duplicate camera UID: {uid}') |
| self.cameras[uid] = camera |
| self.motion_files = {} |
| for item in self.metadata['motion']['files']: |
| side = item['side'] |
| if side in self.motion_files or side not in ('left', 'right'): |
| raise ValueError('Expected one selected file per hand') |
| self.motion_files[side] = item |
| if set(self.motion_files) != {'left', 'right'}: |
| raise ValueError('Episode requires both selected hand files') |
| self._calibrations: dict[str, dict] = {} |
| self._flags: dict[int, set[str]] | None = None |
|
|
| @staticmethod |
| def _json(path: Path): |
| with path.open(encoding='utf-8') as handle: |
| return json.load(handle) |
|
|
| def path(self, episode_relative: str) -> Path: |
| target = (self.prefix / _relative(episode_relative)).as_posix() |
| if self._resolver is not None: |
| return Path(self._resolver(target)) |
| result = (self.root / target).resolve() |
| if not result.is_relative_to(self.root): |
| raise ValueError('Resolved path escapes the package root') |
| return result |
|
|
| def load_motion(self, side: str): |
| """Memory-map numeric source values read-only; never invent betas.""" |
| import numpy as np |
| item = self.motion_files[side] |
| array = np.load(self.path(item['file']), mmap_mode='r', allow_pickle=False) |
| expected = (self.frames, int(item['parameter_columns'])) |
| if expected[1] not in (51, 61) or tuple(array.shape) != expected: |
| raise ValueError(f'Unexpected {side} motion shape: {array.shape}') |
| if tuple(item['shape']) != expected or str(array.dtype) != item['dtype']: |
| raise ValueError(f'{side} shape/dtype differs from metadata') |
| if bool(item['betas_present']) != (expected[1] == 61): |
| raise ValueError(f'{side} beta declaration differs from shape') |
| return array |
|
|
| def calibration(self, camera_uid: str) -> dict: |
| """Return the original parameter entry, without changing order or values.""" |
| camera = self.cameras[camera_uid] |
| filename = camera['calibration_file'] |
| if filename not in self._calibrations: |
| self._calibrations[filename] = self._json(self.path(filename)) |
| data = self._calibrations[filename] |
| if data['episode_id'] != self.metadata['episode_id']: |
| raise ValueError('Calibration belongs to a different episode') |
| return data['namespaces'][camera['parameter_namespace']]['parameters'][str(camera['original_parameter_id'])] |
|
|
| def _indices(self, values) -> set[int]: |
| result = set() |
| for index in values: |
| if isinstance(index, bool) or not isinstance(index, int) or not 0 <= index < self.frames: |
| raise ValueError(f'Invalid motion quality index: {index!r}') |
| result.add(index) |
| return result |
|
|
| def _quality(self) -> dict[int, set[str]]: |
| if self._flags is not None: |
| return self._flags |
| flags: dict[int, set[str]] = {} |
| boundary = self.metadata.get('boundary_quality_mask_file') |
| if boundary: |
| count = 0 |
| with self.path(boundary).open(newline='', encoding='utf-8') as handle: |
| for count, row in enumerate(csv.DictReader(handle), start=1): |
| index = int(row['motion_frame_index']) |
| if index != count - 1 or index >= self.frames: |
| raise ValueError('Boundary mask must cover consecutive motion rows') |
| if row['boundary_usable'] not in ('0', '1'): |
| raise ValueError('Invalid boundary availability flag') |
| if row['boundary_usable'] == '0': |
| flags.setdefault(index, set()).add('boundary_screen') |
| if count != self.frames: |
| raise ValueError('Incomplete boundary mask') |
| local = self._indices(self.metadata.get('locally_excluded_motion_indices', [])) |
| events_path = self.metadata.get('local_motion_quality_events_file') |
| if events_path: |
| events = self._json(self.path(events_path)) |
| if events['episode_id'] != self.metadata['episode_id'] or events['motion_frames'] != self.frames: |
| raise ValueError('Local events belong to a different motion') |
| if self._indices(events['strict_pair_excluded_motion_indices']) != local: |
| raise ValueError('Local event indices differ from metadata') |
| for side, item in self.motion_files.items(): |
| if events['motion_file_sha256_by_side'][side] != item['sha256']: |
| raise ValueError('Local events are bound to a different selected motion') |
| elif local: |
| raise ValueError('Local mask declared without event annotations') |
| for index in local: |
| flags.setdefault(index, set()).add('local_motion_screen') |
| self._flags = flags |
| return flags |
|
|
| def quality_flags(self, motion_index: int) -> tuple[str, ...]: |
| self._indices([motion_index]) |
| return tuple(sorted(self._quality().get(motion_index, ()))) |
|
|
| def iter_frame_map(self, camera_uid: str) -> Iterator[Frame]: |
| """Yield every motion row, including explicit missing video frames. |
| |
| Consume the iterator to exhaustion to validate its complete row count. |
| PTS/time_base remain exact; no fixed FPS or nearest-frame inference. |
| """ |
| camera = self.cameras[camera_uid] |
| certainty = camera.get('alignment_certainty', 'SUPPORTED_BY_RECORDED_EVIDENCE') |
| approximate = certainty == 'APPROXIMATE_ADJACENT_FRAME_SELECTION' |
| if approximate: |
| if camera.get('exact_extraction_index_recovered') is not False: |
| raise ValueError('Approximate timing cannot declare exact extraction recovery') |
| if abs(camera['selected_fixed_offset'] - camera['alternative_fixed_offset']) != 1: |
| raise ValueError('Expected adjacent alternative offsets') |
| flags = self._quality() |
| missing = [] |
| count = 0 |
| with self.path(camera['frame_map_file']).open(newline='', encoding='utf-8') as handle: |
| for count, row in enumerate(csv.DictReader(handle), start=1): |
| index = int(row['motion_frame_index']) |
| if index != count - 1 or index >= self.frames: |
| raise ValueError('Frame map must cover consecutive motion rows') |
| video = row['video_frame_index'].strip() |
| available = bool(video) |
| explicit = row.get('source_frame_available') |
| if explicit is not None and explicit not in ('0', '1'): |
| raise ValueError('Invalid source_frame_available flag') |
| if explicit is not None and (explicit == '1') != available: |
| raise ValueError('Availability flag contradicts source index') |
| raw_pts = row['video_pts'].strip() |
| raw_base = row['video_time_base'].strip() |
| raw_seconds = row['video_timestamp_seconds'].strip() |
| if not available: |
| if raw_pts or raw_base or raw_seconds: |
| raise ValueError('Missing video row contains a timestamp') |
| missing.append(index) |
| video_index = pts = base = seconds = None |
| else: |
| if not raw_pts or not raw_base or not raw_seconds: |
| raise ValueError('Available video row has incomplete timing') |
| video_index, pts = int(video), int(raw_pts) |
| base, seconds = Fraction(raw_base), raw_seconds |
| if video_index < 0 or base <= 0: |
| raise ValueError('Invalid video index/time base') |
| alternate_index = alternate_pts = alternate_seconds = None |
| row_certainty = row.get('alignment_certainty', certainty) |
| if row_certainty != certainty: |
| raise ValueError('Frame timing certainty differs from camera metadata') |
| if approximate: |
| alternate = row.get('alternative_video_frame_index', '').strip() |
| alternate_tick = row.get('alternative_video_pts', '').strip() |
| alternate_seconds = row.get('alternative_video_timestamp_seconds', '').strip() |
| if not available or not alternate or not alternate_tick or not alternate_seconds: |
| raise ValueError('Approximate frame map requires both candidate timestamps') |
| alternate_index, alternate_pts = int(alternate), int(alternate_tick) |
| if (video_index != index + camera['selected_fixed_offset'] or |
| alternate_index != index + camera['alternative_fixed_offset'] or |
| alternate_index < 0): |
| raise ValueError('Approximate candidate indices differ from recorded offsets') |
| yield Frame(index, video_index, pts, base, seconds, |
| tuple(sorted(flags.get(index, ()))), certainty, |
| alternate_index, alternate_pts, alternate_seconds) |
| if count != self.frames: |
| raise ValueError('Incomplete frame map') |
| if missing != camera.get('unobserved_motion_indices', []): |
| raise ValueError('Missing source rows differ from camera metadata') |
| if self.frames - len(missing) != camera['source_video_observed_motion_frames']: |
| raise ValueError('Observed row count differs from metadata') |
|
|
