| """Helpers for the fresh ARCTIC/HOT3D whole-sequence v1.0 pilots.
|
|
|
| Original archives are read only. Temporary extraction is outside raw.
|
| Licensed MANO weights stay in the local model directory and are never published.
|
| """
|
| from sequence_pilot_world import camera_mano, Mano
|
| from pilot_build import *
|
| from scipy.spatial.transform import Rotation
|
| import hashlib
|
| import re
|
| import time
|
| import trimesh
|
| from concurrent.futures import ThreadPoolExecutor,wait,FIRST_COMPLETED
|
| from contextlib import contextmanager
|
|
|
| DATA_ROOT = Path('E:/hand-datasets')
|
| RELEASE = 'shared-v1.0'
|
| RUN = 'fresh-sequence-pilot-20260920'
|
| VRS = WORK/'scripts/tools/vrs_env/Library/bin/vrs.exe'
|
| MEDIA_POOL=None
|
| MEDIA_PENDING=[]
|
| MEDIA_WORKERS=1
|
| MEDIA_POLICY='legacy_full_pixels'
|
| OUTPUT_OVERRIDE=None
|
| TMP_OVERRIDE=None
|
|
|
| @contextmanager
|
| def media_pipeline(workers=1,policy='jpeg-packets-all-rgb-sample16/v1'):
|
| global MEDIA_POOL,MEDIA_PENDING,MEDIA_WORKERS,MEDIA_POLICY
|
| assert MEDIA_POOL is None and not MEDIA_PENDING
|
| MEDIA_WORKERS=workers;MEDIA_POLICY=policy
|
| MEDIA_POOL=ThreadPoolExecutor(max_workers=workers)
|
| try:
|
| yield
|
| for future in MEDIA_PENDING:future.result()
|
| finally:
|
| MEDIA_POOL.shutdown(wait=True,cancel_futures=True)
|
| MEDIA_POOL=None;MEDIA_PENDING=[];MEDIA_POLICY='legacy_full_pixels'
|
|
|
| def submit_media(view,members_factory):
|
| global MEDIA_PENDING
|
| def execute():
|
| jpeg_video(view,members_factory());view.m['pilot_complete']=True;view.finish()
|
| if MEDIA_POOL is None:execute();return
|
|
|
| while len(MEDIA_PENDING)>=MEDIA_WORKERS:
|
| finished,_=wait(MEDIA_PENDING,return_when=FIRST_COMPLETED)
|
| for future in finished:future.result()
|
| MEDIA_PENDING=[f for f in MEDIA_PENDING if f not in finished]
|
| MEDIA_PENDING.append(MEDIA_POOL.submit(execute))
|
|
|
| def digest(p):
|
| h=hashlib.sha256()
|
| with Path(p).open('rb') as f:
|
| for b in iter(lambda:f.read(4*1024*1024),b''): h.update(b)
|
| return h.hexdigest()
|
|
|
| def native_npy_bytes(data):
|
| f=io.BytesIO(data);version=np.lib.format.read_magic(f)
|
| shape,order,dtype=np.lib.format._read_array_header(f,version)
|
| if dtype.hasobject:return Restricted(f,encoding='latin1').load().item()
|
| return np.frombuffer(f.read(),dtype=dtype).reshape(shape,order='F' if order else 'C').copy()
|
|
|
| def command(args):
|
| r=subprocess.run([str(x) for x in args],capture_output=True)
|
| if r.returncode:raise RuntimeError(r.stderr.decode(errors='replace')[-3000:])
|
| return r.stdout
|
|
|
| def framehash(args,copy=False):
|
| output=command([FF,'-v','error','-threads','2','-noautorotate',*args,'-map','0:v:0',
|
| *(['-c:v','copy'] if copy else ['-pix_fmt','rgb24','-threads','2']),
|
| '-f','framehash','-hash','sha256','-fps_mode','passthrough','pipe:1']).decode()
|
| return [(int(r.split(',')[-2]),r.split(',')[-1].strip()) for r in output.splitlines() if r and not r.startswith('#')]
|
|
|
| def jpeg_video(view, members):
|
| """members is a fresh iterator of (locator, JPEG bytes). Verify every packet/frame."""
|
| if MEDIA_POLICY!='legacy_full_pixels':
|
| from accelerated_media import write_video
|
| return write_video(view,members)
|
| temporary=view.tmp/f'{view.m["sequence_id"]}__{view.m["camera_id"]}.mjpeg'
|
| temporary.parent.mkdir(parents=True,exist_ok=True)
|
| hashes=[]
|
| with temporary.open('wb') as out:
|
| for locator,b in members:
|
| assert b[:2]==b'\xff\xd8',locator
|
| hashes.append((len(b),hashlib.sha256(b).hexdigest()));out.write(b)
|
| assert len(hashes)==view.T
|
| dst=view.p/'observation/rgb.mkv';dst.parent.mkdir(parents=True,exist_ok=True)
|
| source=['-f','image2pipe','-framerate','1','-c:v','mjpeg','-i',str(temporary)]
|
| command([FF,'-v','error','-y',*source,'-map','0:v:0','-c:v','copy',dst])
|
| packet=framehash(['-i',str(dst)],True)
|
| assert packet==hashes,'source JPEG packets changed in MKV'
|
| before=framehash(source);after=framehash(['-i',str(dst)])
|
| assert before==after and len(before)==view.T,'RGB decoding differs'
|
| w,h=view.m['camera']['image_size'];assert all(n==w*h*3 for n,_ in after)
|
| info=subprocess.run([FF,'-hide_banner','-i',str(dst)],capture_output=True).stderr.decode(errors='replace')
|
| line=next(s.strip() for s in info.splitlines() if 'Video: mjpeg' in s)
|
| pixel=re.search(r'Video: mjpeg[^,]*,\s*(\w+)',line).group(1)
|
| version=command([FF,'-version']).decode().splitlines()[0]
|
| view.component('rgb','observation/rgb.mkv','rgb/uint8/v1',['T','height','width','channel'],np.ones(view.T,bool),
|
| source=view.source,method='Original JPEG packets copied from raw into MKV; no recompression or rotation',
|
| storage={'profile':'mkv/mjpeg_copy/v1','codec':'mjpeg','pixel_format':pixel,'encoded_size':[w,h],
|
| 'source_lossy':True,'decoder':{'name':'ffmpeg','version':version,'output_pixel_format':'rgb24','autorotate':False,'source_color_declaration':'unknown','actual_stream_description':line},
|
| 'encoder_parameters':{'mode':'stream_copy','version':version}},storage_fps=1,timebase_role='index_only')
|
| view.checks.append({'test':'all_source_JPEG_packets_and_RGB_pixels_exact','passed':True,'frames':view.T,
|
| 'packet_manifest_sha256':hashlib.sha256(json.dumps(hashes).encode()).hexdigest(),
|
| 'pixel_manifest_sha256':hashlib.sha256(json.dumps(after).encode()).hexdigest(),'output_bytes':dst.stat().st_size})
|
| save(view.tmp/'media_checks'/f'{view.m["sequence_id"]}__{view.m["camera_id"]}.json',{'packets':hashes,'pixels':after})
|
|
|
| assert temporary.resolve().is_relative_to(view.tmp.resolve());temporary.unlink()
|
|
|
| class FreshView:
|
| def __init__(self,dataset,seq,cam,ids,size,source):
|
| self.root=(OUTPUT_OVERRIDE/dataset/RELEASE if OUTPUT_OVERRIDE else DATA_ROOT/dataset/RELEASE);self.p=self.root/'data'/seq/cam
|
| self.tmp=(TMP_OVERRIDE/dataset/RUN if TMP_OVERRIDE else DATA_ROOT/dataset/'tmp'/RUN);self.p.mkdir(parents=True,exist_ok=True)
|
| self.T=len(ids);self.source=source;self.checks=[]
|
| self.m={'schema_version':'hand-warehouse/1.0','storage_revision':'lossless-video-2026-09-18',
|
| 'dataset_id':dataset,'release_id':RELEASE,'sequence_id':seq,'camera_id':cam,
|
| 'sample_type':'video','num_frames':self.T,'hand_slots':['left','right'],
|
| 'sampling':{'type':'dense','source_fps':None,'frames_ref':'camera/frames.jsonl','selection':'all released images in selected complete source sequence'},
|
| 'camera':{'model':'unknown','schema_id':None,'image_size':size},'split':'unknown','components':{},'pilot':True}
|
| self.frames=[{'frame_index':i,'source_frame_id':str(fid),'timestamp_ns':None,'clock_domain':None,
|
| 'source_locator':dict(source,source_frame_id=str(fid))} for i,fid in enumerate(ids)]
|
| def component(self,name,path,schema,axes,valid,source=None,method='source values retained',kind='format_conversion',**kw):
|
| valid=np.asarray(valid,bool);vp=Path(path).with_name(Path(path).stem+'_valid.pt').as_posix();tensor(self.p/vp,valid)
|
| self.m['components'][name]={'available':True,'schema_id':schema,'data_ref':path,'axes':axes,
|
| 'valid_ref':vp,'valid_axes':axes[:valid.ndim],'provenance':{'kind':kind,'method':method},
|
| 'source_locator':source or self.source,**kw}
|
| def array(self,name,path,schema,data,valid,axes,**kw):
|
| a=np.asarray(data,np.float32).copy();valid=np.asarray(valid,bool)
|
| assert a.shape[0]==self.T and a.shape[:valid.ndim]==valid.shape
|
| assert np.isfinite(a[valid]).all(),name
|
| a[~valid]=np.nan;tensor(self.p/path,a)
|
| self.component(name,path,schema,axes,valid,**kw)
|
| restored=torch.load(self.p/path,map_location='cpu',weights_only=True).numpy()
|
| assert np.array_equal(a,restored,equal_nan=True)
|
| self.checks.append({'test':'tensor_exact_roundtrip','file':path,'shape':list(a.shape),'valid_count':int(valid.sum()),'passed':True})
|
| def attribute(self,parent,path,data,axes,source,meaning):
|
| data=np.asarray(data,np.float32);valid=np.isfinite(data)
|
| assert ((data[valid]>=0)&(data[valid]<=1)).all()
|
| vp=Path(path).with_name(Path(path).stem+'_valid.pt').as_posix();tensor(self.p/path,data);tensor(self.p/vp,valid)
|
| self.m['components'][parent].setdefault('attributes',{})['visibility']={'data_ref':path,'valid_ref':vp,
|
| 'axes':axes,'valid_axes':axes,'dtype':'float32','visibility_type':'ratio','meaning':meaning,
|
| 'provenance':{'kind':'source','method':'native HOT3D visibility ratio retained in [0,1]; misleading [%] header is not a percentage scale'},'source_locator':source}
|
| def mesh(self,oid,path,source):
|
| self.component('object_'+oid+'_mesh',path,'mesh/obj/v1',['vertex','coordinate'],np.array(True),source=source,
|
| method='Object vertices in metres; topology, material and texture dependencies retained',static=True,unit='m',coordinate_frame='object')
|
| def finish(self):
|
| lines(self.p/'camera/frames.jsonl',self.frames);save(self.p/'metainfo.json',self.m)
|
| save(self.tmp/'checks'/f'{self.m["sequence_id"]}__{self.m["camera_id"]}.json',{'checks':self.checks,'frames':self.T,'input':self.source})
|
| print('CONVERTED',self.m['dataset_id'],self.m['sequence_id'],self.m['camera_id'],self.T,flush=True)
|
|
|
| def assert_se3(a):
|
| a=np.asarray(a);assert a.shape[-2:]==(4,4)
|
|
|
| if a.size==0:return
|
| assert np.isfinite(a).all() and np.allclose(a[...,3,:],[0,0,0,1],atol=1e-6)
|
| r=a[...,:3,:3];assert np.max(np.abs(r@np.swapaxes(r,-1,-2)-np.eye(3)))<2e-5
|
| assert np.max(np.abs(np.linalg.det(r)-1))<2e-5
|
|
|
| def setup(dataset,seq):
|
| base=DATA_ROOT/dataset;out=base/RELEASE
|
| for folder in ['doc','script','doc/validation']: (out/folder).mkdir(parents=True,exist_ok=True)
|
| for f in ['CONTRACT.md','schema.json']:shutil.copyfile(WORK/'distribution/hand-warehouse-1.0'/f,out/'doc'/f)
|
| save(out/'doc/validation/status.json',{'stage':'building_sequence_pilot','human_review':'pending','sequence_id':seq,'full_preprocessing_authorized':False,'upload_authorized':False})
|
|
|
| (base/'tmp'/RUN).mkdir(parents=True,exist_ok=True)
|
|
|
| def object_textured_assets(z,prefix,target):
|
| target.mkdir(parents=True,exist_ok=True)
|
| for name in z.namelist():
|
| if not name.startswith(prefix) or name.endswith('/'):continue
|
| rel=Path(name[len(prefix):]);dest=target/rel
|
| assert dest.resolve().is_relative_to(target.resolve());dest.parent.mkdir(parents=True,exist_ok=True)
|
| if dest.suffix.lower() in ('.obj','.mtl','.jpg','.jpeg','.png'):
|
| b=z.read(name)
|
| if dest.suffix=='.obj':
|
| rows=b.decode().splitlines()
|
| for i,row in enumerate(rows):
|
| if row.startswith('v '):
|
| v=row.split();v[1:4]=[format(float(x)/1000,'.17g') for x in v[1:4]];rows[i]=' '.join(v)
|
| b=('\n'.join(rows)+'\n').encode()
|
| dest.write_bytes(b)
|
| repair_arctic_material_refs(target)
|
|
|
| def repair_arctic_material_refs(target):
|
| """Repair a source filename mismatch only when material identifiers agree."""
|
| material=target/'material.mtl'
|
| if not material.exists():return
|
| ids={x.split(maxsplit=1)[1] for x in material.read_text().splitlines() if x.startswith('newmtl ')}
|
| for obj in target.glob('*.obj'):
|
| text=obj.read_text();rows=text.splitlines();used={x.split(maxsplit=1)[1] for x in rows if x.startswith('usemtl ')}
|
| if 'mtllib material_0.mtl' in rows and not (target/'material_0.mtl').exists():
|
| assert used and used.issubset(ids),(obj,used,ids)
|
| obj.write_text(text.replace('mtllib material_0.mtl','mtllib material.mtl'))
|
|
|
| def project_points(xyz,camera,params):
|
| xyz=np.asarray(xyz,float);uv=np.full((len(xyz),2),np.nan);good=np.isfinite(xyz).all(1)&(xyz[:,2]>1e-6)
|
| if camera=='fisheye624':
|
| p=np.asarray(params);xy=xyz[good,:2]/xyz[good,2,None];r=np.linalg.norm(xy,axis=1);th=np.arctan(r)
|
| radial=th*(1+sum(p[3+i]*th**(2*i+2) for i in range(6)))
|
| xy=xy*np.divide(radial,r,out=np.ones_like(r),where=r>1e-12)[:,None]
|
| x,y=xy.T;rr=x*x+y*y
|
| xd=x+(2*x*x+rr)*p[9]+2*x*y*p[10]+p[11]*rr+p[12]*rr*rr
|
| yd=y+(2*y*y+rr)*p[10]+2*x*y*p[9]+p[13]*rr+p[14]*rr*rr
|
| uv[good]=p[0]*np.stack([xd,yd],1)+p[1:3]
|
| else:
|
| K,D=params;uv[good]=cv2.projectPoints(xyz[good],np.zeros(3),np.zeros(3),K,D)[0].reshape(-1,2)
|
| return uv
|
|
|
