"""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]=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 candidate0 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))