| """Geometry helpers: signed distance fields, point sampling, marching cubes.""" |
| import numpy as np |
| from scipy import ndimage as ndi |
|
|
|
|
| def sdf_from_mask(mask, spacing=(1.0, 1.0, 1.0)): |
| """Signed distance field in mm. Negative inside the mask, positive outside, 0 on surface. |
| mask: bool/0-1 array [x,y,z]; spacing: voxel size per axis (mm).""" |
| mask = mask.astype(bool) |
| spacing = tuple(float(s) for s in spacing) |
| if not mask.any(): |
| |
| return np.full(mask.shape, 10.0, dtype=np.float32) |
| if mask.all(): |
| return np.full(mask.shape, -10.0, dtype=np.float32) |
| out = ndi.distance_transform_edt(~mask, sampling=spacing) |
| inn = ndi.distance_transform_edt(mask, sampling=spacing) |
| sdf = out - inn |
| return sdf.astype(np.float32) |
|
|
|
|
| def normals_from_sdf(sdf, spacing=(1.0, 1.0, 1.0)): |
| """Unit gradient of the SDF (surface normals), [x,y,z,3].""" |
| gx, gy, gz = np.gradient(sdf, spacing[0], spacing[1], spacing[2]) |
| g = np.stack([gx, gy, gz], axis=-1) |
| n = np.linalg.norm(g, axis=-1, keepdims=True) |
| n = np.clip(n, 1e-6, None) |
| return (g / n).astype(np.float32) |
|
|
|
|
| def sample_surface_and_random(mask, spacing, n_points, near_ratio=0.6, |
| sigma_mm=0.6, rng=None): |
| """Return query coordinates in *voxel* units within a ROI. |
| A fraction near the surface (jittered surface voxels) + the rest uniform random.""" |
| rng = rng or np.random.default_rng() |
| shape = np.array(mask.shape) |
| n_near = int(n_points * near_ratio) |
| n_rand = n_points - n_near |
|
|
| |
| mask = mask.astype(bool) |
| if mask.any(): |
| eroded = ndi.binary_erosion(mask) |
| surf = mask & ~eroded |
| coords = np.argwhere(surf) |
| else: |
| coords = np.zeros((0, 3)) |
|
|
| if len(coords) > 0: |
| idx = rng.integers(0, len(coords), size=n_near) |
| near = coords[idx].astype(np.float32) |
| sigma_vox = np.array(sigma_mm) / np.array(spacing) |
| near = near + rng.normal(0, 1, near.shape) * sigma_vox[None, :] |
| else: |
| near = rng.random((n_near, 3)) * (shape - 1)[None, :] |
|
|
| rand = rng.random((n_rand, 3)) * (shape - 1)[None, :] |
| pts = np.concatenate([near, rand], axis=0).astype(np.float32) |
| pts = np.clip(pts, 0, (shape - 1)[None, :]) |
| return pts |
|
|
|
|
| def trilinear_sample(vol, pts): |
| """Sample a scalar/vector volume at fractional voxel coords pts [N,3] -> [N,(C)]. |
| vol: [x,y,z] or [x,y,z,C]. Pure-numpy trilinear interpolation.""" |
| pts = np.asarray(pts, dtype=np.float32) |
| x, y, z = pts[:, 0], pts[:, 1], pts[:, 2] |
| sx, sy, sz = vol.shape[:3] |
| x0 = np.clip(np.floor(x).astype(int), 0, sx - 1); x1 = np.clip(x0 + 1, 0, sx - 1) |
| y0 = np.clip(np.floor(y).astype(int), 0, sy - 1); y1 = np.clip(y0 + 1, 0, sy - 1) |
| z0 = np.clip(np.floor(z).astype(int), 0, sz - 1); z1 = np.clip(z0 + 1, 0, sz - 1) |
| xd = (x - x0)[:, None] if vol.ndim == 4 else (x - x0) |
| yd = (y - y0)[:, None] if vol.ndim == 4 else (y - y0) |
| zd = (z - z0)[:, None] if vol.ndim == 4 else (z - z0) |
|
|
| def g(a, b, c): |
| return vol[a, b, c] |
|
|
| c00 = g(x0, y0, z0) * (1 - xd) + g(x1, y0, z0) * xd |
| c01 = g(x0, y0, z1) * (1 - xd) + g(x1, y0, z1) * xd |
| c10 = g(x0, y1, z0) * (1 - xd) + g(x1, y1, z0) * xd |
| c11 = g(x0, y1, z1) * (1 - xd) + g(x1, y1, z1) * xd |
| c0 = c00 * (1 - yd) + c10 * yd |
| c1 = c01 * (1 - yd) + c11 * yd |
| return c0 * (1 - zd) + c1 * zd |
|
|
|
|
| def canal_centerline(mask): |
| """3D skeleton (centerline) of a binary canal mask -> bool array [x,y,z].""" |
| mask = mask.astype(bool) |
| if not mask.any(): |
| return np.zeros_like(mask) |
| try: |
| from skimage.morphology import skeletonize |
| return skeletonize(mask).astype(bool) |
| except Exception: |
| try: |
| from skimage.morphology import skeletonize_3d |
| return skeletonize_3d(mask).astype(bool) |
| except Exception: |
| return np.zeros_like(mask) |
|
|
|
|
| def marching_cubes_to_mesh(sdf_grid, level=0.0, spacing=(1.0, 1.0, 1.0), |
| origin=(0.0, 0.0, 0.0), pad=False, watertight=False): |
| """SDF grid -> trimesh.Trimesh in world (mm) coordinates. Returns None if empty. |
| |
| pad : pad the grid with a positive border so the zero-level set never |
| touches the volume boundary -> MC produces a closed surface. |
| watertight : keep the largest connected component and fill holes. |
| """ |
| import trimesh |
| from skimage import measure |
| if pad: |
| bigval = float(abs(sdf_grid).max() + max(spacing)) |
| sdf_grid = np.pad(sdf_grid, 1, mode="constant", constant_values=bigval) |
| origin = np.array(origin) - np.array(spacing) |
| if sdf_grid.min() > level or sdf_grid.max() < level: |
| return None |
| try: |
| verts, faces, normals, _ = measure.marching_cubes( |
| sdf_grid, level=level, spacing=tuple(float(s) for s in spacing)) |
| except Exception: |
| return None |
| verts = verts + np.array(origin)[None, :] |
| mesh = trimesh.Trimesh(vertices=verts, faces=faces, vertex_normals=normals, |
| process=True) |
| if watertight: |
| try: |
| comps = mesh.split(only_watertight=False) |
| if len(comps) > 1: |
| mesh = max(comps, key=lambda m: len(m.faces)) |
| mesh.fill_holes() |
| mesh.remove_degenerate_faces() |
| mesh.remove_duplicate_faces() |
| mesh.fix_normals() |
| except Exception: |
| pass |
| return mesh |
|
|
