| """Optional raw converter for FreiHAND v1.1; NOT used for the v1.0 migration.
|
|
|
| Run without arguments from any working directory. Existing complete shards are
|
| validated and skipped; incomplete or incompatible shards stop the run.
|
| """
|
| from freihand_common import *
|
| from mano_runtime import Mano
|
| from bundle_io import ViewReader
|
| from PIL import Image
|
| import argparse, io, re, zipfile
|
| import hashlib
|
|
|
| BaseView=View
|
| class View(BaseView):
|
| def finish(self):
|
| lines(self.p/'camera/frames.jsonl',self.frames);save(self.p/'metainfo.json',self.m)
|
| save(TMP_ROOT/'checks'/f'{self.m["sequence_id"]}__{self.m["camera_id"]}.checks.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 ff(args,data=None):
|
| r=subprocess.run([FF,'-v','error','-y',*args],input=data,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
|
| if r.returncode: raise RuntimeError(r.stderr.decode(errors='replace'))
|
| return r.stdout
|
|
|
| def storage(profile,codec,pix,size,lossy,params):
|
| return dict(profile=profile,codec=codec,pixel_format=pix,encoded_size=size,source_lossy=lossy,
|
| decoder=ff(['-version']).decode().splitlines()[0],encoder_parameters=params)
|
|
|
| def main():
|
| argparse.ArgumentParser(description='Optional raw-to-v1.1 rebuild; requires original ZIPs and licensed MANO. Use migrate_freihand.py for existing shared data.').parse_args()
|
| batch_size=4096;raw_root=RAW_ROOT
|
|
|
| existing=RELEASE_ROOT/'data'
|
| for directory in existing.glob('*'):
|
| if not directory.is_dir():continue
|
| mp=directory/'camera/metainfo.json'
|
| if not mp.exists():raise RuntimeError(f'Incomplete existing shard must be handled before rerun: {directory}')
|
| previous=load(mp);start_index=int(directory.name.rsplit('_',1)[1])
|
| total=130240 if directory.name.startswith('training_') else 3960
|
| expected=min(batch_size,total-start_index)
|
| if start_index%batch_size or previous['num_frames']!=expected:
|
| raise RuntimeError(f'Existing shard layout differs from fixed {batch_size}: {directory}')
|
| torch.set_num_threads(4)
|
| model=None;summary=[]
|
| for split,filename in [('training','FreiHAND_pub_v2.zip'),('evaluation','FreiHAND_pub_v2_eval.zip')]:
|
| with zipfile.ZipFile(raw_root/filename) as z:
|
| ks=np.asarray(json.loads(z.read(split+'_K.json')));xyz=np.asarray(json.loads(z.read(split+'_xyz.json')))
|
| theta=np.asarray(json.loads(z.read(split+'_mano.json'))).reshape(-1,61)
|
| n=len(ks);assert len(xyz)==len(theta)==n
|
| rgbnames=sorted(s for s in z.namelist() if s.startswith(split+'/rgb/') and s.endswith('.jpg'))
|
| assert len(rgbnames)==n*(4 if split=='training' else 1)
|
| for start in range(0,len(rgbnames),batch_size):
|
| names=rgbnames[start:start+batch_size];ids=[int(Path(s).stem) for s in names];ix=np.asarray(ids)%n;t=len(ids)
|
| seq=f'{split}_{start:08d}';source_locator={'archive':'raw/data/'+filename}
|
| complete=RELEASE_ROOT/'data'/seq/'camera/metainfo.json'
|
| if complete.is_file():
|
| old=load(complete)
|
| required=['observation/rgb.mkv','annotation/segment/mask.mkv','annotation/mano/mano.pt','annotation/keypoints/keypoints.pt','camera/camera.pt','camera/frames.jsonl']
|
| if old.get('num_frames')!=t or not all((complete.parent/r).is_file() for r in required):
|
| raise RuntimeError(f'Existing shard is incomplete: {complete.parent}')
|
| reader=ViewReader(complete.parent)
|
| for name in ('intrinsic','keypoints_xyz','mano'):reader.numeric(name)
|
| summary.append({'sequence':seq,'frames':t,'status':'already_complete'});continue
|
| if model is None:model=Mano()
|
| v=View('FreiHAND',seq,'camera',ids,[224,224],source_locator,kind='image',split='train' if split=='training' else 'test')
|
| v.m['view_type']='exo'
|
| v.m['split_scheme']='FreiHAND_official_train_evaluation'
|
| v.m['split_source_locator']={'archive':'raw/data/'+filename,'member_prefix':split+'/'}
|
| v.m['schema_version']='hand-warehouse/1.1';v.m['storage_revision']='lossless-video-2026-09-18'
|
| v.m['sampling']['type']='independent' if t>1 else 'single'
|
| v.m['sampling']['shard_max_images']=batch_size
|
| v.m['sampling']['selection']='all released RGB images, sorted by source RGB index; all background variants retained'
|
| for f,i,base,name in zip(v.frames,ids,ix,names):
|
| f.update(sample_id=f'FreiHAND/{split}/{i:08d}',image_variant={'base_sample_id':int(base),'variant_index':int(i//n)})
|
| f['source_locator'].update(member=name,annotation_index=int(base))
|
| jpg=b''.join(z.read(s) for s in names);path=v.p/'observation/rgb.mkv';path.parent.mkdir(parents=True,exist_ok=True)
|
| ff(['-f','image2pipe','-framerate','1','-c:v','mjpeg','-i','pipe:0','-c:v','copy',str(path)],jpg)
|
| assert ff(['-i',str(path),'-c:v','copy','-f','image2pipe','pipe:1'])==jpg
|
| decoded=ff(['-f','image2pipe','-c:v','mjpeg','-i','pipe:0','-f','rawvideo','-pix_fmt','rgb24','pipe:1'],jpg)
|
| assert len(decoded)==t*224*224*3
|
| assert ff(['-i',str(path),'-f','rawvideo','-pix_fmt','rgb24','pipe:1'])==decoded
|
|
|
| info=subprocess.run([FF,'-hide_banner','-i',str(path)],capture_output=True).stderr.decode(errors='replace')
|
| pix=re.search(r'Video: mjpeg[^\n]*?\b(yuvj?\d+p)\b',info)
|
| if not pix: raise RuntimeError('Unrecognized JPEG pixel format: '+info)
|
| v.add('rgb','observation/rgb.mkv','rgb/uint8/v1',['T','height','width','channel'],np.ones(t,bool),
|
| storage=storage('mkv/mjpeg_copy/v1','mjpeg',pix.group(1),[224,224],True,{'mode':'stream_copy'}),storage_fps=1,timebase_role='index_only')
|
| v.checks.append({'test':'all_rgb_packets_and_decoded_pixels_exact','frames':t})
|
| v.intrinsic(ks[ix]);v.m['components']['intrinsic']['source_locator'].update(member=split+'_K.json',index_ref='camera/frames.jsonl:source_locator.annotation_index')
|
| kp=np.full((t,2,21,3),np.nan);kp[:,1]=xyz[ix];valid=np.zeros((t,2,21),bool);valid[:,1]=True
|
| v.array('keypoints_xyz','annotation/keypoints/xyz.pt','keypoints/xyz/v1',kp,valid,['T','hand','joint','coordinate'],unit='m',coordinate_frame='camera',keypoint_schema='mano21/v1')
|
| v.m['components']['keypoints_xyz']['source_locator'].update(member=split+'_xyz.json',index_ref='camera/frames.jsonl:source_locator.annotation_index')
|
| a=theta[ix];pose=a[:,:48].copy();pose[:,3:]+=model.data['hands_mean'];beta=a[:,48:58]
|
| verts,joints,_=model.geometry(pose,beta)
|
| focal=(ks[ix,0,0]+ks[ix,1,1])/2
|
| root=np.concatenate([a[:,58:60]-ks[ix,:2,2],focal[:,None]],axis=1)/a[:,60,None]
|
| translation=root-joints[:,9];motion=np.full((t,2,61),np.nan);motion[:,1]=np.concatenate([pose,beta,translation],axis=1)
|
| valid=np.zeros((t,2),bool);valid[:,1]=True
|
| v.array('mano','annotation/mano/motion.pt','mano/axis_angle61/v1',motion,valid,['T','hand','parameter'],unit='m',coordinate_frame='camera',angle_unit='rad',model_profile={'version':'MANO-v1.2','flat_hand_mean':True,'left_shapedirs_fix':False},method='Add MANO nonflat mean; recover source camera root from uv/scale; subtract posed middle MCP. No new fitting.')
|
| v.m['components']['mano']['source_locator'].update(member=split+'_mano.json',index_ref='camera/frames.jsonl:source_locator.annotation_index')
|
| _,restored,_=model.geometry(motion[:,1,:48],motion[:,1,48:58],motion[:,1,58:])
|
| assert np.max(np.abs(restored[:,9]-root))<2e-6
|
| masks=[];records=[]
|
| for frame,(i,base) in enumerate(zip(ids,ix)):
|
| member=f'training/mask/{base:08d}.jpg' if split=='training' else f'evaluation/segmap/{i:08d}.png'
|
| arr=np.asarray(Image.open(io.BytesIO(z.read(member))))
|
| if split=='training':
|
| assert arr.shape==(224,224,3) and np.array_equal(arr[:,:,0],arr[:,:,1]) and np.array_equal(arr[:,:,0],arr[:,:,2])
|
| arr=arr[:,:,0].astype(np.uint16)
|
| else:
|
| assert arr.shape==(224,224)
|
| arr=arr.astype(np.uint16);arr[arr==0]=65534
|
| records.append({'frame_index':frame,'labels':[dict(mask_value=int(c),category_id='background' if c==65534 else 'hand',entity_id=None if c==65534 else 'hand_right',part_id=None,source_instance_id=0 if c==65534 else int(c)) for c in np.unique(arr)]})
|
| masks.append(arr)
|
| pix='gray' if split=='training' else 'gray16le';raw=np.asarray(masks,dtype=np.uint8 if pix=='gray' else '<u2').tobytes();path=v.p/'annotation/segment/mask.mkv';path.parent.mkdir(parents=True,exist_ok=True)
|
| ff(['-f','rawvideo','-pixel_format',pix,'-video_size','224x224','-framerate','1','-i','pipe:0','-c:v','ffv1','-level','3',str(path)],raw)
|
| assert ff(['-i',str(path),'-f','rawvideo','-pix_fmt',pix,'pipe:1'])==raw
|
| schema='segment/foreground_intensity/v1' if split=='training' else 'segment/uint16_labels/v1'
|
| v.add('segment','annotation/segment/mask.mkv',schema,['T','height','width'],np.ones(t,bool),storage=storage('mkv/uint16_ffv1/v1','ffv1',pix,[224,224],split=='training',{'level':3}),storage_fps=1,timebase_role='index_only',coverage={'kind':'selected_entities','entities':['hand_right']})
|
| seg=v.m['components']['segment'];seg['source_locator'].update(member_pattern='training/mask/{annotation_index:08d}.jpg' if split=='training' else 'evaluation/segmap/{source_frame_id:08d}.png')
|
| if split=='training':seg.update(segmentation_type='semantic',value_range=[0,255],normalization_scale=1/255,foreground_category='hand',entity_id='hand_right')
|
| else:
|
| seg.update(segmentation_type='semantic',mapping_ref='annotation/segment/instances.jsonl');lines(v.p/'annotation/segment/instances.jsonl',records)
|
| v.checks.extend([{'test':'all_mask_values_exact','frames':t},{'test':'MANO_middle_MCP_root_recovery','max_m':float(np.max(np.abs(restored[:,9]-root)))}])
|
| v.finish();summary.append({'sequence':seq,'frames':t,'status':'converted'})
|
| save(TMP_ROOT/'conversion_progress.json',{'complete':False,'batches':summary})
|
| save(TMP_ROOT/'conversion_progress.json',{'complete':True,'split_selection':'all','batches':summary})
|
| if __name__=='__main__':main()
|
|
|
