"""Label-free cost check on previously exposed pairs; never classifies links.""" import argparse import itertools import json from pathlib import Path import resource import time from xml.etree import ElementTree as ET from zipfile import ZipFile import numpy as np from scipy.spatial import cKDTree from scipy.spatial.transform import Rotation from audit_samples import decode_array, tetra_geometry from boundary_distance import SurfaceDistance from s2_e1_supervisor import save def geometry_only(stream): """Stop after geometry prefix; reject any label association encountered.""" points = None cells = {} allowed = {'Points', 'connectivity', 'offsets', 'types'} stack = [] for event, e in ET.iterparse(stream, events=('start','end')): if event == 'start': stack.append(e.tag) if e.tag in ('PointData','CellData'): raise ValueError('Label association encountered before geometry completed') if e.tag == 'VTKFile': if e.get('byte_order') != 'LittleEndian' or e.get('compressor') != 'vtkZLibDataCompressor': raise ValueError('Unsupported geometry encoding') header = e.get('header_type','UInt32') else: if e.tag == 'DataArray': name = e.get('Name') if name not in allowed or stack[-2] not in ('Points','Cells'): raise ValueError('Non-geometry array in prefix') value = decode_array(e,header).copy() if name == 'Points': points = value else: cells[name] = value e.clear() if points is not None and len(cells) == 3: break stack.pop() if points is None or len(cells) != 3: raise ValueError('Incomplete geometry') offsets = np.r_[0,cells['offsets']] ids = np.flatnonzero(cells['types'] == 10) if not len(ids) or np.any(offsets[ids+1]-offsets[ids] != 4): raise ValueError('Invalid tetra domain') raw_tet = cells['connectivity'][offsets[ids,None]+np.arange(4)] raw_ids = np.unique(raw_tet) x = points[raw_ids] tet = np.searchsorted(raw_ids,raw_tet) report,data = tetra_geometry(x,dict(types=np.full(len(tet),10),offsets=np.arange(1,len(tet)+1)*4,connectivity=tet.ravel())) if report['zero_volume_cells'] or report['nonmanifold_faces'] or not np.isfinite(x).all(): raise ValueError('Invalid tetra geometry') mass = data['node_volume_raw'] center = np.sum(mass[:,None]*x,axis=0)/mass.sum() rg = float(np.sqrt(np.sum(mass*np.sum((x-center)**2,axis=1))/mass.sum())) if not np.isfinite(rg) or rg <= 0: raise ValueError('Invalid Rg') return dict(points=x,boundary=data['boundary_triangles'],center=center,rg=np.array(rg)) def sample_surface(g, prefix, n=2000): tri = g['points'][g['boundary']] cross = np.cross(tri[:,1]-tri[:,0],tri[:,2]-tri[:,0]) area2 = np.linalg.norm(cross,axis=1) if np.any(area2 <= 0): raise ValueError('Degenerate boundary face') rng = np.random.Generator(np.random.PCG64(np.random.SeedSequence([2026111412,prefix]))) ids = rng.choice(len(tri),n,replace=True,p=area2/area2.sum()) uv = rng.random((n,2)); u=np.sqrt(uv[:,0]);v=uv[:,1] pts=(1-u)[:,None]*tri[ids,0]+(u*(1-v))[:,None]*tri[ids,1]+(u*v)[:,None]*tri[ids,2] normals = cross[ids]/area2[ids,None] return pts,normals def pca_axes(x): c=x.mean(0); values,axes=np.linalg.eigh((x-c).T@(x-c)/len(x)) axes=axes[:,::-1];values=values[::-1] if np.linalg.det(axes)<0:axes[:,-1]*=-1 return c,axes,values def starting_poses(source,target): ca,aa,va=pca_axes(source);cb,ab,vb=pca_axes(target) degenerate_axes=set() for values in [va,vb]: for i,j in itertools.combinations(range(3),2): denom=max(abs(values[i]),abs(values[j])) relative=abs(values[i]-values[j])/denom if denom else 0. if relative<.05:degenerate_axes.add(3-i-j) branches={1:[], -1:[]};seen=set() def add(r,origin): key=tuple(np.round(r.ravel(),12)) if key in seen:return seen.add(key);parity=1 if np.linalg.det(r)>0 else -1 branches[parity].append(dict(rotation=r,translation=cb-ca@r.T,origin=origin)) for signs in itertools.product([-1.,1.],repeat=3): add(ab@np.diag(signs)@aa.T,dict(kind='PCA_signs',signs=list(signs))) bases={parity:rows[0]['rotation'].copy() for parity,rows in branches.items()} for parity,base in bases.items(): for axis in sorted(degenerate_axes): for step in range(12): dr=Rotation.from_rotvec(ab[:,axis]*(step*np.pi/6)).as_matrix() add(dr@base,dict(kind='near_degenerate_rotation',axis=axis,degrees=step*30)) return branches,dict(source_eigenvalues=va.tolist(),target_eigenvalues=vb.tolist(), added_rotation_axes=sorted(degenerate_axes), full_degeneracy=len(degenerate_axes)==3, deduplication='rotation entries rounded to 12 decimal places') def icp(source, target, normals, matrix, translation, max_iter=50): tree=cKDTree(target); r=matrix.copy();t=translation.copy();previous=None history=[];ranks=[];converged=False for iteration in range(max_iter): x=source@r.T+t _,idx=tree.query(x,workers=1);n=normals[idx];delta=target[idx]-x residual=np.sum(delta*n,axis=1);obj=float(np.mean(residual**2));history.append(obj) if previous is not None: relative=0. if obj==previous==0 else abs(obj-previous)/abs(previous) if previous else float('inf') if relative<1e-6:converged=True;break previous=obj design=np.column_stack([np.cross(x,n),n]) step,_,rank,_=np.linalg.lstsq(design,residual,rcond=None);ranks.append(int(rank)) if not np.isfinite(step).all(): raise ValueError('Nonfinite ICP update') dr=Rotation.from_rotvec(step[:3]).as_matrix() r=dr@r;t=dr@t+step[3:] x=source@r.T+t;_,idx=tree.query(x,workers=1) final=float(np.mean(np.sum((target[idx]-x)*normals[idx],axis=1)**2)) return dict(rotation=r.tolist(),translation=t.tolist(),iterations=len(history),converged=converged, point_plane_mse=final,min_rank=min(ranks,default=6),history=history, determinant=float(np.linalg.det(r))) def register(a,b,prefix_a,prefix_b): sa,_=sample_surface(a,prefix_a);sb,nb=sample_surface(b,prefix_b) results=[] for route in ['physical','scale_free']: scale_a=float(a['rg']) if route=='scale_free' else 1. scale_b=float(b['rg']) if route=='scale_free' else 1. source=(sa-a['center'])/scale_a;target=(sb-b['center'])/scale_b triangles_a=(a['points'][a['boundary']]-a['center'])/scale_a triangles_b=(b['points'][b['boundary']]-b['center'])/scale_b branches,pca=starting_poses(source,target) surface_a=SurfaceDistance(triangles_a);surface_b=SurfaceDistance(triangles_b) for parity,initials in branches.items(): starts=[] for initial in initials: pose=icp(source,target,nb,initial['rotation'],initial['translation']) r=np.asarray(pose['rotation']);t=np.asarray(pose['translation']) if (1 if np.linalg.det(r)>0 else -1)!=parity:raise ValueError('ICP changed branch parity') forward=surface_b.query(source@r.T+t) backward=surface_a.query((target-t)@r) # Equal weights from area-PPS; never apply area a second time. p95a=float(np.quantile(forward,.95,method='inverted_cdf')) p95b=float(np.quantile(backward,.95,method='inverted_cdf')) pose.update(origin=initial['origin'],direction_p95=[p95a,p95b], residual_max_two_way_area_pps_p95=max(p95a,p95b)) starts.append(pose) best=min(range(len(starts)),key=lambda i:(starts[i]['residual_max_two_way_area_pps_p95'],starts[i]['point_plane_mse'],i)) pose=starts[best] results.append(dict(route=route,branch='rigid' if parity==1 else 'mirror_template',parity=parity, pca_diagnostics=pca,starts=starts,best_start=best, residual_max_two_way_area_pps_p95=pose['residual_max_two_way_area_pps_p95'], best_total_rotation=pose['rotation'],best_translation=pose['translation'], total_determinant=pose['determinant'])) return results def main(): parser=argparse.ArgumentParser();parser.add_argument('root',type=Path);parser.add_argument('index',type=int) args=parser.parse_args();root=args.root;contract=json.loads((root/'registration-cost-contract.json').read_text()) from hashlib import sha256 for path,digest in contract['code_sha256'].items(): if sha256(Path(path).read_bytes()).hexdigest()!=digest:raise ValueError('Code changed after contract') pair=contract['pairs'][args.index];start=time.monotonic();geometries=[] cache=Path(contract.get('geometry_cache',root/'cost-geometry'));cache.mkdir(exist_ok=True) verification=json.loads(Path(contract['archive_verification']).read_text());stat=Path(contract['archive']).stat() if (stat.st_size,stat.st_mtime_ns,stat.st_ino)!=(verification['bytes'],verification['mtime_ns'],verification['inode']):raise ValueError('Archive identity changed') load_start=time.monotonic() for case in [pair['a'],pair['b']]: dest=cache/(case+'.npz') if dest.exists(): with np.load(dest,allow_pickle=False) as z: g={k:z[k] for k in ['points','boundary','center','rg']} else: with ZipFile(contract['archive']) as z: with z.open(case+'_sim.vtu') as stream:g=geometry_only(stream) np.savez_compressed(dest,**g) geometries.append(g) loaded=time.monotonic()-load_start result=register(*geometries,int(pair['a'].split('_')[0]),int(pair['b'].split('_')[0])) save(root/f'g1-cost-{args.index:02d}.result.json',dict(pair=pair,status='COST_ONLY_UNREVIEWED',routes=result, geometry_load_wall_seconds=loaded,wall_seconds=time.monotonic()-start, cpu_seconds=sum(resource.getrusage(resource.RUSAGE_SELF)[:2]),peak_rss_bytes=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss*1024, labels_read=False,new_candidate_generation=False,thresholds_fitted=False,link_classification='UNREVIEWED', residual_note='Area-PPS 2000-point Monte Carlo P95, true triangles; each parity branch chooses lowest two-way P95 across all starts; no certified global optimum')) if __name__=='__main__':main()