| |
| """Independent BOP/image/pose/keypoint checks for a local BlenderProc layout.""" |
| import argparse |
| import hashlib |
| import json |
| from pathlib import Path |
| import cv2 |
| import numpy as np |
|
|
|
|
| def sha(path): |
| h=hashlib.sha256() |
| with path.open('rb') as f: |
| for b in iter(lambda:f.read(8*1024*1024),b''):h.update(b) |
| return h.hexdigest() |
|
|
|
|
| def audit(root,keypoints): |
| scene=json.loads((root/'scene_record.json').read_text());receipt=json.loads((root/'render_receipt.json').read_text()) |
| bop=root/'bop_data/handal/train_pbr/000000';gt=json.loads((bop/'scene_gt.json').read_text());camera=json.loads((bop/'scene_camera.json').read_text());info=json.loads((bop/'scene_gt_info.json').read_text()) |
| frames=scene['frames'];expected={str(i) for i in range(frames)} |
| count_tolerance=0 if (root/'visible_count_canonicalization.json').exists() else 2 |
| if set(gt)!=expected or set(camera)!=expected or set(info)!=expected:raise ValueError('incomplete BOP metadata') |
| world={r['id']:np.asarray(r['matrix']) for r in scene['object_world_poses_m'] if r['dataset']=='handal'} |
| points=np.asarray(json.loads(keypoints.read_text())['keypoints_3d']) |
| if points.shape!=(64,3) or not np.isfinite(points).all():raise ValueError('bad keypoints') |
| target=scene['target_id'];rot_error=[];translation_error=[];pixel_error=[];visible=[];sizes=[];mask_count_deltas=[] |
| for frame in range(frames): |
| key=str(frame);img=cv2.imread(str(bop/'rgb'/f'{frame:06d}.jpg'));depth=cv2.imread(str(bop/'depth'/f'{frame:06d}.png'),cv2.IMREAD_UNCHANGED) |
| if img is None or img.shape[:2]!=(1440,1920) or depth is None or depth.shape!=img.shape[:2] or depth.dtype!=np.uint16:raise ValueError('bad RGB/depth output') |
| if len(gt[key])!=20 or len(info[key])!=20:raise ValueError('expected 20 HANDAL instances') |
| K=np.asarray(camera[key]['cam_K']).reshape(3,3) |
| c2w=np.asarray(scene['camera_world_poses_m'][frame]);w2cv=np.linalg.inv(c2w@np.diag([1,-1,-1,1])) |
| for i,(pose,statistics) in enumerate(zip(gt[key],info[key])): |
| oid=pose['obj_id'];H=world[oid];scale=np.linalg.norm(H[:3,:3],axis=0) |
| if not np.allclose(scale,scale[0],rtol=1e-5):raise ValueError('anisotropic scale') |
| R=w2cv[:3,:3]@(H[:3,:3]/scale) |
| t=(w2cv[:3,:3]@H[:3,3]+w2cv[:3,3])*1000 |
| stored_R=np.asarray(pose['cam_R_m2c']).reshape(3,3);stored_t=np.asarray(pose['cam_t_m2c']) |
| rot_error.append(float(np.abs(R-stored_R).max()));translation_error.append(float(np.linalg.norm(t-stored_t))) |
| mask=cv2.imread(str(bop/'mask'/f'{frame:06d}_{i:06d}.png'),0);vis=cv2.imread(str(bop/'mask_visib'/f'{frame:06d}_{i:06d}.png'),0) |
| if mask is None or vis is None or mask.shape!=img.shape[:2] or vis.shape!=mask.shape:raise ValueError('missing/wrong-size masks') |
| count_delta=abs(int((vis>0).sum())-statistics['px_count_visib']);mask_count_deltas.append(count_delta) |
| |
| |
| |
| if np.any((vis>0)&(mask==0)) or count_delta>count_tolerance: |
| raise ValueError(f'visible-mask/info mismatch beyond {count_tolerance} raster pixels') |
| if oid==target: |
| p1=(R@(points*1000).T).T+t;p2=(stored_R@(points*1000).T).T+stored_t |
| good=(p1[:,2]>0)&(p2[:,2]>0);u1=p1[good]@K.T;u2=p2[good]@K.T |
| if good.any():pixel_error.append(float(np.linalg.norm(u1[:,:2]/u1[:,2:]-u2[:,:2]/u2[:,2:],axis=1).max())) |
| visible.append(statistics['visib_fract']);sizes.append(statistics['bbox_obj'][2:]) |
| overlay=img.copy();contours,_=cv2.findContours(vis,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE);cv2.drawContours(overlay,contours,-1,(0,255,0),2) |
| for uv in u2[:,:2]/u2[:,2:]: |
| x,y=np.rint(uv).astype(int) |
| if 0<=x<img.shape[1] and 0<=y<img.shape[0]:cv2.circle(overlay,(x,y),3,(0,0,255),-1) |
| if frame<8: |
| (root/'audit_overlays').mkdir(exist_ok=True);cv2.imwrite(str(root/'audit_overlays'/f'{frame:06d}.jpg'),overlay) |
| if max(rot_error)>1e-4 or max(translation_error)>.1 or not pixel_error or max(pixel_error)>.1:raise ValueError('independent frame/unit/projection check failed') |
| if not any(v>0 for v in visible):raise ValueError('target is never visible') |
| files={str(p.relative_to(root)):{'sha256':sha(p),'bytes':p.stat().st_size} for p in (root/'bop_data').rglob('*') if p.is_file()} |
| result={'ok':True,'target_id':target,'frames':frames,'image_size':[1920,1440], |
| 'max_rotation_entry_error':max(rot_error),'max_translation_error_mm':max(translation_error), |
| 'max_keypoint_reprojection_error_px':max(pixel_error),'target_visibility':visible,'target_bbox_sizes':sizes, |
| 'max_mask_info_count_difference_pixels':max(mask_count_deltas),'mask_info_count_tolerance_pixels':count_tolerance, |
| 'keypoints_sha256':sha(keypoints),'render_seconds':receipt['render_seconds'],'total_seconds':receipt['total_seconds'], |
| 'bop_bytes':sum(v['bytes'] for v in files.values()),'files':files,'distribution_approved':False} |
| (root/'AUDITED.json').write_text(json.dumps(result,indent=2)+'\n') |
| print(json.dumps({k:v for k,v in result.items() if k!='files'},indent=2),flush=True) |
| return result |
|
|
|
|
| def main(): |
| p=argparse.ArgumentParser();p.add_argument('--root',type=Path,required=True);p.add_argument('--keypoints',type=Path,required=True) |
| a=p.parse_args();audit(a.root,a.keypoints) |
|
|
|
|
| if __name__=='__main__':main() |
|
|
