DiffAtlas/test/evaluate.py

import os
import io
import blobfile as bf
import torch as th
import sys
parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
sys.path.insert(0, parent_dir)
from ddpm import Unet3D, GaussianDiffusion_Nolatent
from Dataset.TS_Dataset import get_TS_dataloader
from Dataset.MMWHS_Dataset import get_MMWHS_dataloader
import torchio as tio
from omegaconf import DictConfig
import hydra
import numpy as np
import torch
from omegaconf import OmegaConf
import atexit
import torch.nn as nn
import torch.nn.functional as F
import scipy.ndimage as ndimage
from scipy.ndimage import distance_transform_edt
from datetime import datetime
import time

def squeeze_and_expand(img, num_slice=32):
    original_shape = img.shape[2:]
    original_img = img.clone()
    step = img.shape[2] // num_slice
    img = img[...,::step, :, :]
    img = F.interpolate(img, size=original_shape, mode='trilinear', align_corners=False)
    img[...,::step, :, :] = original_img[...,::step, :, :]
    return img

def zoom_in_and_out(img, zoom_factor=2):
    original_shape = img.shape[2:]
    original_img = img.clone()
    new_shape = (int(original_shape[0] // zoom_factor), 
                 int(original_shape[1] // zoom_factor), 
                 int(original_shape[2] // zoom_factor))
    img = F.interpolate(img, size=new_shape, mode='trilinear', align_corners=False)
    img = F.interpolate(img, size=original_shape, mode='trilinear', align_corners=False)
    img[..., ::zoom_factor, ::zoom_factor, ::zoom_factor] = original_img[..., ::zoom_factor, ::zoom_factor, ::zoom_factor]
    return img

def degrade_img_only(img, degrade_type):
    if degrade_type == 'none':
        return img
    elif degrade_type == 'res32':
        return squeeze_and_expand(img, num_slice=32)
    elif degrade_type == 'res16':
        return squeeze_and_expand(img, num_slice=16)
    elif degrade_type == 'res8':
        return squeeze_and_expand(img, num_slice=8)
    elif degrade_type == 'res4':
        return squeeze_and_expand(img, num_slice=4)
    elif degrade_type == 'vol32':
        return zoom_in_and_out(img, zoom_factor=2)
    elif degrade_type == 'vol16':
        return zoom_in_and_out(img, zoom_factor=4)
    elif degrade_type == 'vol8':
        return zoom_in_and_out(img, zoom_factor=8)
    elif degrade_type == 'vol4':
        return zoom_in_and_out(img, zoom_factor=16)
    else:
        return img
def get_degrade_mask(degrade_type):
    mask = torch.zeros((1, 1, 64, 64, 64), dtype=torch.float32)
    if degrade_type == 'none':
        mask[...] = 1
    elif degrade_type == 'res32':
        step = 2
        mask[0, 0, ::step, :, :] = 1
    elif degrade_type == 'res16':
        step = 4
        mask[0, 0, ::step, :, :] = 1
    elif degrade_type == 'res8':
        step = 8
        mask[0, 0, ::step, :, :] = 1
    elif degrade_type == 'res4':
        step = 16
        mask[0, 0, ::step, :, :] = 1
    elif degrade_type == '2d':
        mask[0, 0, 32, :, :] = 1
    elif degrade_type == 'mid4':
        width = 4
        mask[0, 0, 32-width//2:32+width//2, :, :] = 1
        mask = 1 - mask
    elif degrade_type == 'mid8':
        width = 8
        mask[0, 0, 32-width//2:32+width//2, :, :] = 1
        mask = 1 - mask
    elif degrade_type == 'mid16':
        width = 16
        mask[0, 0, 32-width//2:32+width//2, :, :] = 1
        mask = 1 - mask
    elif degrade_type == 'mid32':
        width = 32
        mask[0, 0, 32-width//2:32+width//2, :, :] = 1
        mask = 1 - mask
    elif degrade_type == 'mid64':
        width = 64
        mask[0, 0, 32-width//2:32+width//2, :, :] = 1
        mask = 1 - mask
    elif degrade_type == 'none':
        mask[...] = 1
    elif degrade_type == 'vol32':
        mask[0, 0, ::2, ::2, ::2] = 1
    elif degrade_type == 'vol16':
        mask[0, 0, ::4, ::4, ::4] = 1
    elif degrade_type == 'vol8':
        mask[0, 0, ::8, ::8, ::8] = 1
    else:
        raise ValueError("Invalid degrade type")
    return mask

def dev(device):
    if device is None:
        if th.cuda.is_available():
            return th.device(f"cuda")
        return th.device("cpu")
    return th.device(device)


def load_state_dict(path, backend=None, **kwargs):
    with bf.BlobFile(path, "rb") as f:
        data = f.read()
    return th.load(io.BytesIO(data), **kwargs)


try:
    import ctypes
    libgcc_s = ctypes.CDLL('libgcc_s.so.1')
except:
    pass

def get_dice(preds, labels):
    assert preds.shape[0] == labels.shape[0], "predict & target batch size don't match"
    predict = preds.reshape(preds.shape[0], -1)
    target = labels.reshape(labels.shape[0], -1)
    if np.sum(target) == 0 and np.sum(predict) == 0:
        return 1.0
    else:
        num = np.sum(np.multiply(predict, target), axis=1)
        den = np.sum(predict, axis=1) + np.sum(target, axis=1)
        dice = 2 * num / den
        return dice.mean()

def ignore_background(y_pred: torch.Tensor, y: torch.Tensor):
    return y_pred[:, 1:], y[:, 1:]

def prepare_spacing(spacing, batch_size, img_dim):
    if spacing is None:
        spacing = tuple([1.0] * img_dim)
    if isinstance(spacing, (int, float)):
        spacing = tuple([float(spacing)] * img_dim)
    elif isinstance(spacing, (tuple, list)):
        if len(spacing) == 1:
            spacing = tuple([float(spacing[0])] * img_dim)
        elif len(spacing) == img_dim:
            spacing = tuple(float(s) for s in spacing)
        else:
            raise ValueError("spacing should be a number or sequence of numbers matching image dimensions")
    return [spacing] * batch_size

def get_edge_surface_distance(pred, gt, distance_metric="euclidean", spacing=None, use_subvoxels=False, symmetric=True, class_index=None):
    pred = pred.cpu().numpy().astype(bool)
    gt = gt.cpu().numpy().astype(bool)
    
    edges_pred = ndimage.binary_dilation(pred).astype(bool) ^ pred
    edges_gt = ndimage.binary_dilation(gt).astype(bool) ^ gt
    
    if distance_metric == "euclidean":
        dt_pred = distance_transform_edt(~edges_pred, sampling=spacing)
        dt_gt = distance_transform_edt(~edges_gt, sampling=spacing)
    else:
        raise ValueError(f"Unsupported distance metric: {distance_metric}")
    
    distances_pred_gt = dt_gt[edges_pred]
    distances_gt_pred = dt_pred[edges_gt]
    
    areas = None
    return (edges_pred, edges_gt), (distances_pred_gt, distances_gt_pred), areas


def compute_surface_dice(y_pred, y, class_thresholds, include_background=False, 
                       distance_metric="euclidean", spacing=None, use_subvoxels=False):
    if not include_background:
        y_pred, y = ignore_background(y_pred=y_pred, y=y)

    if not isinstance(y_pred, torch.Tensor) or not isinstance(y, torch.Tensor):
        raise ValueError("y_pred and y must be PyTorch Tensor.")

    if y_pred.ndimension() not in (4, 5) or y.ndimension() not in (4, 5):
        raise ValueError("y_pred and y should be one-hot encoded: [B,C,H,W] or [B,C,H,W,D].")

    if y_pred.shape != y.shape:
        raise ValueError(
            f"y_pred and y should have same shape, but instead, shapes are {y_pred.shape} (y_pred) and {y.shape} (y)."
        )

    batch_size, n_class = y_pred.shape[:2]
    img_dim = y_pred.ndim - 2
    spacing_list = prepare_spacing(spacing=spacing, batch_size=batch_size, img_dim=img_dim)
    nsd = torch.empty((batch_size, n_class), device=y_pred.device, dtype=torch.float)

    for b, c in np.ndindex(batch_size, n_class):
        (edges_pred, edges_gt), (distances_pred_gt, distances_gt_pred), areas = get_edge_surface_distance(
            y_pred[b, c],
            y[b, c],
            distance_metric=distance_metric,
            spacing=spacing_list[b],
            use_subvoxels=use_subvoxels,
            symmetric=True,
            class_index=c,
        )
        
        boundary_complete = len(distances_pred_gt) + len(distances_gt_pred)
        boundary_correct = torch.sum(torch.tensor(distances_pred_gt <= class_thresholds[c])) + \
                         torch.sum(torch.tensor(distances_gt_pred <= class_thresholds[c]))

        if boundary_complete == 0:
            nsd[b, c] = torch.tensor(float('nan'))
        else:
            nsd[b, c] = boundary_correct / boundary_complete

    return nsd

class NSDMetric(nn.Module):
    def __init__(self, n_classes):
        super(NSDMetric, self).__init__()
        self.n_classes = n_classes
        self.class_thresholds = [1.0] * n_classes  

    def forward(self, inputs, target, spacing=(1.0, 1.0, 1.0), softmax=False):
        if softmax:
            inputs = torch.softmax(inputs, dim=1)
        
        inputs = F.one_hot(inputs, num_classes=self.n_classes).permute(0, 4, 1, 2, 3).float()
        target = F.one_hot(target, num_classes=self.n_classes).permute(0, 4, 1, 2, 3).float()
        
        nsd_scores = compute_surface_dice(
            inputs, 
            target,
            class_thresholds=self.class_thresholds,
            include_background=False,
            spacing=spacing
        )
        
        return nsd_scores[0]  

class Tee:
    def __init__(self, *files):
        self.files = files
    
    def write(self, obj):
        for f in self.files:
            f.write(obj)
            f.flush()  
    
    def flush(self):
        for f in self.files:
            f.flush()


def generate_results(dataloader, diffusion, device, conf):
    if conf.degrade_type.endswith('_img'):
        conf.degrade_type = conf.degrade_type[:-4]
        degrade_mask = get_degrade_mask(conf.degrade_type)
        degrade_img = True
    elif conf.degrade_type.startswith('vol'):
        degrade_mask = get_degrade_mask(conf.degrade_type)
        degrade_img = True
    else:
        degrade_mask = get_degrade_mask(conf.degrade_type)
        degrade_img = False
    print(f"Degrade type: {conf.degrade_type}, Degrade img: {degrade_img}")
    
    for batch in iter(dataloader):
        begin = time.time()
        for k in batch.keys():
            if isinstance(batch[k], th.Tensor):
                batch[k] = batch[k].to(device)
                affine = batch['affine'].squeeze(0).cpu()

        real_image = batch["img"]
        real_mask = batch.get('mask').cpu()
        real_mask_sdf = batch.get('mask_sdf').cpu()
        gt_name = batch['name']
        if degrade_img:
            real_image = degrade_img_only(real_image, conf.degrade_type)
        # gt_name = gt_name.split('_image')[0]
        # gt_name = gt_name.split('-image')[0]

        print(f"Generating for {gt_name}")


        # sample_fn = diffusion.p_sample_loop
        sample_fn = diffusion.p_sample_loop_universal_guidance

        result = sample_fn(
            shape_image=real_image.size(),
            shape_mask=real_mask_sdf.size(),
            device=device,
            image=real_image,
            degrade_mask=degrade_mask,
            # delta=conf.delta,
            guidance_scale=0.5,
            use_ddim=False,
            guidance_start_t=150,
            guidance_strategy='last_n',
        )

        gen_image = result[:, 0, :, :, :].cpu()
        gen_mask = result[:, 1:(result.size()[1]), :, :, :].cpu()

        for b in range(real_image.size(0)):
            name = gt_name[b].split('_image')[0]
            res = [real_image[b:b+1], real_mask[b:b+1], gen_image[b:b+1], gen_mask[b:b+1], name]
            os.makedirs(conf.target_path, exist_ok=True)
            torch.save(res, os.path.join(conf.target_path, f"{name}.pt"))
    
        end = time.time()
        print(f"exp_dir: {conf.target_path}")
        print(f"Time per batch: {end - begin:.2f}s")
        
        # break #### break debug


def evaluate_metrics(results, conf):
    dice_total = [0, 0, 0, 0, 0]
    nsd_total = [0, 0, 0, 0, 0]

    for real_image, real_mask, gen_image, gen_mask, gt_name in results:
        dice = []
        for i in range(gen_mask.size()[1]):
            gen_mask_i = gen_mask[:,i,:,:,:]
            gen_mask_i = gen_mask_i.cpu()
            # gen_mask_i_de_sdf = torch.where(gen_mask_i < 0.07, torch.tensor(1.0), torch.tensor(0.0))
            # gen_mask_i_de_sdf = sdf_to_voxel(gen_mask_i.squeeze(0), level=0.07)
            # gen_mask_i_de_sdf = torch.from_numpy(gen_mask_i_de_sdf).unsqueeze(0)
            gen_mask_i_de_sdf = torch.where(gen_mask_i < 0.0, torch.tensor(1.0), torch.tensor(0.0))
            real_mask_i = real_mask[:,i,:,:,:]
            Dice = get_dice(real_mask_i.numpy(), gen_mask_i_de_sdf.numpy())
            # print(f"        {i+1}_dice:", Dice)
            dice.append(Dice)
            dice_total[i] += Dice
            
        get_nsd = NSDMetric(n_classes=6)
        background_mask = torch.where((gen_mask <= 0.0).sum(dim=1) > 0, torch.tensor(0.0), torch.tensor(1.0))
        gen_mask_togather = torch.where(background_mask == 0, torch.argmin(gen_mask, dim=1)+1, torch.tensor(0.0))
        background_mask = torch.where((real_mask > 0).sum(dim=1) > 0, torch.tensor(0.0), torch.tensor(1.0))
        real_mask_togather = torch.where(background_mask == 0, torch.argmax(real_mask, dim=1)+1, torch.tensor(0.0))
        nnsd = get_nsd(inputs=gen_mask_togather.long(), target=real_mask_togather.long())

        for i in range(0, 5):
            nsd_total[i] += nnsd[i]

        print(f"    {gt_name}:")
        # print(f"     Dice: {dice}")
        # print(f"     NSD: {nnsd}")
        print(f"     Dice: {sum(dice)/len(dice): .4f}")
        print(f"     NSD: {sum(nnsd)/len(nnsd): .4f}")
    dice_total_avg = [item / len(results) for item in dice_total]
    nsd_total_avg = [item / len(results) for item in nsd_total]
    print(conf.target_path)
    print("Total average:")
    print(f"    Dice: {dice_total_avg}")
    print(f"    NSD: {nsd_total_avg}")


@hydra.main(config_path='confs', config_name='infer', version_base=None)
def main(conf: DictConfig):
    print(OmegaConf.to_container(conf, resolve=True))

    device = dev(conf.get('device'))
    model = Unet3D(
        dim=conf.diffusion_img_size,
        dim_mults=conf.dim_mults,
        channels=conf.diffusion_num_channels,
        cond_dim=16,
    )

    diffusion = GaussianDiffusion_Nolatent(
        model,
        image_size=conf.diffusion_img_size,
        num_frames=conf.diffusion_depth_size,
        channels=conf.diffusion_num_channels,
        timesteps=conf.timesteps,
        loss_type=conf.loss_type,
    )
    diffusion.to(device)

    weights_dict = {}
    for k, v in (load_state_dict(os.path.expanduser(conf.model_path), map_location="cpu")["model"].items()):
        new_k = k.replace('module.', '') if 'module' in k else k
        weights_dict[new_k] = v

    diffusion.load_state_dict(weights_dict)
    model.eval()
    BS = 4
    if conf.dataset == 'MMWHS':
        dataloader = get_MMWHS_dataloader(root_dir=conf.root_dir, mode=conf.mode, data_type=conf.data_type, batch_size=BS)
    elif conf.dataset == 'TS':
        dataloader = get_TS_dataloader(root_dir=conf.root_dir, mode=conf.mode, batch_size=BS)
    else:
        raise ValueError("No Such Dataset")
    
    

    if conf.gen == 1:
        # Generate results
        tag = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
        conf.target_path = os.path.join(conf.target_path, tag)
        if not os.path.exists(conf.target_path):
            os.makedirs(conf.target_path, exist_ok=True)
            generate_results(dataloader, diffusion, device, conf)
        else:
            print(f"Target path {conf.target_path} already exists!")
            exit(0)
    else:
        conf.target_path = 'evaluate/test_set_TS_20_percent/evaluate_240_seg_mid8_guide_150_step3_0.5_hybrid_full/2025-11-19_15-47-03'
    
    # Load results
    results = []
    for file in os.listdir(conf.target_path):
        if file.endswith(".pt"):
            res = torch.load(os.path.join(conf.target_path, file))
            results.append(res)
    # Evaluate metrics
    evaluate_metrics(results, conf)


if __name__ == "__main__":
    main()