| |
| """Validate all shared frames; render capped samples of every available modality.""" |
| import argparse |
| from collections import defaultdict |
| import hashlib |
| import html |
| import json |
| import random |
| from pathlib import Path |
|
|
| import numpy as np |
| from PIL import Image, ImageDraw |
| import torch |
|
|
| from acquire import sha |
| from media import decode, rgb |
|
|
| COLORS = [(0, 0, 0), (255, 70, 80), (50, 150, 255), (255, 180, 40), (80, 220, 100), |
| (220, 80, 220), (140, 90, 40), (40, 220, 220), (150, 150, 255), (70, 70, 70)] |
| EDGES = [(0, i) for i in (1, 5, 9, 13, 17)] + [(i, i+1) for i in range(1, 21) if i % 4 != 0] |
|
|
|
|
| def read_json(path): |
| return json.loads(path.read_text()) |
|
|
|
|
| def read_jsonl(path): |
| return [json.loads(line) for line in path.read_text().splitlines()] |
|
|
|
|
| def pt(path): |
| t = torch.load(path, map_location='cpu', weights_only=True) |
| if not isinstance(t, torch.Tensor) or t.device.type != 'cpu': |
| raise ValueError(f'Expected CPU Tensor: {path}') |
| return t.numpy() |
|
|
|
|
| def local_ref(view, ref): |
| p = view / ref |
| if not p.resolve().is_relative_to(view.resolve()) or not p.is_file(): |
| raise ValueError(f'Broken/unsafe reference: {ref}') |
| return p |
|
|
|
|
| def check_inventory(root, expected): |
| actual = {p.relative_to(root).as_posix(): sha(p) for p in root.rglob('*') if p.is_file() and '__pycache__' not in p.parts |
| and p.relative_to(root).as_posix() not in ('doc/validation/report.json', 'doc/validation/human_review.json')} |
| if actual != expected: |
| raise ValueError('Release contents changed after validation; revalidate and repeat human review') |
|
|
|
|
| def validate_view(view, registry): |
| m = read_json(view / 'metainfo.json') |
| if m.get('dataset_id') != 'EgoHOS': |
| raise ValueError('This v1.1 validator supports EgoHOS only') |
| frames = read_jsonl(view / 'camera/frames.jsonl') |
| t = m['num_frames'] |
| if t < 1 or m['hand_slots'] != ['left', 'right'] or len(frames) != t: |
| raise ValueError('Frame count/hand-slot error') |
| required = registry['view_metadata']['required_fields'] |
| if [k for k in required if k not in m]: |
| raise ValueError(f'Missing required view metadata fields: {[k for k in required if k not in m]}') |
| if (m['schema_version'] != registry['view_metadata']['schema_version'] |
| or m['release_id'] != registry['release_layout']['release_id']): |
| raise ValueError(f"Invalid schema/release version: {m['schema_version']}/{m['release_id']}") |
| if m['view_type'] not in registry['view_metadata']['view_type_values']: |
| raise ValueError('Invalid view_type') |
| if [r['frame_index'] for r in frames] != list(range(t)) or len({r['sample_id'] for r in frames}) != t: |
| raise ValueError('Invalid/duplicate frame IDs') |
| for f in frames: |
| for key in ['timestamp_ns', 'clock_domain', 'source_locator', 'source_frame_id']: |
| if key not in f: |
| raise ValueError(f'Missing frame field {key}') |
| proofs = read_json(view / 'encoding_validation.json') |
| for name, c in m['components'].items(): |
| if not c['available']: |
| if not c.get('reason'): |
| raise ValueError('Missing unavailable reason') |
| continue |
| schema = registry['components'][c['schema_id']] |
| data = local_ref(view, c['data_ref']) |
| valid = pt(local_ref(view, c['valid_ref'])) if 'valid_ref' in c else None |
| if valid is not None and valid.dtype != bool: |
| raise ValueError('Validity must be bool') |
| if 'valid_shape' in schema and valid is not None: |
| shape = tuple(t if x == 'T' else x for x in schema['valid_shape']) |
| if valid.shape != shape: |
| raise ValueError(f'{name} valid shape {valid.shape} != {shape}') |
| if data.suffix == '.pt': |
| a = pt(data) |
| shape = tuple(t if x == 'T' else x for x in schema['shape']) |
| if a.shape != shape or a.dtype != np.dtype(schema['dtype']): |
| raise ValueError(f'{name} tensor shape/dtype mismatch') |
| ok = np.broadcast_to(valid.reshape(valid.shape + (1,)*(a.ndim-valid.ndim)), a.shape) |
| if not np.isfinite(a[ok]).all() or not np.isnan(a[~ok]).all(): |
| raise ValueError(f'{name}: finite valid / NaN invalid policy failed') |
| if c['schema_id'] in ('object/rigid/v1', 'transform/se3/v1'): |
| r = a[valid, :3, :3] |
| if not (np.allclose(np.swapaxes(r, 1, 2) @ r, np.eye(3), atol=1e-4) and np.allclose(np.linalg.det(r), 1, atol=1e-4)): |
| raise ValueError('SE3 check failed') |
| elif data.suffix == '.mkv': |
| storage = c['storage'] |
| if storage['profile'] not in schema['allowed_storage_profiles']: |
| raise ValueError('Unregistered storage profile') |
| for required in registry['video_metadata']['required']: |
| if required not in storage: |
| raise ValueError(f'Missing storage field {required}') |
| chosen = next(x for x in proofs[name]['candidates'] if x['encoder'] == proofs[name]['selected']) |
| hashes = [] |
| mapping = read_jsonl(local_ref(view, c['mapping_ref'])) if name == 'segment' else None |
| if mapping is not None and (len(mapping) != t or [x['frame_index'] for x in mapping] != list(range(t))): |
| raise ValueError('Segmentation mapping timeline differs') |
| for i, a in enumerate(decode(data, name == 'segment')): |
| if list(a.shape[1::-1]) != m['camera']['image_size']: |
| raise ValueError('Video dimensions differ from camera') |
| hashes.append(hashlib.sha256(a.tobytes()).hexdigest()) |
| if mapping is not None: |
| codes = [x['mask_value'] for x in mapping[i]['labels']] |
| if len(codes) != len(set(codes)) or not set(np.unique(a)).difference((0, 65535)).issubset(codes): |
| raise ValueError('Invalid segment mapping') |
| if len(hashes) != t or hashes != chosen['ordered_decoded_sha256']: |
| raise ValueError('Video differs from exact source comparison proof') |
| elif data.suffix == '.obj': |
| if not any(line.startswith('v ') for line in data.read_text().splitlines()): |
| raise ValueError('Empty mesh') |
| return m, frames |
|
|
|
|
| def clean_numbers(x): |
| if isinstance(x, np.generic): |
| return clean_numbers(x.item()) |
| if isinstance(x, np.ndarray): |
| return clean_numbers(x.tolist()) |
| if isinstance(x, list): |
| return [clean_numbers(v) for v in x] |
| if isinstance(x, float) and not np.isfinite(x): |
| return None |
| return x |
|
|
|
|
| def preview_view(root, view, m, frames, target, source_root=None, selected_indices=None): |
| videos = {'rgb': decode(view / 'observation/rgb.mkv')} |
| c = m['components'] |
| if c.get('segment', {}).get('available'): |
| videos['segment'] = decode(view / c['segment']['data_ref'], True) |
| arrays = {name: pt(view / component['data_ref']) for name, component in c.items() |
| if component['available'] and component.get('data_ref', '').endswith('.pt')} |
| instances = read_jsonl(view / c['segment']['mapping_ref']) if 'segment' in videos else None |
| objects = [read_json(p) for p in (view / 'annotation/object').glob('*/metainfo.json')] |
| cards = [] |
| mesh = None |
| if c.get('object_mesh', {}).get('available'): |
| mesh = np.array([[float(v) for v in line.split()[1:4]] for line in (view / c['object_mesh']['data_ref']).read_text().splitlines() if line.startswith('v ')]) |
| |
| mesh = mesh[::max(1, len(mesh)//3000)] |
| for i, frame in enumerate(frames): |
| rgb_array = next(videos['rgb']) |
| current_mask = next(videos['segment']) if 'segment' in videos else None |
| if selected_indices is not None and i not in selected_indices: |
| continue |
| name = hashlib.sha256(f'{view.relative_to(root)}/{i}'.encode()).hexdigest()[:20] |
| image = Image.fromarray(rgb_array) |
| overlay = image.copy() |
| if 'segment' in videos: |
| mask = current_mask |
| color = np.asarray(COLORS, dtype=np.uint8)[mask] |
| mix = rgb_array.copy() |
| foreground = (mask != 9) & (mask != 0) |
| mix[foreground] = (rgb_array[foreground] * .45 + color[foreground] * .55).astype(np.uint8) |
| overlay = Image.fromarray(mix) |
| Image.fromarray(color).save(target / f'{name}-mask.png') |
| draw = ImageDraw.Draw(overlay) |
| if 'keypoints_uv' in arrays: |
| pts = arrays['keypoints_uv'][i, 1] |
| for a, b in EDGES: |
| if np.isfinite(pts[[a, b]]).all(): |
| draw.line([tuple(pts[a]), tuple(pts[b])], fill=(0, 255, 100), width=2) |
| for k, xy in enumerate(pts): |
| if np.isfinite(xy).all(): |
| x, y = xy |
| draw.ellipse((x-2, y-2, x+2, y+2), fill=(255, 50, 50)) |
| draw.text((x+3, y), str(k), fill=(255, 255, 255)) |
| objcam = None |
| if mesh is not None and 'object_pose' in arrays: |
| pose = arrays['object_pose'][i] |
| objcam = mesh @ pose[:3, :3].T + pose[:3, 3] |
| projected = objcam @ arrays['intrinsic'][i].T |
| for x, y, z in projected[projected[:, 2] > 0]: |
| draw.point((float(x/z), float(y/z)), fill=(255, 210, 0)) |
| image.save(target / f'{name}-rgb.png') |
| has_overlay = 'segment' in videos or 'keypoints_uv' in arrays or objcam is not None |
| if has_overlay: |
| overlay.save(target / f'{name}-overlay.png') |
| raw_ref = None |
| if source_root: |
| src = source_root / frame['source_locator']['extracted_path'] |
| if sha(src) != frame['source_locator']['extracted_sha256']: |
| raise ValueError('Preview source differs from build source') |
| Image.fromarray(rgb(src)).save(target / f'{name}-source.png') |
| raw_ref = f'{name}-source.png' |
| values = {key: clean_numbers(a[i]) for key, a in arrays.items()} |
| valid = {key: clean_numbers(pt(view / item['valid_ref'])[i]) for key, item in c.items() |
| if item['available'] and 'valid_ref' in item} |
| cards.append({'id': frame['sample_id'], 'view': view.relative_to(root).as_posix(), |
| 'rgb': f'{name}-rgb.png', 'overlay': f'{name}-overlay.png' if has_overlay else None, 'source': raw_ref, |
| 'mask': f'{name}-mask.png' if 'segment' in videos else None, |
| 'frame': frame, 'arrays': values, 'valid': valid, 'metainfo': m, |
| 'annotations': {'segment_instances': instances[i] if instances else None, 'object_metainfo': objects}, |
| 'object_points_camera': clean_numbers(objcam) if objcam is not None else None, |
| 'object_points_canonical': clean_numbers(mesh) if mesh is not None else None}) |
| return cards |
|
|
|
|
| HTML = '''<!doctype html><html lang="zh-CN"><meta charset="utf-8"><title>手物数据预处理检验</title> |
| <style>body{font:16px system-ui;margin:24px;background:#101724;color:#ecf3ff}button,select,input{font:inherit;padding:7px}h1{font-size:25px}a{color:#7bd5ff}.grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:16px}img{width:100%;background:#000}pre{white-space:pre-wrap;overflow-wrap:anywhere;font:13px monospace;max-height:420px;overflow:auto}figure{margin:0}figcaption{padding:6px}canvas{background:#162434;max-width:100%;touch-action:none}.warning{padding:14px;background:#493915}details{padding:10px;background:#1c293c;margin:10px 0}label{display:block;margin:10px 0}</style> |
| <h1>手物数据预处理检验</h1><p class="warning">待人工审核。自动无损校验通过 ≠ 标注语义或几何已获人工确认。只展示本报告列出的抽检样本；全量报告最多展示 192 帧。未提供模态及原因在元信息中明确列出。</p> |
| <p>检查：源图与解码 RGB、左右手、标签颜色、源文件定位、valid、相机参数；有几何时检查 2D 投影和可旋转 3D 点云。绿色为手关键点，黄色为物体。3D 点云仅为显示抽样，完整模型见 data。</p> |
| <label>样本 <select id="sample" aria-label="选择检验样本"></select></label><button id="prev">上一帧</button> <button id="next">下一帧</button><span id="counter"></span> |
| <h2 id="title"></h2><div class="grid"><figure><img id="source" alt="源 RGB"><figcaption>源文件固定解码 RGB</figcaption></figure><figure><img id="rgb" alt="处理后 RGB"><figcaption>shared MKV 解码 RGB</figcaption></figure><figure><img id="overlay" alt="分割或几何叠加"><figcaption>分割 / 手关键点 / 物体叠加</figcaption></figure><figure><img id="mask" alt="语义标签图"><figcaption>标签图：1 左手红；2 右手蓝；3–8 交互物体；9 源背景灰</figcaption></figure></div> |
| <section id="geometry"><p id="geometry-note"></p><div id="camera-geometry"><h2>相机系 3D（拖动旋转）</h2><canvas id="scene" width="700" height="460" aria-label="手物三维点云"></canvas></div><div id="canonical-geometry"><h2>物体规范坐标系 3D（拖动旋转）</h2><canvas id="canonical" width="700" height="460" aria-label="物体规范三维点云"></canvas></div></section> |
| <details open><summary>逐帧来源、时间与 split</summary><pre id="frame"></pre></details><details><summary>所有数值标注与有效性</summary><pre id="numbers"></pre></details><details><summary>所有组件 / 缺失原因 / 相机 / 存储与映射</summary><pre id="meta"></pre></details> |
| <script>const data=__DATA__;const $=x=>document.getElementById(x);let index=0,yaw=0,pitch=0; |
| data.forEach((d,i)=>{let o=document.createElement('option');o.value=i;o.textContent=d.id;$('sample').append(o)}); |
| function cloud(canvas,points,colors){let ctx=canvas.getContext('2d');ctx.clearRect(0,0,canvas.width,canvas.height);if(!points.length)return;let center=[0,1,2].map(k=>points.reduce((s,p)=>s+p[k],0)/points.length);let q=points.map(p=>p.map((v,k)=>v-center[k]));let scale=180/Math.max(.00001,...q.flat().map(Math.abs));q.forEach((p,i)=>{let x=p[0]*Math.cos(yaw)+p[2]*Math.sin(yaw),z=-p[0]*Math.sin(yaw)+p[2]*Math.cos(yaw),y=p[1]*Math.cos(pitch)-z*Math.sin(pitch);ctx.fillStyle=colors[i];ctx.fillRect(350+x*scale,230+y*scale,3,3)})} |
| function redraw(){let d=data[index],hand=(d.arrays.keypoints_xyz||[]).flat().filter(p=>p&&p.every(v=>v!==null)),obj=d.object_points_camera||[];cloud($('scene'),obj.concat(hand),obj.map(()=> '#ffd23f').concat(hand.map(()=> '#50ff9f')));let can=d.object_points_canonical||[];cloud($('canonical'),can,can.map(()=> '#ffd23f'))} |
| function show(){let d=data[index];$('sample').value=index;$('title').textContent=d.id;$('counter').textContent=` ${index+1} / ${data.length}`;for(let k of ['source','rgb','overlay','mask']){let el=$(k);el.parentElement.hidden=!d[k];if(d[k])el.src=d[k];}$('frame').textContent=JSON.stringify(d.frame,null,2);$('numbers').textContent=JSON.stringify({arrays:d.arrays,valid:d.valid,annotations:d.annotations},null,2);$('meta').textContent=JSON.stringify(d.metainfo,null,2);$('geometry').hidden=!d.object_points_camera&&!d.object_points_canonical&&!d.arrays.keypoints_xyz;$('camera-geometry').hidden=!d.object_points_camera&&!d.arrays.keypoints_xyz;$('canonical-geometry').hidden=!d.object_points_canonical;$('geometry-note').textContent=d.object_points_canonical&&!d.object_points_camera?'仅有静态物体模型；缺少内参/位姿，不生成相机系叠加。':'';redraw()} |
| $('sample').onchange=e=>{index=+e.target.value;show()};$('prev').onclick=()=>{index=(index+data.length-1)%data.length;show()};$('next').onclick=()=>{index=(index+1)%data.length;show()};for(let c of [$('scene'),$('canonical')]){let last=null;c.onpointerdown=e=>{last=[e.clientX,e.clientY];c.setPointerCapture(e.pointerId)};c.onpointerup=()=>last=null;c.onpointermove=e=>{if(last){yaw+=(e.clientX-last[0])*.01;pitch+=(e.clientY-last[1])*.01;last=[e.clientX,e.clientY];redraw()}}}show();</script></html>''' |
|
|
|
|
| def sampled_indices(count, wanted, seed): |
| if wanted >= count: |
| return set(range(count)) |
| fixed = {0, count - 1, count // 4, count // 2, 3 * count // 4} |
| rng = random.Random(seed) |
| remaining = [i for i in range(count) if i not in fixed] |
| fixed.update(rng.sample(remaining, wanted - len(fixed))) |
| return fixed |
|
|
|
|
| def check_release_versions(root, registry, build, versions): |
| """The release directory, every view's metainfo and the build recipe must agree.""" |
| if root.name != registry['release_layout']['directory']: |
| raise ValueError(f'Release directory {root.name!r} != registry ' |
| f"release_layout.directory {registry['release_layout']['directory']!r}") |
| if len(versions) != 1: |
| raise ValueError(f'Mixed schema/release versions across views: {sorted(versions)}') |
| version, release = next(iter(versions)) |
| if version != registry['schema_version'] or release != registry['release_layout']['release_id']: |
| raise ValueError(f'Views declare {version}/{release}, registry declares ' |
| f"{registry['schema_version']}/{registry['release_layout']['release_id']}") |
| for name, digest in sorted(build['recipe']['code_sha256'].items()): |
| tool = root / 'script' / name |
| if not tool.is_file() or sha(tool) != digest: |
| raise ValueError(f'Build recipe digest does not describe this tree: script/{name}') |
| return version, release |
|
|
|
|
| def check_view_coverage(root, build): |
| """Every view in the tree must be in the build recipe, and a recipe must cover something. |
| |
| ``validate_release`` walks ``build['views']``, so a recipe that lost a view -- or a release |
| that carries none -- would validate whatever it happens to list and still write the full |
| acceptance report under the ordinary name. A check that green-lights a smaller scope than |
| the release is not an acceptance check. |
| """ |
| on_disk = sorted(p.parent.relative_to(root).as_posix() |
| for p in (root / 'data').glob('*/*/metainfo.json')) |
| if not on_disk: |
| raise ValueError('No views found in the release tree; refusing to write an acceptance report') |
| if sorted(build['views']) != on_disk: |
| missing = sorted(set(on_disk) - set(build['views'])) |
| extra = sorted(set(build['views']) - set(on_disk)) |
| raise ValueError(f'Build recipe and tree disagree: {len(build["views"])} recipe views, ' |
| f'{len(on_disk)} on disk; missing {missing[:3]}, extra {extra[:3]}') |
| return len(on_disk) |
|
|
|
|
| def validate_release(root, per_stratum=4, seed=20260928, all_views=False, source_root=None, |
| max_visual_frames=192): |
| build = read_json(root / 'doc/build.json') |
| registry = read_json(root / 'doc/schema.json') |
| results = {} |
| strata = defaultdict(list) |
| for relative in build['views']: |
| m, f = validate_view(root / relative, registry) |
| results[relative] = (m, f) |
| strata[(f[0]['source_split'], m['camera_id'])].append(relative) |
| version, release = check_release_versions( |
| root, registry, build, {(m['schema_version'], m['release_id']) for m, _ in results.values()}) |
| check_view_coverage(root, build) |
| rng = random.Random(seed) |
| chosen = sorted(results) if all_views or build['phase'] == 'pilot' else sorted( |
| v for s in sorted(strata) for v in rng.sample(strata[s], min(per_stratum, len(strata[s])))) |
| target = root / 'doc/validation' |
| target.mkdir(parents=True, exist_ok=True) |
| |
| (target / 'human_review.json').unlink(missing_ok=True) |
| for p in target.glob('*.png'): |
| p.unlink() |
| cards = [] |
| allocation = {relative: None for relative in chosen} |
| if not all_views and build['phase'] == 'full' and max_visual_frames: |
| if max_visual_frames < len(chosen): |
| raise ValueError('max_visual_frames must cover every selected view') |
| base, extra = divmod(max_visual_frames, len(chosen)) |
| for position, relative in enumerate(chosen): |
| count = len(results[relative][1]) |
| wanted = min(count, base + (position < extra)) |
| stable_seed = int.from_bytes(hashlib.sha256(f'{seed}/{relative}'.encode()).digest()[:8], 'big') |
| allocation[relative] = sampled_indices(count, wanted, stable_seed) |
| for relative in chosen: |
| m, f = results[relative] |
| cards.extend(preview_view(root, root / relative, m, f, target, source_root, allocation[relative])) |
| payload = json.dumps(cards, ensure_ascii=False, allow_nan=False).replace('<', '\\u003c') |
| (target / 'index.html').write_text(HTML.replace('__DATA__', payload)) |
| hashes = {p.relative_to(root).as_posix(): sha(p) for p in root.rglob('*') if p.is_file() and '__pycache__' not in p.parts |
| and p.relative_to(root).as_posix() not in ('doc/validation/report.json', 'doc/validation/human_review.json')} |
| report = {'dataset': build['dataset'], 'phase': build['phase'], 'recipe': build['recipe'], |
| 'schema_version': version, 'release_id': release, |
| 'registry_sha256': sha(root / 'doc/schema.json'), |
| 'automatic_validation_passed': True, 'human_review': 'pending', |
| 'all_views_checked': len(results), 'all_frames_checked': sum(m['num_frames'] for m, _ in results.values()), |
| 'numeric_scope': 'every component, frame, shape, validity, registered schema and exact video decoded hash', |
| 'visual_scope': 'all available modalities; deterministic frame samples from selected views', |
| 'visual_selected_views': chosen, 'visual_sample_ids': [c['id'] for c in cards], |
| 'visual_policy': {'maximum_frames': None if all_views else max_visual_frames, |
| 'selection': 'per selected view: first, last, quartiles, then fixed-seed sample without replacement', |
| 'frame_indices_by_view': {k: sorted(v) if v is not None else 'all' for k, v in allocation.items()}}, |
| 'seed': seed, 'file_hashes': hashes, 'limitations': build['limitations']} |
| (target / 'report.json').write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n') |
| print(f'Validated {report["all_frames_checked"]} frames; HTML: {target / "index.html"}', flush=True) |
| return report |
|
|
|
|
| if __name__ == '__main__': |
| p = argparse.ArgumentParser(description=__doc__) |
| p.add_argument('release', type=Path) |
| p.add_argument('--per-stratum', type=int, default=4) |
| p.add_argument('--seed', type=int, default=20260928) |
| p.add_argument('--all', action='store_true', help='Generate previews for every frame of every view; potentially large') |
| p.add_argument('--source-root', type=Path, help='Extracted input, to show source RGB alongside shared RGB') |
| p.add_argument('--max-visual-frames', type=int, default=192, |
| help='Full-release visual sample cap; automatic validation still checks every frame') |
| a = p.parse_args() |
| validate_release(a.release, a.per_stratum, a.seed, a.all, a.source_root, a.max_visual_frames) |
|
|
