| """Export predictions as a single .nii.gz label volume per test case, aligned to |
| the processed CBCT, so you can open it in ITK-SNAP ON TOP of the image and scroll |
| through slices (canal = 1..28, tooth body = 29..56), exactly like the GT labels. |
| |
| python -m toothcanal.export_nifti --config configs/default.yaml |
| |
| Outputs, per test case, in outputs/nifti/: |
| <case>_image.nii.gz the (normalized) CBCT used |
| <case>_pred_label.nii.gz predicted labels (open as 'Segmentation' in ITK-SNAP) |
| <case>_gt_label.nii.gz ground-truth labels (for side-by-side comparison) |
| """ |
| import os, argparse |
| import numpy as np |
| import torch |
| from scipy import ndimage as ndi |
| from .utils import load_config, ensure_dir, save_nii |
| from .splits import make_split |
| from .models import ImplicitNet |
| from .infer import reconstruct_instance |
|
|
|
|
| def _load_net(cfg, dev): |
| 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() |
| return net |
|
|
|
|
| def export_case(cfg, net, cid, dev): |
| d = dict(np.load(os.path.join(cfg["paths"]["proc_dir"], f"{cid}.npz"))) |
| img = d["image"].astype(np.float32) |
| sp = d["spacing"].astype(np.float32) |
| origin = d.get("origin", np.zeros(3)).astype(np.float32) |
| full_shape = img.shape |
|
|
| pred = np.zeros(full_shape, np.int16) |
| gt = np.zeros(full_shape, np.int16) |
| |
| inst = d["inst"]; cinst = d["cinst"] |
| gt[inst > 0] = inst[inst > 0].astype(np.int16) + 28 |
| gt[cinst > 0] = cinst[cinst > 0].astype(np.int16) |
|
|
| ids = [int(v) for v in np.unique(inst) if v > 0] |
| for iid in ids: |
| rec = reconstruct_instance(net, d, iid, cfg, dev, do_tto=False) |
| if rec is None: |
| continue |
| roi = rec["roi"] |
| g = rec["grid"] |
| lo_world = roi["lo_world_mm"] |
| |
| |
| actual = roi.get("actual_size_mm", None) |
| if actual is None: |
| actual = np.array([cfg["stage2"]["roi_mm"]] * 3, np.float32) |
| roi_grid_sp = actual / g |
| for name, occ, value in [("tooth", rec["occ_tooth"], iid + 28), |
| ("canal", rec["occ_canal"], iid)]: |
| pts = np.argwhere(occ > 0) |
| if len(pts) == 0: |
| continue |
| world = lo_world[None, :] + pts * roi_grid_sp[None, :] |
| vox = np.round((world - origin[None, :]) / sp[None, :]).astype(int) |
| ok = np.all((vox >= 0) & (vox < np.array(full_shape)), axis=1) |
| vox = vox[ok] |
| if len(vox) == 0: |
| continue |
| if name == "canal": |
| pred[vox[:, 0], vox[:, 1], vox[:, 2]] = value |
| else: |
| cur = pred[vox[:, 0], vox[:, 1], vox[:, 2]] |
| vv = vox[cur == 0] |
| pred[vv[:, 0], vv[:, 1], vv[:, 2]] = value |
|
|
| meta = dict(spacing=sp, origin=origin, direction=np.eye(3).flatten()) |
| out_dir = ensure_dir(os.path.join(cfg["paths"]["out_dir"], "nifti")) |
| save_nii(img, meta, os.path.join(out_dir, f"{cid}_image.nii.gz")) |
| save_nii(pred, meta, os.path.join(out_dir, f"{cid}_pred_label.nii.gz")) |
| save_nii(gt, meta, os.path.join(out_dir, f"{cid}_gt_label.nii.gz")) |
| print(f"[nifti] {cid}: wrote image + pred_label + gt_label to {out_dir}") |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--config", default="configs/default.yaml") |
| ap.add_argument("--case", default=None) |
| args = ap.parse_args() |
| cfg = load_config(args.config) |
| dev = "cuda" if torch.cuda.is_available() else "cpu" |
| net = _load_net(cfg, dev) |
| _, test = make_split(cfg["paths"]["proc_dir"], cfg) |
| cases = [args.case] if args.case else test |
| for cid in cases: |
| export_case(cfg, net, cid, dev) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
