File size: 5,548 Bytes
c4c5273 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 | """Standalone CBCT-only reconstruction. INPUT IS A SINGLE CBCT, NOTHING ELSE.
This entrypoint proves the system needs only a CBCT -- it loads NO label files and
contains NO reference to inst/cinst/solid/canal ground truth. The full chain is:
CBCT (.nii.gz or DICOM folder)
-> normalize/resample (same as training preprocess)
-> Stage-1 (predicts tooth-core descriptors) [image only]
-> connected components -> per-tooth centroids -> ROIs [image only]
-> Stage-2 encoder -> latent -> dual SDF -> marching cubes [image only]
-> per-tooth nested meshes + a full-volume label NIfTI
Usage:
python -m toothcanal.predict --config configs/default.yaml \
--cbct /path/to/case.nii.gz --out /path/to/output_dir
python -m toothcanal.predict --config configs/default.yaml \
--cbct /path/to/dicom_folder --out /path/to/output_dir
"""
import os, argparse
import numpy as np
import torch
from .utils import load_config, ensure_dir, load_nii, save_nii, resample_to_spacing
from .preprocess import normalize_image
from .models import get_unet, ImplicitNet
from .infer import reconstruct_instance
def load_cbct_only(path, cfg):
"""Load a CBCT from a .nii.gz OR a DICOM directory. Returns (image, meta).
NO label is loaded -- this function cannot see ground truth."""
pp = cfg["preprocess"]
if os.path.isdir(path):
from .download import _build_image_from_dicom
built = _build_image_from_dicom(path)
if built is None:
raise SystemExit(f"[predict] could not build image from DICOM dir {path}")
img, meta = load_nii(built)
else:
img, meta = load_nii(path)
img, meta = resample_to_spacing(img, meta, pp["spacing"], is_label=False)
img = normalize_image(img, pp["clip_hu"])
return img.astype(np.float32), meta
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--config", default="configs/default.yaml")
ap.add_argument("--cbct", required=True, help=".nii.gz file OR a DICOM folder")
ap.add_argument("--out", default=None, help="output directory")
args = ap.parse_args()
cfg = load_config(args.config)
dev = "cuda" if torch.cuda.is_available() else "cpu"
out_dir = ensure_dir(args.out or os.path.join(cfg["paths"]["out_dir"], "predict"))
# 1) load CBCT only -- d holds ONLY image/spacing/origin, never any label
img, meta = load_cbct_only(args.cbct, cfg)
d = dict(image=img,
spacing=np.asarray(meta["spacing"], np.float32),
origin=np.asarray(meta.get("origin", np.zeros(3)), np.float32))
print(f"[predict] loaded CBCT {args.cbct} shape={img.shape}")
# 2) Stage-1 -> predicted tooth-core instances (image only)
stage1_ckpt = os.path.join(cfg["paths"]["out_dir"], "stage1.pt")
if not os.path.exists(stage1_ckpt):
raise SystemExit("[predict] missing stage1.pt -- train Stage 1 first")
from .roi import predicted_instances
# predicted_instances only reads d['image'] + d.get('inst') (absent here -> no match)
inst_pred, _ = predicted_instances(d, cfg, dev, stage1_ckpt)
d["inst"] = inst_pred
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"[predict] Stage-1 found {len(ids)} teeth (from CBCT alone)")
# 3) Stage-2 -> per-tooth nested meshes (image only)
ckpt = torch.load(os.path.join(cfg["paths"]["out_dir"], "stage2.pt"), map_location=dev)
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()
mesh_dir = ensure_dir(os.path.join(out_dir, "meshes"))
full = np.zeros(img.shape, np.int16)
sp = d["spacing"]; origin = d["origin"]
for iid in ids:
rec = reconstruct_instance(net, d, iid, cfg, dev, do_tto=False)
if rec is None:
continue
off = rec["roi"]["lo_world_mm"]
for k in ("tooth", "canal"):
if rec[k] is not None:
m = rec[k].copy(); m.vertices = m.vertices + off[None, :]
m.export(os.path.join(mesh_dir, f"t{iid:02d}_{k}.stl"))
# stamp into a full-volume label map for ITK-SNAP
actual = rec["roi"].get("actual_size_mm", np.array([cfg["stage2"]["roi_mm"]] * 3))
g = rec["grid"]; gsp = actual / g
for nm, occ, val in [("tooth", rec["occ_tooth"], iid + 28),
("canal", rec["occ_canal"], iid)]:
pts = np.argwhere(occ > 0)
if len(pts) == 0:
continue
world = off[None, :] + pts * gsp[None, :]
vox = np.round((world - origin[None, :]) / sp[None, :]).astype(int)
ok = np.all((vox >= 0) & (vox < np.array(img.shape)), axis=1)
vox = vox[ok]
if nm == "canal":
full[vox[:, 0], vox[:, 1], vox[:, 2]] = val
else:
cur = full[vox[:, 0], vox[:, 1], vox[:, 2]]
vv = vox[cur == 0]
full[vv[:, 0], vv[:, 1], vv[:, 2]] = val
save_nii(img, meta, os.path.join(out_dir, "image.nii.gz"))
save_nii(full, meta, os.path.join(out_dir, "pred_label.nii.gz"))
print(f"[predict] DONE. meshes in {mesh_dir}, label map at {out_dir}/pred_label.nii.gz")
print(f"[predict] open in ITK-SNAP: main=image.nii.gz, segmentation=pred_label.nii.gz, then click Update")
if __name__ == "__main__":
main()
|