toothcanal/evaluate.py

"""Evaluate reconstruction quality on the held-out test cases.

Builds GT meshes from the (cleaned) GT masks with the SAME marching-cubes rule,
reconstructs predictions, and reports Chamfer / HD95 / Normal-Consistency /
watertight rate / canal-in-tooth containment.

    python -m toothcanal.evaluate --config configs/default.yaml
"""
import os, csv, 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, marching_cubes_to_mesh
from .models import ImplicitNet
from .infer import reconstruct_instance
from .metrics import chamfer_hd95_nc, watertight, containment_rate, dice_asd_rvd, apex_metrics


def _gt_wise_primary(inst_pred, match, gt_inst, ids):
    """Stage-1 over-splitting fix (evaluation-side, no retrain).
    Keep ONE predicted instance per GT tooth -- the one with the largest voxel
    overlap. The remaining predictions for that tooth are over-splits and must NOT
    each be scored against the same GT (that double-penalises reconstruction).
    Returns (primary_ids, detection_stats)."""
    best = {}                                   # gt_id -> (pred_id, overlap)
    for pid in ids:
        gid = match.get(pid)
        if not gid or gid <= 0:
            continue
        ov = int(((inst_pred == pid) & (gt_inst == gid)).sum())
        if ov <= 0:
            continue
        if gid not in best or ov > best[gid][1]:
            best[gid] = (pid, ov)
    primary = sorted({pid for pid, _ in best.values()})
    n_gt = len([v for v in np.unique(gt_inst) if v > 0])
    n_pred = len(ids)
    tp = len(best)                              # GT teeth matched by >=1 prediction
    extra = n_pred - tp                         # over-splits + phantom detections
    prec = tp / n_pred if n_pred else 0.0
    rec = tp / n_gt if n_gt else 0.0
    f1 = 2 * prec * rec / (prec + rec) if (prec + rec) else 0.0
    return primary, dict(n_gt=n_gt, n_pred=n_pred, matched=tp, extra=extra,
                         precision=prec, recall=rec, f1=f1)


def gt_meshes(d, iid, cfg):
    s2 = cfg["stage2"]
    ev = cfg.get("eval", {})
    # GT resolution is decoupled from the model's roi_vox so BOTH a 96-voxel model and
    # a 144-voxel model are scored against the SAME ground-truth mesh (fair Dice).
    gt_vox = int(ev.get("gt_roi_vox", s2["roi_vox"]))
    g = int(ev.get("gt_grid", cfg["infer"]["grid"]))
    roi = crop_roi(d, iid, s2["roi_mm"], gt_vox, center_mode=s2.get("roi_center", "com"))
    if roi is None:
        return None, None
    import scipy.ndimage as ndi
    zt = ndi.zoom(roi["solid"].astype(np.float32), np.array([g] * 3) / gt_vox, order=0) > 0.5
    zc = ndi.zoom(roi["canal"].astype(np.float32), np.array([g] * 3) / gt_vox, order=0) > 0.5
    spg = np.array([s2["roi_mm"] / g] * 3)
    tooth = marching_cubes_to_mesh(sdf_from_mask(zt, spg), 0.0, spg, pad=True)
    canal = marching_cubes_to_mesh(sdf_from_mask(zc, spg), 0.0, spg, pad=True)
    return tooth, canal


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--config", default="configs/default.yaml")
    ap.add_argument("--roi_source", default=None, choices=[None, "oracle", "predicted"])
    ap.add_argument("--tag", default="")
    args = ap.parse_args()
    cfg = load_config(args.config)
    set_seed(cfg["split"]["seed"])
    dev = "cuda" if torch.cuda.is_available() else "cpu"
    roi_source = args.roi_source or cfg["infer"].get("roi_source", "oracle")
    cfg["infer"]["roi_source"] = roi_source
    apex_mm = float(cfg.get("eval", {}).get("apex_mm", 3.0))
    gt_wise = bool(cfg.get("eval", {}).get("gt_wise_predicted", True))
    det_stats = []                               # per-case Stage-1 detection metrics

    ckpt = torch.load(os.path.join(cfg["paths"]["out_dir"], cfg["stage2"].get("ckpt_name", "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()

    stage1_ckpt = os.path.join(cfg["paths"]["out_dir"], "stage1.pt")
    _, test = make_split(cfg["paths"]["proc_dir"], cfg)
    rows = []
    for cid in test:
        d = dict(np.load(os.path.join(cfg["paths"]["proc_dir"], f"{cid}.npz")))
        if roi_source == "predicted":
            if not os.path.exists(stage1_ckpt):
                raise SystemExit("[eval] predicted ROI needs stage1.pt")
            from .roi import predicted_instances
            inst_pred, match = predicted_instances(d, cfg, dev, stage1_ckpt)
            d_full = d                                # keep GT for building GT meshes
            d = dict(d); d["inst"] = inst_pred; d["cinst"] = np.zeros_like(inst_pred)
            ids = [int(v) for v in np.unique(inst_pred) if v > 0]
            if gt_wise:
                ids, dstat = _gt_wise_primary(inst_pred, match, d_full["inst"], ids)
                dstat["case"] = cid
                det_stats.append(dstat)
                print(f"[eval:predicted] {cid}: {dstat['n_pred']} predicted -> "
                      f"{dstat['matched']}/{dstat['n_gt']} GT matched, "
                      f"{dstat['extra']} over-detections dropped (GT-wise)")
        else:
            match = {iid: iid for iid in np.unique(d["inst"]) if iid > 0}
            d_full = d
            ids = [int(v) for v in np.unique(d["inst"]) if v > 0]
        for iid in ids:
            pred = reconstruct_instance(net, d, iid, cfg, dev, do_tto=False)
            gt_id = match.get(iid, iid)
            gt_t, gt_c = gt_meshes(d_full, gt_id, cfg)
            if pred is None or gt_t is None or pred["tooth"] is None:
                continue
            # classify single-rooted (ST) vs multi-rooted (MT). Canal components merge
            # near the pulp chamber, so we count components in the APICAL THIRD (root
            # tips), where separate roots/canals are actually distinct.
            from scipy import ndimage as _ndi
            cmask = (d_full["cinst"] == gt_id)
            ttype = "ST"
            if cmask.any():
                zs = np.argwhere(cmask)[:, 2]
                z_lo, z_hi = zs.min(), zs.max()
                apical = cmask.copy()
                # keep only the apical third along the long (z) axis
                cut = z_lo + int((z_hi - z_lo) * 0.33)
                apical[:, :, cut:] = False
                _, ncomp = _ndi.label(apical, structure=np.ones((3, 3, 3)))
                # also try the other end in case orientation is flipped
                apical2 = cmask.copy(); cut2 = z_hi - int((z_hi - z_lo) * 0.33)
                apical2[:, :, :cut2] = False
                _, ncomp2 = _ndi.label(apical2, structure=np.ones((3, 3, 3)))
                ttype = "MT" if max(ncomp, ncomp2) >= 2 else "ST"
            m = chamfer_hd95_nc(pred["tooth"], gt_t, cfg["eval"]["n_surface_samples"])
            extra = dice_asd_rvd(pred["tooth"], gt_t)
            row = dict(case=cid, inst=iid, structure="tooth", tooth_type=ttype, **m, **extra,
                       watertight=watertight(pred["tooth"]),
                       boundary_touch=float(pred.get("roi", {}).get("boundary_touch", float("nan"))))
            rows.append(row)
            if pred["canal"] is not None and gt_c is not None:
                mc = chamfer_hd95_nc(pred["canal"], gt_c, cfg["eval"]["n_surface_samples"])
                ec = dice_asd_rvd(pred["canal"], gt_c)
                ax = apex_metrics(pred["canal"], gt_c, apex_mm)
                rows.append(dict(case=cid, inst=iid, structure="canal", tooth_type=ttype,
                                 **mc, **ec, **ax,
                                 watertight=watertight(pred["canal"]),
                                 n_components=pred.get("n_canal_components", 1),
                                 containment=containment_rate(pred["canal"], pred["tooth"])))
            print(f"[eval:{roi_source}] {cid} t{iid:02d} ({ttype}) tooth chamfer={m['chamfer_mm']:.3f}mm "
                  f"hd95={m['hd95_mm']:.3f}mm")

    out = ensure_dir(cfg["paths"]["out_dir"])
    suffix = f"_{args.tag}" if args.tag else f"_{roi_source}"
    csv_path = os.path.join(out, f"eval_metrics{suffix}.csv")
    keys = sorted({k for r in rows for k in r})
    with open(csv_path, "w", newline="") as f:
        w = csv.DictWriter(f, fieldnames=keys); w.writeheader(); w.writerows(rows)

    def agg(structure, key, ttype=None):
        vals = [r[key] for r in rows if r["structure"] == structure
                and (ttype is None or r.get("tooth_type") == ttype)
                and isinstance(r.get(key), (int, float)) and not np.isnan(r[key])]
        return float(np.mean(vals)) if vals else float("nan")
    print(f"\n===== [{roi_source}] held-out test summary =====")
    def agg_med(structure, key, ttype=None):
        vals = [r[key] for r in rows if r["structure"] == structure
                and (ttype is None or r.get("tooth_type") == ttype)
                and isinstance(r.get(key), (int, float)) and not np.isnan(r[key])]
        return float(np.median(vals)) if vals else float("nan")
    for s in ["tooth", "canal"]:
        print(f"{s:6s} | chamfer={agg(s,'chamfer_mm'):.3f}mm  hd95={agg(s,'hd95_mm'):.3f}mm  "
              f"NC={agg(s,'normal_consistency'):.3f}")
        print(f"       | Dice={agg(s,'dice'):.3f}  ASD={agg(s,'asd_mm'):.3f}mm  RVD={agg(s,'rvd'):.3f}  "
              f"(<-- comparable to Duan 2021 baseline)")
        sr = agg_med(s, "signed_rvd")
        verdict = "thicker than GT" if sr > 0.05 else ("thinner/under than GT" if sr < -0.05 else "~balanced")
        print(f"       | signed_RVD (median) = {sr:+.3f}  ->  predicted {s} is {verdict}")
    bt = [r.get("boundary_touch") for r in rows if r["structure"] == "tooth"
          and isinstance(r.get("boundary_touch"), (int, float)) and not np.isnan(r.get("boundary_touch"))]
    if bt:
        clipped = sum(1 for x in bt if x > 0.01)
        print(f"tooth ROI clipping: {clipped}/{len(bt)} teeth touch an ROI face "
              f"(>1% of solid on boundary)  median touch={np.median(bt):.4f}")
    print(f"canal containment (in-tooth) = {agg('canal','containment'):.3f}")
    ad = agg_med("canal", "apex_dice"); asr = agg_med("canal", "apex_signed_rvd")
    ahd = agg_med("canal", "apex_hd95_mm")
    av = "thicker/over-extended" if asr > 0.05 else ("thinner/missing" if asr < -0.05 else "~balanced")
    print(f"canal APEX (root tip, {apex_mm:.0f}mm): Dice={ad:.3f}  HD95={ahd:.3f}mm  "
          f"signed_RVD={asr:+.3f} -> apex is {av}")
    print(f"--- by tooth type (ST=single-rooted, MT=multi-rooted) ---")
    for tt in ["ST", "MT"]:
        n = len({r['inst'] for r in rows if r.get('tooth_type') == tt})
        ncomp = [r.get('n_components') for r in rows if r.get('tooth_type') == tt
                 and r['structure'] == 'canal' and isinstance(r.get('n_components'), (int, float))]
        mean_comp = float(np.mean(ncomp)) if ncomp else float('nan')
        print(f"  {tt} (n={n}): tooth chamfer={agg('tooth','chamfer_mm',tt):.3f}mm  "
              f"canal chamfer={agg('canal','chamfer_mm',tt):.3f}mm  "
              f"canal Dice={agg('canal','dice',tt):.3f}  "
              f"mean canal components={mean_comp:.2f}")
    if det_stats:
        N_gt = sum(s["n_gt"] for s in det_stats); N_pred = sum(s["n_pred"] for s in det_stats)
        N_match = sum(s["matched"] for s in det_stats); N_extra = sum(s["extra"] for s in det_stats)
        P = N_match / N_pred if N_pred else 0.0
        R = N_match / N_gt if N_gt else 0.0
        F = 2 * P * R / (P + R) if (P + R) else 0.0
        print(f"--- Stage-1 detection (GT-wise eval) ---")
        print(f"  GT teeth={N_gt}  predicted={N_pred}  matched={N_match}  over-detections={N_extra}")
        print(f"  precision={P:.3f}  recall={R:.3f}  F1={F:.3f}")
        print(f"  (reconstruction metrics above use 1 best-overlap prediction per GT tooth)")
    print(f"metrics written to {csv_path}")


if __name__ == "__main__":
    main()