122 lines
7.5 KiB
Python
122 lines
7.5 KiB
Python
"""Frozen Df-guided tet-edge paths and dry merge-tree depth; no truth."""
|
|
import heapq
|
|
import math
|
|
import numpy as np
|
|
from scipy.sparse import csr_matrix
|
|
|
|
|
|
def edge_geometry(x,tets,volume,cell_speed):
|
|
pairs=[(0,1),(0,2),(0,3),(1,2),(1,3),(2,3)]
|
|
raw=np.concatenate([np.sort(tets[:,[i,j]],axis=1) for i,j in pairs])
|
|
edges,inverse=np.unique(raw,axis=0,return_inverse=True)
|
|
denominator=np.bincount(inverse,weights=np.tile(volume,6))
|
|
inside=np.bincount(inverse,weights=np.tile(volume*cell_speed,6))/denominator
|
|
length=np.linalg.norm(x[edges[:,0]]-x[edges[:,1]],axis=1)
|
|
if np.any(length<=0) or not np.isfinite(length).all():raise ValueError('NONPOSITIVE_OR_NONFINITE_EDGE')
|
|
a=np.r_[edges[:,0],edges[:,1]];b=np.r_[edges[:,1],edges[:,0]]
|
|
adjacency=csr_matrix((np.r_[length,length],(a,b)),shape=(len(x),len(x)))
|
|
thickness=csr_matrix((np.r_[2*inside,2*inside],(a,b)),shape=adjacency.shape)
|
|
return adjacency,thickness
|
|
|
|
|
|
def paths(df,raw,roots,adjacency,thickness,mass=None):
|
|
n=len(df);df=np.asarray(df);raw=np.asarray(raw);roots=set(map(int,roots))
|
|
mass=np.ones(n) if mass is None else np.asarray(mass)
|
|
if not roots or min(roots)<0 or max(roots)>=n or not np.isfinite(df).all():raise ValueError('INVALID_DF_OR_SOURCE')
|
|
if not np.array_equal(adjacency.indices,thickness.indices) or not np.array_equal(adjacency.indptr,thickness.indptr):raise ValueError('EDGE_FIELD_ALIGNMENT')
|
|
order=np.argsort(df,kind='stable');cuts=np.r_[0,np.flatnonzero(np.diff(df[order])!=0)+1,n]
|
|
parent=np.full(n,-2,np.int64);owner=np.full(n,-1,np.int64);b=np.full(n,np.nan);integral=np.full(n,np.nan);processed=[];ties=0;platforms=[]
|
|
for lo,hi in zip(cuts[:-1],cuts[1:]):
|
|
layer=set(map(int,order[lo:hi]))
|
|
while layer:
|
|
seed=min(layer,key=lambda i:int(raw[i]));layer.remove(seed);todo=[seed];nodes=[]
|
|
while todo:
|
|
i=todo.pop();nodes.append(i)
|
|
for jj in adjacency.indices[adjacency.indptr[i]:adjacency.indptr[i+1]]:
|
|
j=int(jj)
|
|
if j in layer:layer.remove(j);todo.append(j)
|
|
block=set(nodes);best={};queue=[];exits=0
|
|
for i in nodes:
|
|
options=[]
|
|
for pos in range(adjacency.indptr[i],adjacency.indptr[i+1]):
|
|
j=int(adjacency.indices[pos]);length=float(adjacency.data[pos])
|
|
if df[j]<df[i] and owner[j]>=0:options.append((-(df[i]-df[j])/length,int(raw[j]),j,pos))
|
|
if i in roots:
|
|
parent[i]=-1;owner[i]=i;b[i]=np.inf;integral[i]=0.;processed.append(i);candidate=(0.,int(raw[i]),-1,i);exits+=1
|
|
elif options:
|
|
options.sort();_,_,j,pos=options[0];ties+=sum(o[0]==options[0][0] for o in options)>1
|
|
parent[i]=j;owner[i]=owner[j];h=float(thickness.data[pos]);b[i]=min(b[j],h) if np.isfinite(h) and h>0 and not np.isnan(b[j]) else np.nan
|
|
integral[i]=integral[j]+float(adjacency.data[pos])/h**2 if np.isfinite(h) and h>0 else np.nan;processed.append(i)
|
|
candidate=(0.,int(raw[i]),int(raw[j]),i);exits+=1
|
|
else:continue
|
|
best[i]=candidate[:3];heapq.heappush(queue,candidate)
|
|
finalized=set()
|
|
while queue:
|
|
dist,exit_id,parent_id,i=heapq.heappop(queue)
|
|
if i in finalized or best.get(i)!=(dist,exit_id,parent_id):continue
|
|
finalized.add(i)
|
|
for pos in range(adjacency.indptr[i],adjacency.indptr[i+1]):
|
|
j=int(adjacency.indices[pos])
|
|
if j not in block or j in finalized:continue
|
|
candidate=(dist+float(adjacency.data[pos]),exit_id,int(raw[i]))
|
|
if candidate[0]<=dist:raise ValueError('PLATFORM_DISTANCE_PRECISION_LOSS')
|
|
if j not in best or candidate<best[j]:
|
|
best[j]=candidate;parent[j]=i;owner[j]=owner[i];h=float(thickness.data[pos])
|
|
b[j]=min(b[i],h) if np.isfinite(h) and h>0 and not np.isnan(b[i]) else np.nan
|
|
integral[j]=integral[i]+float(adjacency.data[pos])/h**2 if np.isfinite(h) and h>0 else np.nan
|
|
heapq.heappush(queue,(*candidate,j))
|
|
if parent[i]>=0 and df[parent[i]]==df[i]:processed.append(i)
|
|
platforms.append(dict(size=len(nodes),exits=exits,reachable=len(finalized),mass=math.fsum(map(float,mass[nodes])),Df=float(df[nodes[0]]),minimum_raw_id=int(min(raw[nodes]))))
|
|
b[np.isinf(b)]=np.nan
|
|
return parent,owner,np.column_stack([b,integral]),dict(platforms=platforms,lower_slope_tie_nodes=int(ties),reachable_nodes=int(np.sum(owner>=0)))
|
|
|
|
|
|
def junction_depth(df,mass,raw,adjacency,roots,parent_owner,persistence=.010):
|
|
n=len(df);order=np.argsort(-np.asarray(df),kind='stable');cuts=np.r_[0,np.flatnonzero(np.diff(np.asarray(df)[order])!=0)+1,n]
|
|
uf=np.arange(n);active=np.zeros(n,bool);birth=np.zeros(n);birth_id=np.array(raw,copy=True);top=np.full(n,-1,np.int64);location=np.full(n,-1,np.int64)
|
|
tree_parent=[];significant=[];levels=[];total=math.fsum(map(float,mass));passed=0.
|
|
def find(i):
|
|
while uf[i]!=i:uf[i]=uf[uf[i]];i=int(uf[i])
|
|
return i
|
|
for lo,hi in zip(cuts[:-1],cuts[1:]):
|
|
layer=order[lo:hi];level=passed/total;pending=set(map(int,layer));blocks=[]
|
|
while pending:
|
|
first=pending.pop();todo=[first];nodes=[];olds=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]:olds.add(find(j))
|
|
elif j in pending:pending.remove(j);todo.append(j)
|
|
blocks.append((nodes,olds))
|
|
bp=list(range(len(blocks)));seen={}
|
|
def bf(i):
|
|
while bp[i]!=i:bp[i]=bp[bp[i]];i=bp[i]
|
|
return i
|
|
for k,(_,olds) in enumerate(blocks):
|
|
for g in olds:
|
|
if g in seen:bp[bf(k)]=bf(seen[g])
|
|
else:seen[g]=k
|
|
groups={}
|
|
for k in range(len(blocks)):groups.setdefault(bf(k),[]).append(k)
|
|
for keys in groups.values():
|
|
nodes=[i for k in keys for i in blocks[k][0]];olds=set().union(*(blocks[k][1] for k in keys));event=False
|
|
tid=len(tree_parent);tree_parent.append(-1);levels.append(level)
|
|
if olds:
|
|
survivor=min(olds,key=lambda i:(birth[i],int(birth_id[i])))
|
|
event=any(level-birth[i]>=persistence and level-birth[i]>0 for i in olds-{survivor})
|
|
for g in olds:tree_parent[int(top[g])]=tid;uf[g]=survivor
|
|
else:survivor=min(nodes,key=lambda i:int(raw[i]));birth[survivor]=level;birth_id[survivor]=raw[survivor]
|
|
significant.append(event);top[survivor]=tid
|
|
for i in nodes:uf[i]=survivor;active[i]=True;location[i]=tid
|
|
passed=math.fsum((passed,math.fsum(map(float,np.asarray(mass)[layer]))))
|
|
depth=np.zeros(len(tree_parent),np.int64)
|
|
for i in range(len(depth)-1,-1,-1):
|
|
p=tree_parent[i]
|
|
if p>=0:depth[i]=depth[p]+int(significant[p])
|
|
result=np.full(n,np.nan)
|
|
valid=np.flatnonzero(parent_owner>=0)
|
|
result[valid]=depth[location[valid]]-depth[location[parent_owner[valid]]]
|
|
if np.any(result[valid]<0):raise ValueError('ROOT_NOT_ANCESTOR_IN_DRY_TREE')
|
|
return result,dict(significant_events=int(sum(significant)),tree_nodes=len(tree_parent)),dict(tree_parent=np.array(tree_parent),significant=np.array(significant),node_tree_location=location,tree_depth=depth,tree_levels=np.array(levels))
|