Files
MeltMind/artifacts/s2-e1-2026-11-14/superseded-1816-source/g1_registration_cost.py
T

169 lines
8.8 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); _,axes=np.linalg.eigh((x-c).T@(x-c)/len(x))
return c,axes[:,::-1]
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
# Keep the explicitly flagged mirror branch, including redundant starts,
# so its measured preparation cost is not silently removed.
for mirrored in [False,True]:
mirror=np.diag([-1.,1.,1.]) if mirrored else np.eye(3)
s=source@mirror.T;ca,aa=pca_axes(s);cb,ab=pca_axes(target)
starts=[]
for signs in itertools.product([-1.,1.],repeat=3):
initial=ab@np.diag(signs)@aa.T
pose=icp(s,target,nb,initial,cb-ca@initial.T)
pose['initial_signs']=list(signs);starts.append(pose)
best=min(range(len(starts)),key=lambda i:(starts[i]['point_plane_mse'],i))
pose=starts[best];r=np.asarray(pose['rotation'])@mirror;t=np.asarray(pose['translation'])
forward=SurfaceDistance(triangles_b).query(source@r.T+t)
backward=SurfaceDistance(triangles_a).query((target-t)@r)
# Equal weights are the area-PPS Monte Carlo weights; do not multiply
# by triangle areas again. Cumulative 95% (higher order statistic).
p95a=float(np.quantile(forward,.95,method='inverted_cdf'))
p95b=float(np.quantile(backward,.95,method='inverted_cdf'))
results.append(dict(route=route,explicit_mirror_branch=mirrored,starts=starts,best_start=best,
residual_max_two_way_area_pps_p95=max(p95a,p95b),direction_p95=[p95a,p95b],
best_total_rotation=r.tolist(),best_translation=t.tolist(),
total_determinant=float(np.linalg.det(r))))
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=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; pose chosen by point-plane objective within each branch, not a certified global optimum'))
if __name__=='__main__':main()