"""CPU-only prototypes for geometry grouping and local coordinate frames. No fitted model, frozen type ontology, split, or physical thickness estimator. All mesh nodes and edges are retained; partitions add an aggregation mapping. """ import argparse import hashlib import heapq import itertools import json from pathlib import Path import resource import time import numpy as np from scipy.sparse import coo_matrix,diags from scipy.sparse.csgraph import connected_components,dijkstra from scipy.stats import spearmanr def graph_from_edges(n,edges,lengths=None): weights=np.ones(len(edges)) if lengths is None else lengths return coo_matrix((np.r_[weights,weights],(np.r_[edges[:,0],edges[:,1]],np.r_[edges[:,1],edges[:,0]])),shape=(n,n)).tocsr() def node_tensor(points,tet,volumes,distance,graph,steps=3): q=points[tet] gradient=np.linalg.solve(q[:,1:]-q[:,:1],(distance[tet[:,1:]]-distance[tet[:,:1]])[...,None])[...,0] norm=np.linalg.norm(gradient,axis=1);good=norm>1e-8 normal=gradient/np.where(good,norm,1)[:,None] cellvolume=np.abs(np.linalg.det(q[:,1:]-q[:,:1]))/6 raw=np.zeros((len(points),9));mass=np.zeros(len(points)) outer=(normal[:,:,None]*normal[:,None,:]).reshape(-1,9) for j in range(4): np.add.at(raw,tet[:,j],outer*(cellvolume*good/4)[:,None]) np.add.at(mass,tet[:,j],cellvolume*good/4) raw/=np.where(mass>0,mass,1)[:,None] # A stated mesh-dependent stencil, NOT a physical-length neighbourhood. adjacency=graph.copy();adjacency.data[:]=1;adjacency.setdiag(1) weights=adjacency@diags(volumes) average=diags(1/np.asarray(weights.sum(axis=1)).ravel())@weights for _ in range(steps):raw=average@raw tensor=raw.reshape(-1,3,3) return tensor,average,dict(zero_gradient_tet_fraction=float((~good).mean()),initial_unsupported_node_fraction=float((mass==0).mean()),diffusion_steps=steps,gradient_norm_quantiles=np.quantile(norm,[0,.5,.99,1]).tolist()) def spectral_features(tensor): values,basis=np.linalg.eigh(tensor);values=values[:,::-1];basis=basis[:,:,::-1] tr=values.sum(1);frac=values/np.where(tr>1e-12,tr,1)[:,None] gap1=(values[:,0]-values[:,1])/np.maximum(values[:,0],1e-12) gap2=(values[:,1]-values[:,2])/np.maximum(values[:,0],1e-12) axis=(tr>1e-10)&(gap1>.1) full=axis&(gap2>.1) # Proxy tensor-rank labels, NOT frozen wall/rib/junction semantics. kind=np.full(len(tensor),2,dtype=np.int8) kind[(frac[:,0]>=.8)&(tr>1e-10)]=0 kind[(frac[:,0]<.65)&(frac[:,1]>=.25)&(frac[:,2]<=.15)&(tr>1e-10)]=1 kind[tr<=1e-10]=3 return dict(eigenvalues=values,basis=basis,fraction=frac,gap1=gap1,gap2=gap2,axis=axis,full=full,kind=kind) def farthest_seeds(points,mass,k): center=np.average(points,axis=0,weights=mass) first=int(np.argmax(np.sum((points-center)**2,axis=1))) seeds=[first];nearest=np.sum((points-points[first])**2,axis=1) for _ in range(1,k): nearest[seeds]=-1 i=int(np.argmax(nearest));seeds.append(i) nearest=np.minimum(nearest,np.sum((points-points[i])**2,axis=1)) return np.array(seeds) def connected_voronoi(graph,seeds): """Positive-weight multi-source graph paths guarantee connected assigned cells.""" n=graph.shape[0];labels=np.full(n,-1,dtype=np.int32);dist=np.full(n,np.inf) queue=[] for group,node in enumerate(seeds): dist[node]=0;labels[node]=group;heapq.heappush(queue,(0.,group,int(node))) while queue: value,group,u=heapq.heappop(queue) if value!=dist[u] or group!=labels[u]:continue for pos in range(graph.indptr[u],graph.indptr[u+1]): v=int(graph.indices[pos]);candidate=value+graph.data[pos] if candidate0 entropy+=fractions[group]*float(-(prob[nz]*np.log(prob[nz])).sum()) cross=labels[edges[:,0]]!=labels[edges[:,1]] pairs=np.unique(np.sort(labels[edges[cross]],axis=1),axis=0) quotient=graph_from_edges(k,pairs) return dict(k=k,component_counts=component_counts,all_connected=all(c==1 for c in component_counts),volume_fractions=fractions.tolist(),max_to_mean_volume=float(fractions.max()*k),min_to_mean_volume=float(fractions.min()*k),aspect=aspect,within_region_type_entropy=entropy,cross_edge_fraction=float(cross.mean()),quotient_edges=len(pairs),quotient_components=int(connected_components(quotient,directed=False,return_labels=False)),retained_original_edges=len(edges),repair_nodes=0) def matched_acceptance(candidate,reference): # Provisional implementation screen, preregistered here before outputs. volume_l1=float(np.abs(np.sort(candidate['volume_fractions'])-np.sort(reference['volume_fractions'])).sum()) q=np.array([.1,.5,.9]);ca=np.quantile(candidate['aspect'],q);ra=np.quantile(reference['aspect'],q) aspect_log_delta=float(np.max(np.abs(np.log(np.maximum(ca,1e-12)/np.maximum(ra,1e-12))))) cut_delta=abs(candidate['cross_edge_fraction']-reference['cross_edge_fraction']) passed=candidate['all_connected'] and candidate['k']==reference['k'] and volume_l1<=.1 and aspect_log_delta<=np.log(1.25) and cut_delta<=.05 return dict(pass_provisional=bool(passed),sorted_volume_fraction_l1=volume_l1,aspect_quantile_max_abs_log_ratio=aspect_log_delta,cross_edge_fraction_delta=cut_delta,limits=dict(volume_l1=.1,aspect_ratio=1.25,cross_edge_fraction_delta=.05),status='engineering feasibility only; not a statistical equivalence test or frozen trial rule') def bottleneck(graph,times,sources): best=np.full(len(times),np.inf);queue=[] for node in sources:best[node]=times[node];heapq.heappush(queue,(float(times[node]),int(node))) while queue: t,u=heapq.heappop(queue) if t!=best[u]:continue for pos in range(graph.indptr[u],graph.indptr[u+1]): v=int(graph.indices[pos]);candidate=max(t,times[v]) if candidatefill+tol result['violations'].append(dict(gate=label,source_count=len(sources),tolerance_fraction=fraction,tolerance_seconds=tol,nodes=int(bad.sum()),volume_fraction=float(mass[bad].sum()/mass.sum()),max_delay_seconds=float((m-fill).max()))) result['wall_seconds']=time.monotonic()-started return result def main(): p=argparse.ArgumentParser();p.add_argument('sample',type=Path);p.add_argument('distance',type=Path);p.add_argument('output',type=Path);p.add_argument('--k',type=int,default=32);a=p.parse_args() a.output.mkdir(parents=True,exist_ok=True);target=a.output/(a.sample.stem+'.routes.json') if target.exists():raise FileExistsError('Preserve previous route result; use a new output directory') start=time.monotonic();d=np.load(a.sample);x=d['points_raw'];edges=d['edges'];mass=d['node_volume_raw'];tet=d['tetra'];distance=np.load(a.distance) if len(distance)!=len(x) or not np.isfinite(distance).all():raise ValueError('Invalid cached distance') lengths=np.linalg.norm(x[edges[:,0]]-x[edges[:,1]],axis=1) if (lengths<=0).any():raise ValueError('Zero length graph edge') graph=graph_from_edges(len(x),edges,lengths);marks={} tick=time.monotonic();tensor,average,meta=node_tensor(x,tet,mass,distance,graph);features=spectral_features(tensor);marks['descriptor_seconds']=time.monotonic()-tick axis=features['axis'];full=features['full'];kind=features['kind'];E=features['basis'];rng=np.random.default_rng(1729) rotations={};q,_=np.linalg.qr(rng.normal(size=(3,3))) for name,R in [('rotation',q*np.linalg.det(q)),('reflection',q@np.diag([-1.,1.,1.]))]: transformed=x@R.T+np.array([3.1,-7.,2.]);t2,_,_=node_tensor(transformed,tet,mass,distance,graph) f2=spectral_features(t2);expected=R@tensor@R.T b2=f2['basis'];basis_expected=R@E sign=np.sign(np.einsum('nij,nij->nj',basis_expected,b2));sign[sign==0]=1 frame_error=np.linalg.norm(b2*sign[:,None,:]-basis_expected,axis=(1,2)) rotations[name]=dict(tensor_max_abs_error=float(abs(t2-expected).max()),type_change_fraction=float((kind!=f2['kind']).mean()),validity_change_fraction=float((full!=f2['full']).mean()),full_frame_orbit_max_error=float(frame_error[full&f2['full']].max(initial=0)),normal_projector_max_error=float(np.abs(b2[axis,:,0,None]*b2[axis,None,:,0]-basis_expected[axis,:,0,None]*basis_expected[axis,None,:,0]).max(initial=0))) local_center=average@x;delta=x-local_center;local=np.einsum('ni,nij->nj',delta,E);reconstruction=np.einsum('nj,nij->ni',local,E)+local_center masks=dict(full_frame_node_fraction=float(full.mean()),full_frame_volume_fraction=float(mass[full].sum()/mass.sum()),normal_axis_node_fraction=float(axis.mean()),normal_axis_volume_fraction=float(mass[axis].sum()/mass.sum()),ambiguous_node_fraction=float((~full).mean()),reconstruction_max_error_raw=float(abs(reconstruction-x).max()),rank_proxy_node_counts=np.bincount(kind,minlength=4).tolist(),rank_proxy_volume_fractions=(np.bincount(kind,weights=mass,minlength=4)/mass.sum()).tolist()) # A modest stencil sensitivity check, not evidence of remeshing stability. t5,_,_=node_tensor(x,tet,mass,distance,graph,steps=5);f5=spectral_features(t5) sensitivity=dict(type_change_fraction_3_vs_5_hops=float((kind!=f5['kind']).mean()),full_validity_change_fraction_3_vs_5_hops=float((full!=f5['full']).mean())) tick=time.monotonic();seeds=farthest_seeds(x,mass,a.k);partition_results={};label_cache={} random_kind=kind[rng.permutation(len(x))] for name,alpha,types in [('generic',0,kind),('type_alpha1',1,kind),('type_alpha4',4,kind),('control_alpha1',1,random_kind),('control_alpha4',4,random_kind)]: then=time.monotonic();weight=lengths*(1+alpha*(types[edges[:,0]]!=types[edges[:,1]]));g=graph_from_edges(len(x),edges,weight) labels=connected_voronoi(g,seeds);report=partition_report(labels,graph,edges,x,mass,kind);report['seconds']=time.monotonic()-then if name!='generic':report['matching']=matched_acceptance(report,partition_results['generic']) partition_results[name]=report;label_cache[name]=labels marks['partition_seconds']=time.monotonic()-tick tick=time.monotonic();baseline=filling_baselines(graph,x,d['fill_time_raw'],mass,d['gate_location_raw']);marks['baseline_seconds']=time.monotonic()-tick np.savez_compressed(a.output/(a.sample.stem+'.route_arrays.npz'),tensor=tensor,type_proxy=kind,frame_valid=full,axis_valid=axis,seeds=seeds,**label_cache) result=dict(case=a.sample.stem,nodes=len(x),edges=len(edges),k=a.k,source_sample_sha256=hashlib.sha256(a.sample.read_bytes()).hexdigest(),source_distance_sha256=hashlib.sha256(a.distance.read_bytes()).hexdigest(),descriptor=meta,frames=masks,pose_checks=rotations,stencil_sensitivity=sensitivity,partitions=partition_results,baselines=baseline,timings=marks,wall_seconds=time.monotonic()-start,peak_rss_kib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss,scope='Three-part feasibility prototype. No training, split, full-corpus rate, type ontology, thickness or chart map claim.') target.write_text(json.dumps(result,indent=2,allow_nan=False)+'\n');print(json.dumps({k:result[k] for k in ['case','frames','pose_checks','stencil_sensitivity','timings','wall_seconds','peak_rss_kib']},indent=2),flush=True) if __name__=='__main__':main()