84 lines
4.5 KiB
Python
84 lines
4.5 KiB
Python
"""Distance to the supplied full triangle surface; not a thickness estimator."""
|
|
import argparse
|
|
import json
|
|
from pathlib import Path
|
|
import resource
|
|
import time
|
|
import numpy as np
|
|
from scipy.spatial import cKDTree
|
|
|
|
|
|
def triangle_distance_squared(point, triangles):
|
|
a,b,c=triangles[:,0],triangles[:,1],triangles[:,2]
|
|
ab,ac=b-a,c-a
|
|
q=point-a
|
|
normal=np.cross(ab,ac)
|
|
n2=np.einsum("ij,ij->i",normal,normal)
|
|
good=n2>0
|
|
denom=np.where(good,n2,1.)
|
|
u=np.einsum("ij,ij->i",np.cross(q,ac),normal)/denom
|
|
v=np.einsum("ij,ij->i",np.cross(ab,q),normal)/denom
|
|
inside=good&(u>=0)&(v>=0)&(u+v<=1)
|
|
plane=np.einsum("ij,ij->i",q,normal)**2/denom
|
|
result=np.where(inside,plane,np.inf)
|
|
for first,second in [(a,b),(b,c),(c,a)]:
|
|
edge=second-first;length2=np.einsum("ij,ij->i",edge,edge)
|
|
alpha=np.clip(np.einsum("ij,ij->i",point-first,edge)/np.where(length2>0,length2,1.),0,1)
|
|
residual=point-(first+alpha[:,None]*edge)
|
|
result=np.minimum(result,np.einsum("ij,ij->i",residual,residual))
|
|
return np.maximum(result,0.)
|
|
|
|
|
|
class SurfaceDistance:
|
|
def __init__(self,triangles):
|
|
self.triangles=np.asarray(triangles,dtype=np.float64)
|
|
if self.triangles.ndim!=3 or self.triangles.shape[1:]!=(3,3) or not len(triangles) or not np.isfinite(self.triangles).all():
|
|
raise ValueError("Invalid triangle surface")
|
|
self.centers=self.triangles.mean(1)
|
|
self.radius=np.linalg.norm(self.triangles-self.centers[:,None],axis=2).max(1)
|
|
self.max_radius=float(self.radius.max())
|
|
self.tree=cKDTree(self.centers)
|
|
|
|
def query(self,points):
|
|
points=np.asarray(points,dtype=np.float64)
|
|
if points.ndim!=2 or points.shape[1]!=3 or not np.isfinite(points).all():raise ValueError("Invalid query")
|
|
_,nearest=self.tree.query(points)
|
|
answer=np.empty(len(points))
|
|
for i,(point,j) in enumerate(zip(points,nearest)):
|
|
bound=float(np.sqrt(triangle_distance_squared(point,self.triangles[j:j+1])[0]))
|
|
ids=np.asarray(self.tree.query_ball_point(point,np.nextafter(bound+self.max_radius,np.inf)),dtype=int)
|
|
# Bounding spheres give a conservative candidate set; no k-NN truncation.
|
|
possible=np.linalg.norm(self.centers[ids]-point,axis=1)-self.radius[ids]<=np.nextafter(bound,np.inf)
|
|
ids=ids[possible]
|
|
if len(ids):bound=min(bound,float(np.sqrt(triangle_distance_squared(point,self.triangles[ids]).min())))
|
|
answer[i]=bound
|
|
return answer
|
|
|
|
|
|
def main():
|
|
p=argparse.ArgumentParser();p.add_argument("sample",type=Path);p.add_argument("output",type=Path);a=p.parse_args()
|
|
d=np.load(a.sample,allow_pickle=False);points=d["points_raw"];faces=d["boundary_triangles"]
|
|
start=time.monotonic();surface=SurfaceDistance(points[faces]);build=time.monotonic()-start
|
|
boundary_nodes=np.unique(faces);interior=np.ones(len(points),dtype=bool);interior[boundary_nodes]=False
|
|
distances=np.zeros(len(points))
|
|
start=time.monotonic();distances[interior]=surface.query(points[interior]);query=time.monotonic()-start
|
|
if not np.isfinite(distances).all() or np.any(distances<0):raise ValueError("Invalid distance")
|
|
a.output.mkdir(parents=True,exist_ok=True)
|
|
np.save(a.output/(a.sample.stem+".boundary_distance_raw.npy"),distances)
|
|
rng=np.random.default_rng(1729);idx=rng.choice(len(points),min(30,len(points)),replace=False)
|
|
brute=np.array([np.sqrt(triangle_distance_squared(x,points[faces]).min()) for x in points[idx]])
|
|
check=float(np.max(np.abs(brute-distances[idx])))
|
|
if check>1e-10*max(1.,np.ptp(points,axis=0).max()):raise ValueError("Acceleration/brute mismatch")
|
|
result=dict(case=a.sample.stem,nodes=len(points),boundary_triangles=len(faces),
|
|
boundary_nodes=len(boundary_nodes),interior_nodes=int(interior.sum()),
|
|
distance_raw_quantiles=np.quantile(distances,[0,.5,.9,1]).tolist(),
|
|
build_seconds=build,query_seconds=query,brute_check_queries=len(idx),brute_max_abs_error=check,
|
|
peak_rss_kib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss,
|
|
semantics="Euclidean distance to full supplied boundary triangles in exported coordinate units; not wall thickness or type",
|
|
surface_validation="Boundary extracted from linear tets; CAD discretization error not assessed")
|
|
(a.output/(a.sample.stem+".distance.json")).write_text(json.dumps(result,indent=2)+"\n")
|
|
print(json.dumps(result,indent=2),flush=True)
|
|
|
|
|
|
if __name__=="__main__":main()
|