pre/code/cleaning.py

"""Root-canal label cleaning (Stage 0).

Implements the three-step cleaning from the report:
  1. connected components (26-connectivity)
  2. remove specks smaller than a voxel threshold  (NOT keep-largest, so real
     multi-canals in molars survive)
  3. morphological closing to bridge artifact-induced gaps  (+ optional hole fill)
Also returns before/after statistics for the QC table.
"""
import numpy as np
from scipy import ndimage as ndi
from skimage import morphology

_FULL26 = np.ones((3, 3, 3), dtype=int)


def _ball(radius):
    return morphology.ball(int(radius)) if radius and radius > 0 else None


def clean_binary(mask, speck_min_voxels=30, closing_radius=1, fill_holes=True):
    """Clean a single binary structure. Returns (cleaned_mask, stats)."""
    mask = mask.astype(bool)
    lab, n = ndi.label(mask, structure=_FULL26)
    stats = dict(n_components_before=int(n),
                 voxels_before=int(mask.sum()))
    if n == 0:
        stats.update(n_components_after=0, voxels_after=0, removed_specks=0,
                     largest_ratio=0.0)
        return mask, stats

    sizes = ndi.sum(np.ones_like(lab), lab, index=np.arange(1, n + 1))
    largest = float(sizes.max())
    stats["largest_ratio"] = float(largest / max(mask.sum(), 1))

    keep = np.zeros_like(mask)
    removed = 0
    for i, s in enumerate(sizes, start=1):
        if s >= speck_min_voxels:
            keep |= (lab == i)
        else:
            removed += 1
    # safety: if threshold removed everything, fall back to largest component
    if not keep.any():
        keep = (lab == (1 + int(np.argmax(sizes))))

    if closing_radius and closing_radius > 0:
        keep = ndi.binary_closing(keep, structure=_ball(closing_radius))
    if fill_holes:
        keep = ndi.binary_fill_holes(keep)

    lab2, n2 = ndi.label(keep, structure=_FULL26)
    stats.update(n_components_after=int(n2),
                 voxels_after=int(keep.sum()),
                 removed_specks=int(removed))
    return keep.astype(bool), stats


def _nearest_body_field(body_map):
    """For every voxel, the id of the spatially nearest tooth body.
    Propagates body ids into the pulp space / background via the EDT, so a canal
    voxel sitting inside a tooth resolves to that tooth's id regardless of how the
    raw canal label was numbered."""
    inds = ndi.distance_transform_edt(body_map == 0, return_indices=True)[1]
    return body_map[tuple(inds)]


def build_instances(label_xyz, cfg):
    """From the raw multi-label volume build per-tooth (body, canal) instances.

    Returns dict instance_id(1..28) -> {body: bool[x,y,z], canal: bool[x,y,z],
    tooth_solid: bool[x,y,z]} plus an aggregate cleaning report list.

    pair_mode (label_scheme.pair_mode):
      'geometric' (default) -- assign each canal component to the tooth BODY it
            physically sits inside (nearest-body), ignoring the raw canal id.
            Robust to mis-numbered / offset-shifted annotations (the cause of the
            canal<->tooth ID mismatches found in QC, e.g. cases 032/035/013/014).
      'offset' -- legacy: pair canal label i with body label i+pair_offset.
    """
    ls = cfg["label_scheme"]
    pp = cfg["preprocess"]
    off = ls["pair_offset"]
    mode = ls.get("pair_mode", "geometric")
    report = []
    instances = {}

    if mode == "offset":
        for i in range(ls["canal_lo"], ls["canal_hi"] + 1):
            canal_raw = (label_xyz == i)
            body_raw = (label_xyz == (i + off))
            if not canal_raw.any() and not body_raw.any():
                continue
            canal, st = clean_binary(canal_raw,
                                     speck_min_voxels=pp["speck_min_voxels"],
                                     closing_radius=pp["closing_radius"],
                                     fill_holes=pp["fill_holes"])
            st["instance"] = i
            report.append(st)
            tooth_solid = ndi.binary_fill_holes((body_raw | canal).astype(bool))
            canal = canal & tooth_solid
            instances[i] = dict(body=body_raw, canal=canal, tooth_solid=tooth_solid)
        return instances, report

    # ---------- geometric re-pairing (default) ----------
    # 1) body label map (id = canal-equivalent index i; body lives at label i+off)
    body_map = np.zeros(label_xyz.shape, dtype=np.int16)
    body_ids = []
    for i in range(ls["canal_lo"], ls["canal_hi"] + 1):
        bmask = (label_xyz == (i + off))
        if bmask.any():
            body_map[bmask] = i
            body_ids.append(i)
    if not body_ids:
        return instances, report

    # 2) clean the WHOLE canal volume once, then split into components
    canal_all = np.zeros(label_xyz.shape, dtype=bool)
    for i in range(ls["canal_lo"], ls["canal_hi"] + 1):
        canal_all |= (label_xyz == i)
    canal_all, _ = clean_binary(canal_all,
                                speck_min_voxels=pp["speck_min_voxels"],
                                closing_radius=pp["closing_radius"],
                                fill_holes=pp["fill_holes"])

    # 3) nearest-body id for every voxel
    nearest = _nearest_body_field(body_map)

    # 4) assign each canal component to the tooth it sits inside (majority vote)
    cc, ncc = ndi.label(canal_all, structure=_FULL26)
    assigned = {i: np.zeros(label_xyz.shape, dtype=bool) for i in body_ids}
    n_reassigned = 0
    n_orphan = 0
    for k in range(1, ncc + 1):
        comp = (cc == k)
        votes = nearest[comp]
        votes = votes[votes > 0]
        if votes.size == 0:
            n_orphan += int(comp.sum())
            continue
        vals, counts = np.unique(votes, return_counts=True)
        tgt = int(vals[counts.argmax()])
        conf = float(counts.max() / votes.size)
        if conf < 0.5 or tgt not in assigned:      # ambiguous -> drop as orphan
            n_orphan += int(comp.sum())
            continue
        assigned[tgt] |= comp
        # would the legacy offset rule have put this elsewhere? (diagnostic only)
        raw_here = label_xyz[comp]
        raw_here = raw_here[(raw_here >= ls["canal_lo"]) & (raw_here <= ls["canal_hi"])]
        if raw_here.size:
            raw_id = int(np.bincount(raw_here).argmax())
            if raw_id != tgt:
                n_reassigned += int(comp.sum())

    # 5) materialize instances
    for i in body_ids:
        body_raw = (label_xyz == (i + off))
        canal = assigned[i]
        tooth_solid = ndi.binary_fill_holes((body_raw | canal).astype(bool))
        canal = canal & tooth_solid
        instances[i] = dict(body=body_raw, canal=canal, tooth_solid=tooth_solid)

    report.append(dict(pairing="geometric", n_components=int(ncc),
                       voxels_reassigned=int(n_reassigned),
                       voxels_orphaned=int(n_orphan),
                       n_instances=len(body_ids)))
    return instances, report