pre/code/metrics.py

"""Mesh quality metrics: Chamfer, HD95, normal consistency, watertight, containment."""
import numpy as np


def _sample(mesh, n):
    import trimesh
    pts, fid = trimesh.sample.sample_surface(mesh, n)
    nrm = mesh.face_normals[fid]
    return np.asarray(pts), np.asarray(nrm)


def chamfer_hd95_nc(pred, gt, n=30000):
    """Returns dict with chamfer (mm), hd95 (mm), normal_consistency in [0,1]."""
    from scipy.spatial import cKDTree
    pp, pn = _sample(pred, n)
    gp, gn = _sample(gt, n)
    tp = cKDTree(pp); tg = cKDTree(gp)
    d_pg, i_pg = tg.query(pp)        # pred -> gt
    d_gp, i_gp = tp.query(gp)        # gt -> pred
    chamfer = 0.5 * (d_pg.mean() + d_gp.mean())
    hd95 = max(np.percentile(d_pg, 95), np.percentile(d_gp, 95))
    nc = 0.5 * (np.abs((pn * gn[i_pg]).sum(1)).mean() +
                np.abs((gn * pn[i_gp]).sum(1)).mean())
    return dict(chamfer_mm=float(chamfer), hd95_mm=float(hd95),
                normal_consistency=float(nc))


def dice_asd_rvd(pred, gt, pitch=0.1):
    """Volumetric metrics comparable to Duan 2021 baseline:
        Dice (volume overlap), ASD (avg symmetric surface distance, mm),
        RVD (relative volume difference). Both meshes are voxelized onto a SHARED
        grid (pitch mm) spanning their combined bounds, then compared as solids.
    Returns dict(dice, asd_mm, rvd)."""
    import trimesh
    if pred is None or gt is None:
        return dict(dice=float("nan"), asd_mm=float("nan"), rvd=float("nan"), signed_rvd=float("nan"))
    try:
        lo = np.minimum(pred.bounds[0], gt.bounds[0]) - 2 * pitch
        hi = np.maximum(pred.bounds[1], gt.bounds[1]) + 2 * pitch
        dims = np.maximum(np.ceil((hi - lo) / pitch).astype(int), 1)

        def solid(mesh):
            try:
                v = mesh.voxelized(pitch).fill()
                idx = np.round((v.points - lo) / pitch).astype(int)
                vol = np.zeros(dims, bool)
                ok = np.all((idx >= 0) & (idx < dims), axis=1)
                idx = idx[ok]
                vol[idx[:, 0], idx[:, 1], idx[:, 2]] = True
                return vol
            except Exception:
                return None

        pv, gv = solid(pred), solid(gt)
        if pv is None or gv is None:
            return dict(dice=float("nan"), asd_mm=float("nan"), rvd=float("nan"), signed_rvd=float("nan"))
        inter = np.logical_and(pv, gv).sum()
        dice = 2.0 * inter / (pv.sum() + gv.sum() + 1e-9)
        rvd = (pv.sum() - gv.sum()) / (gv.sum() + 1e-9)
        # ASD from surface samples (reuse chamfer-style nearest distances)
        from scipy.spatial import cKDTree
        pp, _ = _sample(pred, 20000); gp, _ = _sample(gt, 20000)
        d_pg, _ = cKDTree(gp).query(pp)
        d_gp, _ = cKDTree(pp).query(gp)
        asd = 0.5 * (d_pg.mean() + d_gp.mean())
        return dict(dice=float(dice), asd_mm=float(asd),
                    rvd=float(abs(rvd)), signed_rvd=float(rvd))
    except Exception:
        return dict(dice=float("nan"), asd_mm=float("nan"), rvd=float("nan"), signed_rvd=float("nan"))


def watertight(mesh):
    try:
        return bool(mesh.is_watertight)
    except Exception:
        return False


def containment_rate(canal_mesh, tooth_mesh, n=20000):
    """Fraction of canal surface points lying inside the tooth mesh.
    Tries trimesh.contains (ray), then signed_distance, then a voxelized
    point-in-volume test, so it returns a real number on headless servers."""
    if canal_mesh is None or tooth_mesh is None:
        return float("nan")
    import numpy as np
    import trimesh
    try:
        pts, _ = trimesh.sample.sample_surface(canal_mesh, n)
    except Exception:
        pts = canal_mesh.vertices
    pts = np.asarray(pts)

    # 1) ray-based contains (needs a backend; may raise/warn on headless)
    try:
        inside = tooth_mesh.contains(pts)
        if inside is not None and len(inside) == len(pts):
            return float(np.mean(inside))
    except Exception:
        pass
    # 2) signed distance (positive inside in trimesh convention)
    try:
        from trimesh.proximity import signed_distance
        sd = signed_distance(tooth_mesh, pts)
        return float(np.mean(sd > 0))
    except Exception:
        pass
    # 3) voxelize the tooth solid and test point membership
    try:
        pitch = max(tooth_mesh.extents.max() / 64.0, 1e-3)
        vox = tooth_mesh.voxelized(pitch).fill()
        inside = vox.is_filled(pts)
        return float(np.mean(inside))
    except Exception:
        return float("nan")


def _apex_point_from_gt(gt, apex_mm, n=20000):
    """Orientation-free apex localization on the GT canal.
    The canal runs crown(pulp chamber, WIDE) -> apex(root tip, NARROW). We take the
    two extremes along the canal's principal axis and pick the NARROWER one (fewer GT
    surface points within apex_mm) as the apex. Returns (apex_pt[3], gt_pts[n,3]) or
    (None, None) if the canal is too small to localize an apex."""
    gp, _ = _sample(gt, n)
    if len(gp) < 50:
        return None, None
    c = gp.mean(0)
    X = gp - c
    # first principal direction via SVD
    try:
        u = np.linalg.svd(X, full_matrices=False)[2][0]
    except Exception:
        return None, None
    t = X @ u
    lo_end = gp[int(t.argmin())]
    hi_end = gp[int(t.argmax())]
    n_lo = int((np.linalg.norm(gp - lo_end, axis=1) <= apex_mm).sum())
    n_hi = int((np.linalg.norm(gp - hi_end, axis=1) <= apex_mm).sum())
    apex_pt = lo_end if n_lo <= n_hi else hi_end
    return apex_pt, gp


def apex_metrics(pred, gt, apex_mm=3.0, pitch=0.1):
    """Apex-restricted canal metrics (the clinically important root-tip region).
    All quantities are computed ONLY within `apex_mm` of the GT apex point.
    Returns apex_dice, apex_asd_mm, apex_hd95_mm, apex_signed_rvd (signed: + = pred
    too thick / over-extended at the apex, - = pred too thin / missing apex)."""
    nan = float("nan")
    blank = dict(apex_dice=nan, apex_asd_mm=nan, apex_hd95_mm=nan, apex_signed_rvd=nan)
    if pred is None or gt is None:
        return blank
    try:
        from scipy.spatial import cKDTree
        apex_pt, gp = _apex_point_from_gt(gt, apex_mm)
        if apex_pt is None:
            return blank
        pp, _ = _sample(pred, 20000)

        gm = np.linalg.norm(gp - apex_pt, axis=1) <= apex_mm     # GT apex surface
        pm = np.linalg.norm(pp - apex_pt, axis=1) <= apex_mm     # pred apex surface
        gp_a = gp[gm]
        pp_a = pp[pm]
        if len(gp_a) < 10:
            return blank

        # --- apex ASD / HD95 ---
        # gt-apex -> nearest pred surface (full): "is the true apex reconstructed?"
        d_g = cKDTree(pp).query(gp_a)[0]
        if len(pp_a) >= 10:
            d_p = cKDTree(gp).query(pp_a)[0]           # pred-apex -> nearest GT
            apex_asd = 0.5 * (d_g.mean() + d_p.mean())
            apex_hd95 = max(np.percentile(d_g, 95), np.percentile(d_p, 95))
        else:
            # pred has (almost) nothing at the apex -> missed apex
            apex_asd = float(d_g.mean())
            apex_hd95 = float(np.percentile(d_g, 95))

        # --- apex Dice / signed-RVD on a shared voxel grid in an apex box ---
        import trimesh
        lo = apex_pt - apex_mm
        hi = apex_pt + apex_mm

        def solid_box(mesh):
            try:
                v = mesh.voxelized(pitch).fill()
                pts = v.points
                keep = np.all((pts >= lo) & (pts <= hi), axis=1)
                pts = pts[keep]
                if len(pts) == 0:
                    return np.zeros((0, 3))
                return np.round((pts - lo) / pitch).astype(int)
            except Exception:
                return None

        dims = np.maximum(np.ceil((hi - lo) / pitch).astype(int) + 1, 1)
        pi = solid_box(pred)
        gi = solid_box(gt)
        if pi is None or gi is None:
            return dict(apex_asd_mm=float(apex_asd), apex_hd95_mm=float(apex_hd95),
                        apex_dice=nan, apex_signed_rvd=nan)

        def to_vol(idx):
            vol = np.zeros(dims, bool)
            if len(idx):
                ok = np.all((idx >= 0) & (idx < dims), axis=1)
                idx = idx[ok]
                vol[idx[:, 0], idx[:, 1], idx[:, 2]] = True
            return vol

        pv, gv = to_vol(pi), to_vol(gi)
        inter = np.logical_and(pv, gv).sum()
        apex_dice = 2.0 * inter / (pv.sum() + gv.sum() + 1e-9)
        apex_srvd = (pv.sum() - gv.sum()) / (gv.sum() + 1e-9)
        return dict(apex_dice=float(apex_dice), apex_asd_mm=float(apex_asd),
                    apex_hd95_mm=float(apex_hd95), apex_signed_rvd=float(apex_srvd))
    except Exception:
        return blank