Files
MeltMind/tools/phase2_h1_topology.py
T

127 lines
7.5 KiB
Python

"""Mold91ecc62f dry H0 on original tet-edge graphs; array-only implementation."""
import math
import numpy as np
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import dijkstra
from scipy.optimize import linear_sum_assignment
def graph(points, tetra):
x=np.asarray(points,dtype=np.float64); t=np.asarray(tetra)
if x.ndim!=2 or x.shape[1]!=3 or not np.isfinite(x).all(): raise ValueError('Invalid geometry')
if t.ndim!=2 or t.shape[1]!=4 or t.dtype.kind not in 'iu' or t.min()<0 or t.max()>=len(x): raise ValueError('Invalid tet IDs')
edges=np.concatenate([t[:,[a,b]] for a,b in [(0,1),(0,2),(0,3),(1,2),(1,3),(2,3)]])
edges=np.unique(np.sort(edges,axis=1),axis=0)
length=np.linalg.norm(x[edges[:,0]]-x[edges[:,1]],axis=1)
if not np.isfinite(length).all() or np.any(length<=0): raise ValueError('Nonpositive original edge')
a=np.r_[edges[:,0],edges[:,1]]; b=np.r_[edges[:,1],edges[:,0]]
return csr_matrix((np.r_[length,length],(a,b)),shape=(len(x),len(x)))
def events(field,mass,raw_ids,points,adjacency,persistence=.01):
s=np.asarray(field,dtype=np.float64); m=np.asarray(mass,dtype=np.float64); raw=np.asarray(raw_ids)
n=len(s); x=np.asarray(points,dtype=np.float64)
if s.shape!=m.shape or raw.shape!=s.shape or x.shape!=(n,3) or adjacency.shape!=(n,n): raise ValueError('Event domain mismatch')
if not np.isfinite(s).all() or not np.isfinite(m).all() or np.any(m<=0) or len(np.unique(raw))!=n: raise ValueError('Invalid event input')
order=np.argsort(-s,kind='stable'); boundaries=np.r_[0,np.flatnonzero(np.diff(s[order])!=0)+1,n]
parent=np.arange(n); active=np.zeros(n,bool); birth=np.zeros(n); birth_id=raw.copy()
def find(i):
while parent[i]!=i:
parent[i]=parent[parent[i]];i=int(parent[i])
return i
total=math.fsum(map(float,m)); passed=0.; output=[]; infinite=None
for lo,hi in zip(boundaries[:-1],boundaries[1:]):
layer=order[lo:hi]; level=passed/total; pending=set(map(int,layer)); blocks=[]
while pending:
first=next(iter(pending));pending.remove(first);todo=[first];nodes=[];old=set()
while todo:
i=todo.pop();nodes.append(i)
for jj in adjacency.indices[adjacency.indptr[i]:adjacency.indptr[i+1]]:
j=int(jj)
if active[j]: old.add(find(j))
elif j in pending:
pending.remove(j);todo.append(j)
blocks.append((nodes,old))
# Bipartite connected components, using shared old roots to join blocks.
bp=list(range(len(blocks)));owner={}
def bf(i):
while bp[i]!=i: bp[i]=bp[bp[i]];i=bp[i]
return i
for k,(_,old) in enumerate(blocks):
for g in old:
if g in owner:bp[bf(k)]=bf(owner[g])
else:owner[g]=k
compound={}
for k in range(len(blocks)):compound.setdefault(bf(k),[]).append(k)
for keys in compound.values():
nodes=[i for k in keys for i in blocks[k][0]]
olds=set().union(*(blocks[k][1] for k in keys))
if olds:
survivor=min(olds,key=lambda i:(birth[i],int(birth_id[i])))
dying=sorted(olds-{survivor},key=lambda i:(birth[i],int(birth_id[i])))
bars=[dict(birth=float(birth[i]),death=float(level),persistence=float(level-birth[i]),birth_raw_id=int(birth_id[i])) for i in dying]
if any(b['persistence']>=persistence and b['persistence']>0 for b in bars):
support=np.array([i for k in keys if len(blocks[k][1])>=2 for i in blocks[k][0]],dtype=int)
if not len(support): raise ValueError('Compound merge has no positional support')
center=np.sum(x[support]*m[support,None],axis=0)/m[support].sum()
distance=np.linalg.norm(x[support]-center,axis=1)
rep=int(support[np.lexsort((raw[support],distance))[0]])
output.append(dict(node=rep,raw_id=int(raw[rep]),death=float(level),
support_nodes=len(support),support_radius=float(np.linalg.norm(x[support]-x[rep],axis=1).max()),
multiplicity=len(dying),bars=bars))
for g in olds:parent[g]=survivor
else:
survivor=min(nodes,key=lambda i:int(raw[i]));birth[survivor]=level;birth_id[survivor]=raw[survivor]
for i in nodes:parent[i]=survivor;active[i]=True
passed=math.fsum((passed,math.fsum(map(float,m[layer]))))
infinite=len({find(i) for i in range(n)})
output.sort(key=lambda e:(e['death'],e['raw_id']))
return dict(events=output,infinite_classes=infinite,nodes=n,total_mass=total,
precision='frozen scalar values converted to FP64; exact equality ties',persistence=persistence)
def _assignment(cost, forced=(), excluded=frozenset()):
n,m=cost.shape; fr={i for i,j in forced}; fc={j for i,j in forced}
if len(fr)!=len(forced) or len(fc)!=len(forced): return None
rows=[i for i in range(n) if i not in fr];cols=[j for j in range(m) if j not in fc]
nr,nc=len(rows),len(cols);penalty=float(n+m+1)
a=np.full((nr+nc,nr+nc),penalty*4)
if nr and nc:
sub=cost[np.ix_(rows,cols)].copy()
for ii,i in enumerate(rows):
for jj,j in enumerate(cols):
if (i,j) in excluded:sub[ii,jj]=np.inf
a[:nr,:nc]=np.where(np.isfinite(sub),sub,penalty*4)
a[:nr,nc:]=penalty;a[nr:,:nc]=penalty;a[nr:,nc:]=0.
rr,cc=linear_sum_assignment(a)
pairs=list(forced)+[(rows[i],cols[j]) for i,j in zip(rr,cc) if i<nr and j<nc and np.isfinite(cost[rows[i],cols[j]]) and (rows[i],cols[j]) not in excluded]
return pairs,math.fsum(float(cost[i,j]) for i,j in pairs)
def match(reference,predicted,adjacency,rg):
if not math.isfinite(rg) or rg<=0:raise ValueError('Invalid frozen Rg')
truth=reference['events'];pred=predicted['events'];cost=np.full((len(truth),len(pred)),np.inf)
for i,a in enumerate(truth):
eligible=[j for j,b in enumerate(pred) if abs(a['death']-b['death'])<=.05]
if not eligible:continue
dist=dijkstra(adjacency,directed=False,indices=a['node'],limit=.10*rg)
for j in eligible:
d=float(dist[pred[j]['node']])
if math.isfinite(d) and d<=.10*rg:cost[i,j]=d/rg
best,target=_assignment(cost);count=len(best);forced=[];excluded=set()
candidates=sorted(zip(*np.where(np.isfinite(cost))),key=lambda p:(truth[p[0]]['raw_id'],pred[p[1]]['raw_id']))
for edge in candidates:
i,j=map(int,edge)
if any(i==a or j==b for a,b in forced):continue
attempt=_assignment(cost,forced+[(i,j)],frozenset(excluded))
if attempt is not None and len(attempt[0])==count and attempt[1]==target:forced.append((i,j))
else:excluded.add((i,j))
if len(forced)==count:break
if len(forced)!=count: raise ValueError('Exact-cost lexicographic matching could not be certified')
distances=[float(cost[i,j]) for i,j in forced]
return dict(TP=count,FP=len(pred)-count,FN=len(truth)-count,
precision=count/len(pred) if pred else None,recall=count/len(truth) if truth else None,
matched_distance_over_Rg=distances,median_distance_over_Rg=float(np.median(distances)) if distances else None,
empty_class='both_empty' if not truth and not pred else 'truth_empty' if not truth else 'prediction_empty' if not pred else 'both_nonempty',
pairs=[dict(truth_raw_id=truth[i]['raw_id'],prediction_raw_id=pred[j]['raw_id'],distance_over_Rg=float(cost[i,j])) for i,j in forced])