| |
| """EgoHOS -> the hand-warehouse layout declared by schema.json. |
| Legacy OakInk helpers are not a supported v1.1 conversion path.""" |
| import argparse |
| from collections import defaultdict |
| from functools import lru_cache |
| import hashlib |
| import json |
| import os |
| import pickle |
| import random |
| import re |
| import shlex |
| import shutil |
| import sys |
| from pathlib import Path |
|
|
| import numpy as np |
| from PIL import Image |
| import torch |
|
|
| from acquire import sha, safe_path |
| from media import encode |
|
|
| HERE = Path(__file__).resolve().parent |
| |
| |
| REGISTRY = json.loads((HERE / 'schema.json').read_text()) |
| SCHEMA_VERSION = REGISTRY['schema_version'] |
| RELEASE_ID = REGISTRY['release_layout']['release_id'] |
| CAMS = ['north_east_color', 'south_east_color', 'north_west_color', 'south_west_color'] |
| LABELS = ['background', 'left_hand', 'right_hand', 'first_order_left', 'first_order_right', |
| 'first_order_both', 'second_order_left', 'second_order_right', 'second_order_both'] |
|
|
|
|
| def dump(path, data): |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(json.dumps(data, indent=2, ensure_ascii=False, allow_nan=False) + '\n') |
|
|
|
|
| def jsonl(path, rows): |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open('w') as f: |
| for row in rows: |
| f.write(json.dumps(row, ensure_ascii=False, allow_nan=False) + '\n') |
|
|
|
|
| def load(path): |
| return json.loads(path.read_text()) |
|
|
|
|
| def tensor(root, ref, value): |
| p = root / ref |
| p.parent.mkdir(parents=True, exist_ok=True) |
| torch.save(torch.from_numpy(np.asarray(value).copy()).cpu(), p) |
|
|
|
|
| def component(schema, ref, axes, valid, vaxes, source, method, kind='format_conversion', **extra): |
| return {'available': True, 'schema_id': schema, 'data_ref': ref, 'axes': axes, |
| 'valid_ref': valid, 'valid_axes': vaxes, 'provenance': {'kind': kind, 'method': method}, |
| 'source_locator': source, **extra} |
|
|
|
|
| def source_index(root): |
| path = root / 'sources.jsonl' |
| if not path.exists(): |
| raise ValueError('Missing sources.jsonl; run acquire.py first or create a provenance inventory as documented') |
| result = {} |
| for line in path.read_text().splitlines(): |
| row = json.loads(line) |
| if row['path'] in result: |
| raise ValueError(f'Duplicate source path: {row["path"]}') |
| safe_path(root, row['path']) |
| result[row['path']] = row |
| return result |
|
|
|
|
| @lru_cache(maxsize=64) |
| def source_digest(path, size, mtime_ns): |
| return sha(path) |
|
|
|
|
| def locator(path, root, index): |
| key = path.relative_to(root).as_posix() |
| row = index.get(key) |
| if row is None: |
| raise ValueError(f'Missing provenance for {key}; add it to sources.jsonl') |
| stat = path.stat() |
| if source_digest(path, stat.st_size, stat.st_mtime_ns) != row['sha256']: |
| raise ValueError(f'Source changed: {path}') |
| return dict(row['source_locator'], extracted_path=key, extracted_sha256=row['sha256']) |
|
|
|
|
| @lru_cache(maxsize=128) |
| def find_one(root, name): |
| matches = [p for p in root.rglob(name) if p.is_dir()] |
| if len(matches) != 1: |
| raise ValueError(f'Expected one {name}/ directory, found {len(matches)}') |
| return matches[0] |
|
|
|
|
| def inventory_ego(root): |
| rows = [] |
| for split in ('train', 'val', 'test_indomain', 'test_outdomain'): |
| d = find_one(root, split) |
| images = sorted(p for p in (d / 'image').iterdir() if p.suffix.lower() in ('.jpg', '.jpeg', '.png')) |
| for p in images: |
| label = d / 'label' / (p.stem + '.png') |
| if not label.is_file(): |
| raise ValueError(f'Image without segmentation: {p}') |
| rows.append({'image': p, 'mask': label, 'split': 'test' if split.startswith('test_') else split, |
| 'source_split': split, 'camera_id': 'ego', 'sample_id': split + '/' + p.name}) |
| if not rows: |
| raise ValueError('No EgoHOS images') |
| return rows |
|
|
|
|
| def inventory_oak(root, annotations, split_scheme): |
| stream = find_one(root, 'stream_release_v2') |
| rows = [] |
| if annotations: |
| info = load(annotations / 'seq_all.json') |
| splits = {} |
| for split in ('train', 'val', 'test'): |
| relative = (f'split_train_val/{split_scheme}/example_split_{split}.json' if split != 'test' |
| else f'split/{split_scheme}/seq_test.json') |
| file = annotations / relative |
| if not file.is_file(): |
| raise ValueError(f'Official split missing: {file}') |
| for x in load(file): |
| key = tuple(x) |
| if key in splits: |
| raise ValueError('Conflicting official splits') |
| splits[key] = (split, relative) |
| for x in info: |
| seq, subject, frame, camera = x |
| if camera not in range(4) or subject not in (0, 1): |
| raise ValueError(f'Unexpected official sample key: {x}') |
| name = '__'.join(map(str, x)).replace('/', '__') |
| split, split_ref = splits.get(tuple(x), ('unknown', None)) |
| rows.append({'image': stream / seq / f'{CAMS[camera]}_{frame}.png', |
| 'camera_id': CAMS[camera], 'sequence': seq, 'source_frame_id': str(frame), |
| 'sample_id': name, 'subject': subject, 'split': split, 'source_split': split, |
| 'annotation_key': name, 'split_ref': split_ref}) |
| else: |
| for p in sorted(stream.rglob('*.png')): |
| m = re.fullmatch(r'(north_east|south_east|north_west|south_west)_color_(\d+)', p.stem) |
| if not m or len(p.relative_to(stream).parts) != 3: |
| raise ValueError(f'Unexpected OakInk image path: {p}') |
| rows.append({'image': p, 'camera_id': m[1] + '_color', |
| 'sequence': p.parent.relative_to(stream).as_posix(), 'source_frame_id': m[2], |
| 'sample_id': p.relative_to(stream).as_posix(), 'subject': None, |
| 'split': 'unknown', 'source_split': 'unknown'}) |
| if not rows: |
| raise ValueError('No OakInk images') |
| return rows |
|
|
|
|
| def select_rows(rows, dataset, phase, count, seed): |
| if phase == 'full': |
| return rows |
| strata = defaultdict(list) |
| for r in rows: |
| strata[r['source_split'] if dataset == 'EgoHOS' else (r['split'], r['camera_id'])].append(r) |
| rng = random.Random(seed) |
| return [r for key in sorted(strata) for r in rng.sample(strata[key], min(count, len(strata[key])))] |
|
|
|
|
| def groups(rows, dataset, chunk): |
| buckets = defaultdict(list) |
| for r in rows: |
| with Image.open(r['image']) as im: |
| size = im.size |
| if dataset == 'EgoHOS': |
| key = (r['source_split'], r['camera_id'], size) |
| else: |
| |
| key = (r['sequence'], r['subject'], int(r['source_frame_id']) // chunk, r['camera_id'], size) |
| buckets[key].append(r) |
| result = [] |
| for key in sorted(buckets, key=str): |
| batch = sorted(buckets[key], key=lambda r: (int(r.get('source_frame_id', 0)), r['sample_id'])) |
| if dataset == 'EgoHOS': |
| for start in range(0, len(batch), chunk): |
| sequence = f'{key[0]}_{key[2][0]}x{key[2][1]}_{start//chunk:06d}' |
| result.append((sequence, key[1], key[2], batch[start:start+chunk])) |
| else: |
| name = key[0].replace('/', '__') |
| person = '' if key[1] is None else f'__person{key[1]}' |
| sequence = f'{name}{person}__window{key[2]:06d}_{key[4][0]}x{key[4][1]}' |
| result.append((sequence, key[3], key[4], batch)) |
| return result |
|
|
|
|
| def read_pickle(path): |
| |
| with path.open('rb') as f: |
| return pickle.load(f) |
|
|
|
|
| def numeric(value, shape, name): |
| if isinstance(value, torch.Tensor): |
| value = value.detach().cpu().numpy() |
| a = np.asarray(value, dtype=np.float32) |
| if a.shape != shape or not np.isfinite(a).all(): |
| raise ValueError(f'{name}: expected finite {shape}, got {a.shape}') |
| return a |
|
|
|
|
| def se3(value, name): |
| a = numeric(value, (4, 4), name) |
| if not (np.allclose(a[3], [0, 0, 0, 1], atol=1e-5) and |
| np.allclose(a[:3, :3].T @ a[:3, :3], np.eye(3), atol=1e-4) and |
| np.isclose(np.linalg.det(a[:3, :3]), 1, atol=1e-4)): |
| raise ValueError(f'Invalid rigid transform: {name}') |
| return a |
|
|
|
|
| def copy_mesh(source, dst, root, index): |
| lines = source.read_text().splitlines() |
| materials = [n for line in lines if line.startswith('mtllib ') for n in shlex.split(line)[1:]] |
| missing_materials = [n for n in materials if not safe_path(source.parent, n).is_file()] |
| if missing_materials and len(missing_materials) != len(materials): |
| raise ValueError(f'Partly missing OBJ materials need review: {source}: {missing_materials}') |
| |
| if missing_materials: |
| lines = [line for line in lines if not line.startswith(('mtllib ', 'usemtl '))] |
| vertices = np.array([[float(v) for v in line.split()[1:4]] for line in lines if line.startswith('v ')]) |
| if vertices.ndim != 2 or vertices.shape[1] != 3 or not np.isfinite(vertices).all(): |
| raise ValueError(f'Invalid OBJ: {source}') |
| center = (vertices.min(0) + vertices.max(0)) / 2 |
| shifted = iter(vertices - center) |
| output = [] |
| for line in lines: |
| if line.startswith('v '): |
| v = next(shifted) |
| line = 'v ' + ' '.join(format(x, '.12g') for x in v) + (' ' + ' '.join(line.split()[4:]) if len(line.split()) > 4 else '') |
| output.append(line) |
| dst.parent.mkdir(parents=True, exist_ok=True) |
| dst.write_text('\n'.join(output) + '\n') |
| sources = [locator(source, root, index)] |
| for line in lines: |
| if line.startswith('mtllib '): |
| for name in shlex.split(line)[1:]: |
| mtl = safe_path(source.parent, name) |
| dest = safe_path(dst.parent, name) |
| dest.parent.mkdir(parents=True, exist_ok=True) |
| shutil.copy2(mtl, dest) |
| sources.append(locator(mtl, root, index)) |
| for entry in mtl.read_text().splitlines(): |
| if entry.strip().startswith(('map_', 'bump ', 'disp ', 'decal ', 'norm ')): |
| texture = shlex.split(entry)[-1] |
| src = safe_path(mtl.parent, texture) |
| to = safe_path(dest.parent, texture) |
| to.parent.mkdir(parents=True, exist_ok=True) |
| shutil.copy2(src, to) |
| sources.append(locator(src, root, index)) |
| return center.tolist(), sources, missing_materials |
|
|
|
|
| def oak_object_asset(view, rows, meta, root, index): |
| objid = rows[0]['sequence'].split('/')[0].split('_')[0] |
| mesh = find_one(root, 'obj') / (objid + '.obj') |
| ref = f'annotation/object/{objid}/assets/{objid}.obj' |
| center, sources, missing_materials = copy_mesh(mesh, view / ref, root, index) |
| meta['components']['object_mesh'] = {'available': True, 'schema_id': 'mesh/obj/v1', 'data_ref': ref, |
| 'axes': [], 'valid': True, 'unit': 'm', 'source_locator': sources, |
| 'provenance': {'kind': 'format_conversion', 'method': 'subtract (min(vertices)+max(vertices))/2, official oikit load_object; remove dangling material bindings only if all referenced MTL files are absent in source', |
| 'subtracted_center': center, 'source_missing_materials': missing_materials}} |
| dump(view / f'annotation/object/{objid}/metainfo.json', {'object_id': objid, 'identity_scope': 'sequence', |
| 'scope_id': meta['sequence_id'], 'source_object_id': objid, 'has_model': True, |
| 'mesh_ref': ref, 'source_locator': sources, 'association_basis': 'official sequence prefix object ID'}) |
|
|
|
|
| def oak_geometry(view, rows, frames, meta, root, index, anno, split_scheme): |
| count = len(rows) |
| keys = [r['annotation_key'] for r in rows] |
| arrays = {'intrinsic': [], 'extrinsic': [], 'xyz': [], 'pose': []} |
| objid = rows[0]['sequence'].split('/')[0].split('_')[0] |
| for i, key in enumerate(keys): |
| sources = {} |
| for name in ('cam_intr', 'hand_j', 'general_info', 'obj_transf'): |
| p = anno / name / (key + '.pkl') |
| |
| if name == 'obj_transf' and not p.exists(): |
| p = anno / 'obj_trasnf' / (key + '.pkl') |
| sources[name] = locator(p, root, index) |
| sources[name]['record'] = key |
| value = read_pickle(p) |
| if name == 'cam_intr': |
| k = numeric(value, (3, 3), name) |
| if not np.allclose(k[2], [0, 0, 1]) or min(k[0, 0], k[1, 1]) <= 0: |
| raise ValueError('Invalid pinhole K') |
| arrays['intrinsic'].append(k) |
| elif name == 'hand_j': |
| arrays['xyz'].append(numeric(value, (21, 3), name)) |
| elif name == 'obj_transf': |
| arrays['pose'].append(se3(value, name)) |
| else: |
| arrays['extrinsic'].append(se3(value['cam_extr'], 'T_camera_from_world')) |
| frames[i]['annotation_sources'] = sources |
| frames[i]['source_subject_flag'] = rows[i]['subject'] |
| if rows[i]['split_ref']: |
| frames[i]['split_source_locator'] = locator(anno / rows[i]['split_ref'], root, index) |
| frames[i]['annotation_matches'] = {name: {'source_frame_id': key, 'source_timestamp_ns': None, |
| 'clock_domain': None, 'match_method': 'index_map', 'delta_ns': None} for name in sources} |
| arrays = {k: np.stack(v) for k, v in arrays.items()} |
| xyz = np.full((count, 2, 21, 3), np.nan, np.float32) |
| xyz[:, 1] = arrays['xyz'] |
| valid = np.zeros((count, 2, 21), bool) |
| valid[:, 1] = True |
| uv = np.full((count, 2, 21, 2), np.nan, np.float32) |
| homogeneous = np.einsum('tij,tkj->tki', arrays['intrinsic'], arrays['xyz']) |
| projectable = homogeneous[:, :, 2] > 0 |
| uv[:, 1][projectable] = (homogeneous[:, :, :2][projectable] / homogeneous[:, :, 2:][projectable]) |
| uv_valid = valid.copy() |
| uv_valid[:, 1] &= projectable |
| common_source = {'file': 'camera/frames.jsonl', 'fields': ['annotation_sources'], 'records': 'all frame_index rows'} |
| policy = {'rule': 'source present AND finite/numerical checks; no additional official QA input', |
| 'scope': 'per joint for keypoints; per frame for camera/pose', |
| 'official_split_is_not_visibility': True, 'local_excluded_frame_indices': []} |
| specs = [('intrinsic', 'camera/pinhole/v1', 'camera/intrinsic.pt', arrays['intrinsic'], np.ones(count, bool), ['T', 3, 3]), |
| ('extrinsic', 'transform/se3/v1', 'camera/extrinsic.pt', arrays['extrinsic'], np.ones(count, bool), ['T', 4, 4]), |
| ('keypoints_xyz', 'keypoints/xyz/v1', 'annotation/keypoints/xyz.pt', xyz, valid, ['T', 'hand', 'keypoint', 'xyz']), |
| ('keypoints_uv', 'keypoints/uv/v1', 'annotation/keypoints/uv.pt', uv, uv_valid, ['T', 'hand', 'keypoint', 'uv']), |
| ('object_pose', 'object/rigid/v1', f'annotation/object/{objid}/pose.pt', arrays['pose'], np.ones(count, bool), ['T', 4, 4])] |
| for name, schema, ref, data, ok, axes in specs: |
| vref = ref.replace('.pt', '_valid.pt') |
| tensor(view, ref, data) |
| tensor(view, vref, ok) |
| extra = {'valid_policy': policy} |
| if name.startswith('keypoints'): |
| extra.update(keypoint_schema='mano21/v1', coordinate_frame='camera', |
| unit='pixel' if name.endswith('uv') else 'm') |
| if name in ('extrinsic', 'object_pose'): |
| extra.update(unit='m', convention='T_camera_from_world' if name == 'extrinsic' else 'T_camera_from_object') |
| meta['components'][name] = component(schema, ref, axes, vref, ['T', 'hand', 'keypoint'] if ok.ndim == 3 else ['T'], |
| common_source, 'K @ official camera-space hand_j; positive Z only' if name.endswith('uv') else 'official per-sample array, float32; right-hand slot 1', |
| kind='derived' if name.endswith('uv') else 'format_conversion', **extra) |
| oak_object_asset(view, rows, meta, root, index) |
| meta['camera'].update(model='pinhole', schema_id='camera/pinhole/v1') |
| meta.update(split_scheme=split_scheme, split_source_locator={'file': 'camera/frames.jsonl', 'field': 'split_source_locator'}) |
|
|
|
|
| def build_view(out, seq, cam, size, rows, args, index): |
| view = out / 'data' / seq / cam |
| view.mkdir(parents=True) |
| frames = [] |
| for i, r in enumerate(rows): |
| src = locator(r['image'], args.input, index) |
| frames.append({'frame_index': i, 'sample_id': r['sample_id'], 'source_frame_id': r.get('source_frame_id', r['image'].name), |
| 'timestamp_ns': None, 'clock_domain': None, 'source_locator': src, |
| 'split': r['split'], 'source_split': r['source_split']}) |
| if 'mask' in r: |
| frames[-1]['mask_source_locator'] = locator(r['mask'], args.input, index) |
| source_ref = {'file': 'camera/frames.jsonl', 'field': 'source_locator', 'records': 'all frame_index rows'} |
| count = len(rows) |
| storage, proof = encode([r['image'] for r in rows], view / 'observation/rgb.mkv') |
| tensor(view, 'observation/rgb_valid.pt', np.ones(count, bool)) |
| comps = {'rgb': component('rgb/uint8/v1', 'observation/rgb.mkv', ['T', 'height', 'width', 'RGB'], |
| 'observation/rgb_valid.pt', ['T'], source_ref, 'exact source JPEG remux or exact RGB round-trip re-encoding', storage=storage)} |
| ego = args.dataset == 'EgoHOS' |
| meta = {'schema_version': SCHEMA_VERSION, 'dataset_id': args.dataset, 'release_id': RELEASE_ID, |
| 'sequence_id': seq, 'camera_id': cam, 'sample_type': 'image' if ego else 'video', |
| 'num_frames': count, 'hand_slots': ['left', 'right'], 'view_type': 'ego' if ego else 'exo', |
| 'split': rows[0]['split'] if len({r['split'] for r in rows}) == 1 else 'unknown', |
| 'sampling': {'type': ('single' if count == 1 else 'independent') if ego else 'sparse', |
| 'source_fps': None, 'frames_ref': 'camera/frames.jsonl', 'strategy': args.phase, |
| 'seed': args.seed, 'timestamps': 'unknown; no timestamps inferred from filenames or MKV PTS'}, |
| 'camera': {'model': 'unknown', 'schema_id': None, 'image_size': list(size)}, 'components': comps} |
| proofs = {'rgb': proof} |
| missing = {'depth': 'not provided by selected source image release', |
| 'mano': 'not exported: model profile/flat-hand-mean/translation conversion not empirically verified', |
| 'visibility': 'no independent source visibility input; never inferred from valid', |
| 'contact': 'no verified per-entity or vertex contact annotations in selected input'} |
| if ego: |
| meta.update(split_scheme='EgoHOS-official-four-directories', split_source_locator=source_ref) |
| storage, proofs['segment'] = encode([r['mask'] for r in rows], view / 'annotation/segment/mask.mkv', labels=True) |
| tensor(view, 'annotation/segment/mask_valid.pt', np.ones(count, bool)) |
| labels = [{'mask_value': 9 if i == 0 else i, 'category_id': name, |
| 'entity_id': 'hand_left' if i == 1 else 'hand_right' if i == 2 else None, |
| 'part_id': None, 'source_instance_id': None, 'source_attributes': {'source_class_id': i}} |
| for i, name in enumerate(LABELS)] |
| jsonl(view / 'annotation/segment/instances.jsonl', [{'frame_index': i, 'labels': labels} for i in range(count)]) |
| comps['segment'] = component('segment/uint16_labels/v1', 'annotation/segment/mask.mkv', ['T', 'height', 'width'], |
| 'annotation/segment/mask_valid.pt', ['T'], {'file': 'camera/frames.jsonl', 'field': 'mask_source_locator'}, |
| 'source 0 background -> 9; 1..8 unchanged; exact uint16 round-trip', |
| storage=storage, segmentation_type='semantic', mapping_ref='annotation/segment/instances.jsonl', |
| coverage={'kind': 'partial', 'meaning': 'hands and selected interacting object categories; background is source task background, not exhaustive object annotation'}, |
| valid_policy={'rule': 'paired source label exists, shape and integer categories verified; no additional official QA supplied', 'local_excluded_frame_indices': []}) |
| missing.update(intrinsic='source calibration absent', extrinsic='source calibration absent', |
| keypoints='source keypoints absent', object='semantic classes do not establish instance identity/mesh/pose', |
| contact='raw package lacks contact/; interaction-order categories are not per-entity contact labels') |
| elif args.annotations: |
| oak_geometry(view, rows, frames, meta, args.input, index, args.annotations, args.split_scheme) |
| else: |
| missing.update(intrinsic='anno_v2_1.zip missing', extrinsic='anno_v2_1.zip missing', |
| keypoints='anno_v2_1.zip missing', object_pose='anno_v2_1.zip missing; canonical mesh does not establish camera-space pose') |
| if args.object_assets_present: |
| oak_object_asset(view, rows, meta, args.input, index) |
| else: |
| missing['object_mesh'] = 'image/obj.zip exists upstream but has not been downloaded/extracted into this input' |
| meta['split_reason'] = 'official split files are in missing anno_v2_1.zip; unknown is not a new split' |
| for name, reason in missing.items(): |
| comps[name] = {'available': False, 'reason': reason} |
| jsonl(view / 'camera/frames.jsonl', frames) |
| dump(view / 'metainfo.json', meta) |
| dump(view / 'encoding_validation.json', proofs) |
| return view.relative_to(out).as_posix() |
|
|
|
|
| def recipe(args): |
| names = ['preprocess.py', 'media.py', 'validate.py', 'acquire.py', 'schema.json', 'CONTRACT.md'] |
| return {'dataset': args.dataset, 'chunk': args.chunk, 'seed': args.seed, |
| 'annotations': bool(args.annotations), 'split_scheme': args.split_scheme, |
| 'code_sha256': {n: sha(HERE / n) for n in names}} |
|
|
|
|
| def approve(root, reviewer): |
| from validate import check_inventory |
| report = root / 'doc/validation/report.json' |
| d = load(report) |
| check_inventory(root, d['file_hashes']) |
| if not reviewer.strip() or not d['automatic_validation_passed']: |
| raise ValueError('Reviewer and passing automatic checks required') |
| |
| dump(root / 'doc/validation/human_review.json', {'reviewer': reviewer, 'phase': d['phase'], |
| 'report_sha256': sha(report), 'recipe': d['recipe'], 'approved': True, |
| 'statement': 'I inspected the listed HTML sample IDs and accept the documented scope and limitations.'}) |
|
|
|
|
| def require_review(root): |
| from validate import check_inventory |
| report = root / 'doc/validation/report.json' |
| reviewed = load(root / 'doc/validation/human_review.json') |
| if not reviewed.get('approved') or reviewed['report_sha256'] != sha(report): |
| raise ValueError('Missing/stale human review; inspect HTML and run approve') |
| result = load(report) |
| check_inventory(root, result['file_hashes']) |
| return result |
|
|
|
|
| def run(args): |
| if args.dataset != "EgoHOS": |
| raise ValueError("This v1.1 builder supports EgoHOS only; OakInk numeric bundles are not adapted here") |
| if args.dataset == 'OakInk-v1' and not args.annotations and not args.allow_rgb_only: |
| raise ValueError('OakInk annotations absent. Supply --annotations + --trust-pickle, or explicitly select --allow-rgb-only (limited scope).') |
| if args.annotations and (not args.trust_pickle or not args.annotations.resolve().is_relative_to(args.input.resolve())): |
| raise ValueError('--annotations must be under --input and requires --trust-pickle; pickle can execute code') |
| if args.out.exists(): |
| raise ValueError('Output exists; choose a fresh directory. Incomplete output is never reused as a release.') |
| expected = recipe(args) |
| if args.phase == 'full': |
| if not args.pilot: |
| raise ValueError('Full processing requires --pilot with a human review') |
| reviewed = require_review(args.pilot) |
| if reviewed['phase'] != 'pilot' or reviewed['recipe'] != expected: |
| raise ValueError('Pilot recipe does not match; re-run and review pilot after code/config changes') |
| acquisition = args.input / 'acquisition.json' |
| if not acquisition.exists() or load(acquisition).get('command') != 'extract' or load(acquisition).get('dataset') != args.dataset: |
| raise ValueError('Full processing requires complete, verified acquire.py extract input, not a partial pilot download') |
| index = source_index(args.input) |
| args.object_assets_present = any(p.is_dir() for p in args.input.rglob('obj')) if args.dataset == 'OakInk-v1' else False |
| if args.phase == 'full': |
| for pf in (args.pilot / 'data').glob('*/*/camera/frames.jsonl'): |
| for line in pf.read_text().splitlines(): |
| f = json.loads(line) |
| for field in ('source_locator', 'mask_source_locator'): |
| if field in f: |
| old = f[field] |
| current = index.get(old['extracted_path']) |
| if current is None or current['sha256'] != old['extracted_sha256']: |
| raise ValueError('Full input differs from reviewed pilot source samples') |
| rows = inventory_ego(args.input) if args.dataset == 'EgoHOS' else inventory_oak(args.input, args.annotations, args.split_scheme) |
| if args.phase == 'full' and args.dataset == 'EgoHOS': |
| expected_counts = dict(train=8993, val=1124, test_indomain=1126, test_outdomain=500) |
| actual_counts = {s: sum(r['source_split'] == s for r in rows) for s in expected_counts} |
| if actual_counts != expected_counts: |
| raise ValueError(f'Incomplete/wrong EgoHOS full inventory: {actual_counts}; expected {expected_counts}') |
| ids = [r['sample_id'] for r in rows] |
| if len(set(ids)) != len(ids): |
| raise ValueError('Duplicate sample IDs') |
| selected = select_rows(rows, args.dataset, args.phase, args.per_stratum, args.seed) |
| plan = groups(selected, args.dataset, args.chunk) |
| raw_bytes = sum(r['image'].stat().st_size for r in selected) |
| |
| estimated = max(raw_bytes * 4, max(w*h*len(rs)*8 for _, _, (w, h), rs in plan)) + 1024**3 |
| args.out.parent.mkdir(parents=True, exist_ok=True) |
| if shutil.disk_usage(args.out.parent).free < estimated: |
| raise ValueError(f'Estimated working/output space {estimated/1e9:.1f} GB exceeds free space') |
| args.out.mkdir() |
| (args.out / 'script').mkdir() |
| (args.out / 'doc').mkdir() |
| for p in HERE.glob('*.py'): |
| shutil.copy2(p, args.out / 'script' / p.name) |
| for name in ['schema.json', 'CONTRACT.md', 'requirements.txt', 'README.md', |
| 'EgoHOS_DATA_MAPPING.md', 'OakInk-v1_DATA_MAPPING.md']: |
| shutil.copy2(HERE / name, args.out / 'script' / name) |
| shutil.copytree(HERE / 'source_evidence', args.out / 'script/source_evidence') |
| for name in ['schema.json', 'CONTRACT.md']: |
| shutil.copy2(HERE / name, args.out / 'doc' / name) |
| mapping = HERE / f'{args.dataset}_DATA_MAPPING.md' |
| for name in ['DATA_MAPPING.md', 'RAW_TO_SHARED.md']: |
| shutil.copy2(mapping, args.out / 'doc' / name) |
| shutil.copy2(HERE / 'README.md', args.out / 'doc/RUNBOOK.md') |
| views = [] |
| for i, (seq, cam, size, batch) in enumerate(plan): |
| if shutil.disk_usage(args.out).free < size[0]*size[1]*len(batch)*8 + 512*1024**2: |
| raise RuntimeError('Low disk; stopped before next view, output remains incomplete') |
| views.append(build_view(args.out, seq, cam, size, batch, args, index)) |
| print(f'{i+1}/{len(plan)} {seq}/{cam} T={len(batch)}', flush=True) |
| manifest = {'dataset': args.dataset, 'phase': args.phase, 'recipe': expected, |
| 'inventory_samples': len(rows), 'selected_samples': len(selected), 'views': views, |
| 'input_sources_sha256': sha(args.input / 'sources.jsonl'), |
| 'sample_selection': {'seed': args.seed, 'per_stratum': args.per_stratum, 'pilot_strata': 'official source split or split x camera'}, |
| 'source_inventory': {'sample_ids_sha256': hashlib.sha256('\n'.join(sorted(ids)).encode()).hexdigest()}, |
| 'human_status': 'pending', 'command': sys.argv, |
| 'limitations': ['OakInk MANO conversion not implemented until model-profile and translation parity verified', |
| 'OakInk-Shape/OakBase excluded: object-space grasp/knowledge assets are not synchronized camera observations', |
| 'No source visibility/contact guessed from geometry or masks']} |
| if args.phase == 'full': |
| shutil.copy2(args.pilot / 'doc/validation/human_review.json', args.out / 'doc/pilot_human_review.json') |
| dump(args.out / 'doc/build.json', manifest) |
| from validate import validate_release |
| validate_release(args.out, args.per_stratum, args.seed, source_root=args.input) |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser(description=__doc__) |
| sub = p.add_subparsers(dest='command', required=True) |
| b = sub.add_parser('build') |
| b.add_argument('--dataset', choices=['EgoHOS', 'OakInk-v1'], required=True) |
| b.add_argument('--input', type=Path, required=True) |
| b.add_argument('--out', type=Path, required=True) |
| b.add_argument('--phase', choices=['pilot', 'full'], default='pilot') |
| b.add_argument('--pilot', type=Path) |
| b.add_argument('--chunk', type=int, default=128) |
| b.add_argument('--per-stratum', type=int, default=4) |
| b.add_argument('--seed', type=int, default=20260928) |
| b.add_argument('--annotations', type=Path) |
| b.add_argument('--split-scheme', choices=['split0', 'split1', 'split2', 'split0_ho'], default='split0') |
| b.add_argument('--trust-pickle', action='store_true') |
| b.add_argument('--allow-rgb-only', action='store_true') |
| a = sub.add_parser('approve', help='Human review record; never run automatically') |
| a.add_argument('--release', type=Path, required=True) |
| a.add_argument('--reviewer', required=True) |
| u = sub.add_parser('upload', help='Upload reviewed FULL release to the requested raw repository') |
| u.add_argument('--release', type=Path, required=True) |
| args = p.parse_args() |
| if args.command == 'build': |
| if args.chunk < 1 or args.per_stratum < 1: |
| p.error('chunk and per-stratum must be positive') |
| run(args) |
| elif args.command == 'approve': |
| approve(args.release, args.reviewer) |
| else: |
| from validate import check_inventory |
| d = load(args.release / 'doc/validation/report.json') |
| if d['dataset'] != 'EgoHOS': |
| raise ValueError('This v1.1 uploader supports EgoHOS only') |
| d = require_review(args.release) |
| if d['phase'] != 'full': |
| raise ValueError(f'Pilot releases cannot be uploaded as {RELEASE_ID}') |
| check_inventory(args.release, d['file_hashes']) |
| from huggingface_hub import HfApi |
| target = f'{d["dataset"]}/{RELEASE_ID}' |
| api = HfApi() |
| |
| existing = api.list_repo_files('ParityLab/Hand-Datasets-Raw', repo_type='dataset') |
| if any(x.startswith(target + '/') for x in existing): |
| raise ValueError(f'Remote {target} already exists; publish a new version or review replacement separately') |
| from huggingface_hub import CommitOperationAdd |
| files = sorted((p for p in args.release.rglob('*') if p.is_file() and '__pycache__' not in p.parts), |
| key=lambda p: (p.relative_to(args.release).parts[0] == 'doc', p.as_posix())) |
| |
| for start in range(0, len(files), 128): |
| operations = [CommitOperationAdd(path_in_repo=target + '/' + f.relative_to(args.release).as_posix(), |
| path_or_fileobj=f) for f in files[start:start+128]] |
| result = api.create_commit(repo_id='ParityLab/Hand-Datasets-Raw', repo_type='dataset', |
| operations=operations, commit_message=f'Add reviewed {target} files {start+1}-{min(start+128, len(files))}') |
| print(result, flush=True) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
