Files
MeltMind/tools/g1_registration_cost.py
T

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()