suppl/4_MaskEdits.py

#!/usr/bin/env python
from pathlib import Path
import argparse
import nibabel as nib
import numpy as np
import os
import multiprocessing
from time import time
import logging
import traceback
from scipy.ndimage import label as ndi_label, sum as ndi_sum
from nibabel.orientations import io_orientation, axcodes2ornt, ornt_transform
from scipy.ndimage import label as ndi_label, sum as ndi_sum, gaussian_filter

# logging
logging.basicConfig(level=logging.INFO, 
                    format='%(asctime)s - %(levelname)s - %(message)s')

# maping of input labels to output labels
input_labels_map = {
    "spine_to_vb": {
        "labels-spine": {1:0,2:0,3:0,4:0,5:0,6:0,7:0, # removing cervical spine
                         8:1,9:2,10:3,11:4,12:5,13:6,14:7,15:8,16:9,17:10,18:11,19:12,
                         20:13,21:14,22:15,23:16,24:17,25:18,
                         26:19,27:20,28:21,},
        "labels-bodyregions": {11:1}, # = nervous_system 11
        "labels-spinalcord":{1:1,79:1} # = spinal_cord, 1 for Tseg binary masks OR 79 for inference results; do not combine with task total (includes 1=spleen)
    },
}

# definition of classes
class ProcessLoader:
    def __init__(self, input_root, method):
        self.root = input_root
        self.method = method
        self.labels_map = input_labels_map[method]
        logging.info(f"Initializing method `{method}`, loading relevant label map")

    # reducing spine to vertebral bodies
    def spine_to_vb(self, case):
        output_np = case.fetch_label('labels-spine') # load original spine
        myelon_np = case.fetch_label('labels-bodyregions') # load myelon from Body-and-Organ-Analysis, label nervous_system = 11
        myelon2_np = case.fetch_label('labels-spinalcord') # load myelon from TotalSegmentator, label spinal_cord = 1 (for Tseg binary masks) OR 79 (for Inference)

        # combine Body-and-Organ-Analysis and TotalSegmentator
        myelon_np[myelon2_np > 0] = 1

        # save sacrum temporarily, will not remove anything there
        sacrum_np = output_np==19

        # remove everything posterior from most anterior voxel of myelon
        for slice in range(myelon_np.shape[2]):
            slice_np = myelon_np[:,:,slice]
            if np.sum(slice_np) > 0:
                com_max = np.max(np.where(slice_np > 0), axis=1)[1] # most anterior
                output_np[:,:com_max,slice] = 0

        output_np[sacrum_np] = 19

        # keep only the biggest connected component per vertebra (3D), removes noise
        labels = np.unique(output_np)[1:]
        for label in labels:
            mask = output_np == label
            if np.any(mask):
                labeled, num_labels = ndi_label(mask)
                sizes = ndi_sum(mask, labeled, index=range(1, num_labels+1))
                largest_label = np.argmax(sizes) + 1
                output_np[(labeled != largest_label) & mask] = 0

        # fill holes in the vertebra mask
        for label in labels:
            mask = output_np == label
            if np.any(mask):
                np.invert(mask, out=mask)
                labeled, num_labels = ndi_label(mask)
                if num_labels <= 1:
                    continue
                sizes = ndi_sum(mask, labeled, index=range(1, num_labels+1))
                largest_label = np.argmax(sizes) + 1
                mask[labeled != largest_label] = 0
                np.invert(mask, out=mask)
                output_np[mask] = label

        # smooth mask
        output_np_smoothed = np.zeros_like(output_np)
        for label in labels:
            mask = output_np == label
            if np.any(mask):
                smoothed_mask = gaussian_filter(mask.astype(float), sigma=1) > 0.5
                output_np_smoothed[smoothed_mask] = label

        return (output_np_smoothed, 'labels-vb')
    

    def __call__(self, input_images_file):
        time_start = time()
        worker_name = multiprocessing.current_process().name
        logging.debug(f"Processing `{input_images_file}` @{worker_name}")

        try:
            # load case
            case = CaseLoader(self.root, input_images_file, self.labels_map)

            # run pipeline according to method
            output_np, output_dir = getattr(self, self.method)(case)

            # skip patient if no output available from some reasons
            if output_np is False or output_np.size == 0:
                raise ValueError(f"no output available, skipping")
            if not output_dir:
                raise RuntimeError(f"directory for output was undefined")

            # save output, logging
            os.makedirs(self.root / output_dir, exist_ok=True)
            output_path = self.root / output_dir / input_images_file
            output_nib = nib.Nifti1Image(output_np, case.image_reoriented_affine)

            # transform back to original orientation
            affine_transformer = ornt_transform(axcodes2ornt("RAS"), # on purpose using RAS directly and not _reoriented_affine = additional check
                                                io_orientation(case.image_original_affine))
            output_nib = output_nib.as_reoriented(affine_transformer)
            if not np.allclose(case.image_original_affine, output_nib.affine):
                raise ValueError(f'Affine transformation failed: \n {case.image_original_affine} != \n {output_nib.affine}')

            nib.save(output_nib, output_path)
            logging.debug(f"  saved `{output_path}` ({time()-time_start:.2f}s)")
            logging.info(f"{input_images_file} finished @{worker_name} ({time()-time_start:.2f}s)")

        except Exception as e:
            logging.warning(f"{input_images_file} failed:\n {e}\n {traceback.format_exc()}\n")


class CaseLoader:
    def __init__(self, input_root, input_images_file, input_labels_map):

        # load source image, save shape and affine
        input_path = input_root / 'images' / input_images_file
        if not os.path.exists(input_path):
            ValueError(f"{input_path} not available")
        input_original_nib = nib.load(input_path)
        input_reoriented_nib = nib.as_closest_canonical(input_original_nib)
        input_reoriented_np = input_reoriented_nib.get_fdata().astype(np.float32)
        logging.debug(f"  loaded input `{input_path}`")

        # set shape and affine
        self.image_reoriented_np = input_reoriented_np
        self.image_reoriented_shape = input_reoriented_np.shape
        self.image_reoriented_affine = input_reoriented_nib.affine
        self.image_reoriented_zooms = input_reoriented_nib.header.get_zooms()
        self.image_original_affine = input_original_nib.affine
        self.input_images_file = input_images_file
        self.root = input_root
        self.labels_map = input_labels_map

    def fetch_label(self, label):
        # load label
        label_path = self.root / label / self.input_images_file
        label_original_nib = nib.load(label_path)
        label_reoriented_nib = nib.as_closest_canonical(label_original_nib)
        label_reoriented_np = label_reoriented_nib.get_fdata().astype(np.uint8)

        # shape and affine checks
        if not np.allclose(self.image_reoriented_affine, label_reoriented_nib.affine, rtol=1e-03, atol=1e-04):
            raise ValueError(f"affine matrices of input and label {label} do not match:\n{self.image_reoriented_affine}\n{label_reoriented_nib.affine}\n{self.image_reoriented_affine-label_reoriented_nib.affine}")
        if not np.array_equal(self.image_reoriented_shape, label_reoriented_np.shape):
            raise ValueError(f"shapes of input and label {label} do not match: {self.image_reoriented_shape} vs {label_reoriented_np.shape}")

        # load labels, create mapping array for relabeling, not existing labels are replaced with 0
        labels = self.labels_map[label]
        labels_max = max(max(labels.keys()), np.max(label_reoriented_np))
        relabel_array = np.zeros(labels_max+1, dtype=np.uint8)
        for key, value in labels.items():
           relabel_array[key] = value
            
        # remap labels using fancy indexing
        label_reoriented_np = relabel_array[label_reoriented_np]

        logging.debug(f"  loaded label `{label_path}` using {len(labels)} labels")
        return label_reoriented_np


def main(input_root, input_prefix, method):
    time_start = time()

    # print
    logging.info('PIPELINE: MASK PROCESSING')
    logging.info(f'input root directory: `{input_root}`')
    logging.info(f'method: `{method}`')
    logging.info(f'input prefix: `{input_prefix}`')

    # checks: input directory? method?
    if not os.path.exists(input_root):
        raise ValueError(f'Input root directory `{input_root}` does not exist.')
    if method not in input_labels_map.keys():
        raise ValueError(f"Method `{method}` not available.")

    # find cases (images/*, prefix*nii.gz)
    input_images_dir = input_root / "images"
    input_images_files = [file.name for file in input_images_dir.glob(input_prefix + '*.nii.gz')]
    logging.info(f"{len(input_images_files)} input images identified")

    # identifying all input subdirectories
    input_labels_required = input_labels_map[method]
    logging.info(f"{len(input_labels_required)} labels required: {', '.join(input_labels_required.keys())}")

    # check if all required label files are available
    input_images_files = [file for file in input_images_files if all((input_root / label / file).exists() for label in input_labels_required.keys())]
    logging.info(f"{len(input_images_files)} complete cases (all required labels available) identified")

    # initialize current method as process
    process = ProcessLoader(input_root, method)
    n_processes = min(multiprocessing.cpu_count(), len(input_images_files))

    # multiprocessing
    logging.info(f"spawn processes at {n_processes}/{multiprocessing.cpu_count()} CPUs\n")
    with multiprocessing.Pool(processes=n_processes, maxtasksperchild=20) as p:
       p.map(process, input_images_files, chunksize=min(5, n_processes))

    # finalized
    logging.info(f"FINISHED PIPELINE ({len(input_images_files)} cases in {time()-time_start:.2f}s)")


if __name__ == "__main__":
    """
    Toolkit for label manipulation, combination and agregation.
    requires directories images/, and directories corresponding to the labels as specified in input_labels_map within the input root directory.

    Usage:
    suppl/4_MaskEdits.py -i /Volumes/path/to/main/ -m spine_to_vb
    """

    parser = argparse.ArgumentParser(description="toolkit to combine and manipulate masks.")
    parser.add_argument("-i", "--input", metavar="Input root directory", dest="input_root",
                        help="Root Directory", 
                        type=lambda p: Path(p).absolute(), required=True)
    parser.add_argument("-b", "--batch", metavar="Prefix of inputs", dest="input_prefix",
                        help="Prefix of input files to be processed", 
                        type=str, required=False, default="")   
    parser.add_argument("-m", "--method", metavar="Method", dest="method",
                        help="The method / pipeline used for mask processing",
                        type=str, choices=["spine_to_vb"], required=True)
    args = parser.parse_args()

    main(input_root=args.input_root, input_prefix=args.input_prefix, method=args.method)