"""Inference: reconstruct per-tooth (tooth + canal) meshes from the implicit field, with optional test-time latent optimization (TTO), and export STL. python -m toothcanal.infer --config configs/default.yaml """ import os, argparse import numpy as np import torch from .utils import load_config, ensure_dir, set_seed from .splits import make_split from .roi import crop_roi from .geometry import sdf_from_mask, sample_surface_and_random, trilinear_sample, \ marching_cubes_to_mesh from .models import ImplicitNet from .losses import sdf_l1, occupancy_dice def _dense_coords(roi_vox, roi_mm, grid, dev): lin = torch.linspace(-roi_mm / 2, roi_mm / 2, grid, device=dev) gx, gy, gz = torch.meshgrid(lin, lin, lin, indexing="ij") coords = torch.stack([gx, gy, gz], -1).reshape(1, -1, 3) # [1,G^3,3] return coords def tto_latent(net, feat, roi, cfg, dev): """Optimize a fresh latent to fit the observed coarse masks in `roi`.""" s2 = cfg["stage2"] feat = tuple(f.detach() for f in feat) # TTO optimizes only z, not the encoder z = net.latents.weight.detach().mean(0, keepdim=True).clone().to(dev) z.requires_grad_(True) opt = torch.optim.Adam([z], lr=cfg["tto"]["lr"]) half = torch.tensor([s2["roi_mm"] / 2.0], device=dev) sdf_t = sdf_from_mask(roi["solid"], roi["roi_sp"]) sdf_c = sdf_from_mask(roi["canal"], roi["roi_sp"]) for _ in range(cfg["tto"]["steps"]): pts = sample_surface_and_random(roi["solid"], roi["roi_sp"], s2["points_per_tooth"]) gt_t = torch.from_numpy(trilinear_sample(sdf_t, pts).astype(np.float32)).to(dev) gt_c = torch.from_numpy(trilinear_sample(sdf_c, pts).astype(np.float32)).to(dev) center = (s2["roi_vox"] - 1) / 2.0 cmm = torch.from_numpy(((pts - center) * roi["roi_sp"][None, :]).astype(np.float32)) cmm = cmm[None].to(dev) sdf, _ = net.query(feat, cmm, half, z, compute_grad=False) st, sc = sdf[..., 0], sdf[..., 1] loss = (sdf_l1(st, gt_t[None], s2["sdf_clamp_mm"]) + sdf_l1(sc, gt_c[None], s2["sdf_clamp_mm"]) + occupancy_dice(st, gt_t[None], s2["occ_tau_mm"]) + occupancy_dice(sc, gt_c[None], s2["occ_tau_mm"])) opt.zero_grad(); loss.backward(); opt.step() return z.detach() @torch.no_grad() def _eval_grid(net, feat, coords, half, z, chunk=200000): outs = [] for i in range(0, coords.shape[1], chunk): c = coords[:, i:i + chunk] sdf, _ = net.query(feat, c, half, z, compute_grad=False) outs.append(sdf.cpu()) return torch.cat(outs, dim=1)[0].numpy() # [G^3, 2] def reconstruct_instance(net, d, iid, cfg, dev, do_tto=None): s2 = cfg["stage2"] if do_tto is None: do_tto = bool(cfg["infer"].get("use_tto", False)) roi = crop_roi(d, iid, s2["roi_mm"], s2["roi_vox"], center_mode=s2.get("roi_center", "com")) if roi is None: return None img = torch.from_numpy(roi["img"][None, None].astype(np.float32)).to(dev) feat = net.encode(img) half = torch.tensor([s2["roi_mm"] / 2.0], device=dev) if do_tto: z = tto_latent(net, feat, roi, cfg, dev) # optional refinement only elif getattr(net, "use_encoder_latent", False): with torch.no_grad(): z = net.latent_from_feat(feat) # latent from image alone (no GT) else: z = net.latents.weight.detach().mean(0, keepdim=True).to(dev) g = cfg["infer"]["grid"] coords = _dense_coords(s2["roi_vox"], s2["roi_mm"], g, dev) sdf = _eval_grid(net, feat, coords, half, z) sdf_t = sdf[:, 0].reshape(g, g, g) sdf_c = sdf[:, 1].reshape(g, g, g) sp = np.array([s2["roi_mm"] / g] * 3) pad = bool(cfg["infer"].get("pad_roi", True)) # Tier-1/2: tooth and canal use SEPARATE marching-cubes levels & postprocessing. # tooth was systematically undersized (-0.12 RVD) because it shared the canal's # -0.2 level while GT is meshed at 0.0 -> mc_level_tooth pulls it back to GT size. inf = cfg["infer"] lvl_t = float(inf.get("mc_level_tooth", inf.get("mc_level", 0.0))) lvl_c = float(inf.get("mc_level_canal", inf.get("mc_level", -0.2))) wt_t = bool(inf.get("tooth_watertight_postprocess", inf.get("watertight_postprocess", True))) wt_c = bool(inf.get("canal_watertight_postprocess", False)) # keep thin apex / branches tooth = marching_cubes_to_mesh(sdf_t, lvl_t, sp, pad=pad, watertight=wt_t) canal = marching_cubes_to_mesh(sdf_c, lvl_c, sp, pad=pad, watertight=wt_c) # canal de-merging + phantom guard: the implicit field can bridge nearby canals # into one blob. Split into connected components, keep those inside the tooth, and # remove thin bridges by discarding components far smaller than the main canal(s). n_canal_components = 0 if canal is not None and tooth is not None: try: import trimesh tlo, thi = tooth.bounds margin = 1.0 comps = canal.split(only_watertight=False) in_tooth = [] for c in comps: cc = c.centroid if np.all(cc >= tlo - margin) and np.all(cc <= thi + margin): in_tooth.append(c) if in_tooth: # drop tiny fragments (< 8% of the largest component volume): these are # usually bridge stubs or noise, not real separate canals. vols = np.array([abs(c.volume) for c in in_tooth]) vmax = vols.max() frac = float(cfg["infer"].get("canal_min_component_frac", 0.08)) kept = [c for c, v in zip(in_tooth, vols) if v >= frac * vmax] n_canal_components = len(kept) canal = trimesh.util.concatenate(kept) if len(kept) > 1 else kept[0] else: canal = None except Exception: pass # predicted occupancy volumes on the ROI grid (for NIfTI / ITK-SNAP export) occ_tooth = (sdf_t < lvl_t).astype(np.uint8) occ_canal = (sdf_c < lvl_c).astype(np.uint8) return dict(tooth=tooth, canal=canal, roi=roi, occ_tooth=occ_tooth, occ_canal=occ_canal, grid=g, n_canal_components=n_canal_components) def main(): ap = argparse.ArgumentParser() ap.add_argument("--config", default="configs/default.yaml") ap.add_argument("--tto", dest="tto", action="store_true", default=None, help="force test-time optimization on (default: follow config use_tto)") args = ap.parse_args() cfg = load_config(args.config) set_seed(cfg["split"]["seed"]) dev = "cuda" if torch.cuda.is_available() else "cpu" ckpt = torch.load(os.path.join(cfg["paths"]["out_dir"], cfg["stage2"].get("ckpt_name", "stage2.pt")), map_location=dev) # rebuild with matching latent table size n_lat = ckpt["model"]["latents.weight"].shape[0] class _N(ImplicitNet): def __init__(s): super().__init__(n_lat, cfg) net = _N().to(dev) net.load_state_dict(ckpt["model"]) net.eval() _, test = make_split(cfg["paths"]["proc_dir"], cfg) mesh_dir = ensure_dir(os.path.join(cfg["paths"]["out_dir"], "meshes")) roi_source = cfg["infer"].get("roi_source", "oracle") stage1_ckpt = os.path.join(cfg["paths"]["out_dir"], "stage1.pt") print(f"[infer] roi_source = {roi_source} use_tto = {cfg['infer'].get('use_tto', False)}") for cid in test: d = dict(np.load(os.path.join(cfg["paths"]["proc_dir"], f"{cid}.npz"))) if roi_source == "predicted" and os.path.exists(stage1_ckpt): from .roi import predicted_instances inst_pred, match = predicted_instances(d, cfg, dev, stage1_ckpt) d["inst"] = inst_pred # Stage-1 drives the ROIs (no GT) d["cinst"] = np.zeros_like(inst_pred) # canal comes purely from the implicit field ids = [int(v) for v in np.unique(inst_pred) if v > 0] print(f"[infer] {cid}: {len(ids)} predicted teeth (Stage-1 driven)") else: ids = [int(v) for v in np.unique(d["inst"]) if v > 0] print(f"[infer] {cid}: {len(ids)} teeth (oracle ROI)") for iid in ids: r = reconstruct_instance(net, d, iid, cfg, dev, do_tto=args.tto) if r is None: continue # transform meshes from local ROI frame into world (mm) coords so they # reassemble correctly when visualize.py merges them. offset = r["roi"]["lo_world_mm"] for k in ("tooth", "canal"): if r[k] is not None: r[k].vertices = r[k].vertices + offset[None, :] if r["tooth"] is not None: r["tooth"].export(os.path.join(mesh_dir, f"{cid}_t{iid:02d}_tooth.stl")) if r["canal"] is not None: r["canal"].export(os.path.join(mesh_dir, f"{cid}_t{iid:02d}_canal.stl")) print(f"[infer] meshes saved to {mesh_dir}") if __name__ == "__main__": main()