200 lines
10 KiB
Python
200 lines
10 KiB
Python
"""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()
|