DiffAtlas/test/vis.py

#!/usr/bin/env python3
import argparse
import os
import SimpleITK as sitk
import numpy as np
import imageio
from PIL import Image, ImageFilter
import torch
import nibabel as nib

def window_image(img: sitk.Image, window_min: float, window_max: float) -> sitk.Image:
    return sitk.IntensityWindowing(
        img,
        windowMinimum=window_min,
        windowMaximum=window_max,
        outputMinimum=0.0,
        outputMaximum=255.0
    )

def create_overlay(img: sitk.Image, lbl: sitk.Image, alpha: float) -> sitk.Image:
    return sitk.LabelOverlay(image=img, labelImage=lbl, opacity=alpha, backgroundValue=0)

def get_resample_filter(name: str):
    from PIL import Image as PILImage
    mapping = {
        'nearest': PILImage.NEAREST,
        'bilinear': PILImage.BILINEAR,
        'lanczos': PILImage.LANCZOS
    }
    return mapping.get(name, PILImage.NEAREST)

def resize_image(arr: np.ndarray, width: int, height: int, resample_mode) -> np.ndarray:
    return np.array(Image.fromarray(arr).resize((width, height), resample_mode))

def sharpen_image(arr: np.ndarray, radius: float, percent: int, threshold: int) -> np.ndarray:
    return np.array(
        Image.fromarray(arr).filter(
            ImageFilter.UnsharpMask(radius=radius, percent=percent, threshold=threshold)
        )
    )

def apply_outline_slice(slice_rgb: np.ndarray, label_slice: np.ndarray, dark_factor: float) -> np.ndarray:
    label_img = sitk.GetImageFromArray(label_slice.astype(np.uint8))
    contour = sitk.LabelContour(label_img)
    contour_arr = sitk.GetArrayFromImage(contour) > 0
    dark = (slice_rgb.astype(np.float32) * dark_factor).astype(np.uint8)
    result = slice_rgb.copy()
    result[contour_arr] = dark[contour_arr]
    return result

def save_slices(slices: np.ndarray, label_arr: np.ndarray, output_dir: str,
                width: int, height: int, resample_mode,
                sharpen: bool, sharpen_params: dict,
                outline: bool, outline_factor: float):
    os.makedirs(output_dir, exist_ok=True)
    for i, slice_rgb in enumerate(slices):
        img = slice_rgb.astype(np.uint8)
        if outline and label_arr is not None:
            img = apply_outline_slice(img, label_arr[i], outline_factor)
        if width and height:
            img = resize_image(img, width, height, resample_mode)
        if sharpen:
            img = sharpen_image(
                img,
                radius=sharpen_params['radius'],
                percent=sharpen_params['percent'],
                threshold=sharpen_params['threshold']
            )
        filepath = os.path.join(output_dir, f"slice_{i:03d}.png")
        imageio.imwrite(filepath, img)

def main():
    parser = argparse.ArgumentParser(description="Generate overlay PNGs with optional mask and outline")
    parser.add_argument('image', help="Input NIfTI image file (.nii or .nii.gz)")
    parser.add_argument('--label', help="Optional NIfTI label file (.nii or .nii.gz)", default=None)
    parser.add_argument('--alpha', type=float, default=0.5, help="Overlay opacity (0.0-1.0)")
    parser.add_argument('--window-min', type=float, default=-450.0, help="Window minimum intensity")
    parser.add_argument('--window-max', type=float, default=250.0, help="Window maximum intensity")
    parser.add_argument('--width', type=int, default=1024, help="Output image width")
    parser.add_argument('--height', type=int, default=1024, help="Output image height")
    parser.add_argument('--resample', choices=['nearest','bilinear','lanczos'], default='nearest', help="Resize interpolation mode")
    parser.add_argument('--sharpen', action='store_true', help="Apply sharpening filter after resizing and outlining")
    parser.add_argument('--sharpen-radius', type=float, default=1.0, help="Sharpen radius")
    parser.add_argument('--sharpen-percent', type=int, default=150, help="Sharpen percent")
    parser.add_argument('--sharpen-threshold', type=int, default=3, help="Sharpen threshold")
    parser.add_argument('--outline', action='store_true', help="Overlay dark outline on mask edges if label provided")
    parser.add_argument('--outline-factor', type=float, default=0.7, help="Darkening factor for outline (0.0-1.0)")
    parser.add_argument('--output-dir', type=str, default='output', help="Directory to save images")
    args = parser.parse_args()



    if args.image.endswith('.pt'):
        image, *_ = torch.load(args.image, map_location='cpu')
        image = image.squeeze().cpu().numpy().transpose((2, 1, 0))
        image = sitk.GetImageFromArray(image)
    else:
        image = nib.load(args.image)
        image_data = image.get_fdata()
        image = sitk.GetImageFromArray(np.transpose(image_data, (2, 1, 0)))

    if args.label:
        if args.label.endswith('.pt'):
            *_, label, _ = torch.load(args.label, map_location='cpu')
            background_mask = torch.where((label <= 0.02).sum(dim=1) > 0, torch.tensor(0.0), torch.tensor(1.0))
            label = torch.where(background_mask == 0, torch.argmin(label, dim=1)+1, torch.tensor(0.0))
            label = label.squeeze().cpu().numpy().transpose((2, 1, 0))
            label_img = sitk.GetImageFromArray(label)
            label_img = sitk.Cast(label_img, sitk.sitkUInt8)
        else:
            label_img = nib.load(args.label)
            label_data = label_img.get_fdata()
            label_img = sitk.GetImageFromArray(np.transpose(label_data, (2, 1, 0)))
            label_img = sitk.Cast(label_img, sitk.sitkUInt8)
    
    windowed = window_image(image, args.window_min, args.window_max)
    windowed_uint8 = sitk.Cast(windowed, sitk.sitkUInt8)

    if args.label:
        overlay = create_overlay(windowed_uint8, label_img, alpha=args.alpha)
        slices = sitk.GetArrayFromImage(overlay)
        label_arr = sitk.GetArrayFromImage(label_img)
    else:
        arr = sitk.GetArrayFromImage(windowed_uint8)
        slices = np.stack([arr, arr, arr], axis=-1)  # expand to RGB
        label_arr = None

    resample_mode = get_resample_filter(args.resample)
    sharpen_params = {'radius': args.sharpen_radius,
                      'percent': args.sharpen_percent,
                      'threshold': args.sharpen_threshold}

    save_slices(
        slices, label_arr, args.output_dir,
        args.width, args.height, resample_mode,
        args.sharpen, sharpen_params,
        args.outline, args.outline_factor
    )
    print(f"Images saved to: {args.output_dir}")

if __name__ == '__main__':
    main()

    '''
    python GenMedVis.py "C:/Users/gwd200/Desktop/MSN/MMWHS-CT/MMWHS-CT/MMWHS-CT-resize-try-test/MMWHS-CT-010-image.nii.gz" --label "C:/Users/gwd200/Desktop/MSN/MMWHS-CT/MMWHS-CT/MMWHS-CT-resize-try-test/MMWHS-CT-010-label.nii.gz" --alpha 0.3 --window-min -800 --window-max +600 --outline
    '''