SegMamba/light_training/preprocessing/preprocessors/default_preprocessor.py

#    Copyright 2020 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany
#
#    Licensed under the Apache License, Version 2.0 (the "License");
#    you may not use this file except in compliance with the License.
#    You may obtain a copy of the License at
#
#        http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS,
#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#    See the License for the specific language governing permissions and
#    limitations under the License.
import multiprocessing
import shutil
from time import sleep
from typing import Union, Tuple
import glob
import numpy as np
from batchgenerators.utilities.file_and_folder_operations import *
from light_training.preprocessing.cropping.cropping import crop_to_nonzero
# from .default_resampling import resample_data_or_seg_to_spacing, resample_img
from light_training.preprocessing.resampling.default_resampling import resample_data_or_seg_to_shape, compute_new_shape
from tqdm import tqdm
from light_training.preprocessing.normalization.default_normalization_schemes import CTNormalization, ZScoreNormalization
import SimpleITK as sitk 
from tqdm import tqdm 
from copy import deepcopy
import json 

def create_image(image_arr, spacing):
    image = sitk.GetImageFromArray(image_arr)
    image.SetSpacing(spacing)
    return image 

def get_shape_must_be_divisible_by(net_numpool_per_axis):
    return 2 ** np.array(net_numpool_per_axis)

def pad_shape(shape, must_be_divisible_by):
    """
    pads shape so that it is divisible by must_be_divisible_by
    :param shape:
    :param must_be_divisible_by:
    :return:
    """
    if not isinstance(must_be_divisible_by, (tuple, list, np.ndarray)):
        must_be_divisible_by = [must_be_divisible_by] * len(shape)
    else:
        assert len(must_be_divisible_by) == len(shape)

    new_shp = [shape[i] + must_be_divisible_by[i] - shape[i] % must_be_divisible_by[i] for i in range(len(shape))]

    for i in range(len(shape)):
        if shape[i] % must_be_divisible_by[i] == 0:
            new_shp[i] -= must_be_divisible_by[i]
    new_shp = np.array(new_shp).astype(int)
    return new_shp

def get_pool_and_conv_props(spacing, patch_size, min_feature_map_size, max_numpool):
    """
    this is the same as get_pool_and_conv_props_v2 from old nnunet

    :param spacing:
    :param patch_size:
    :param min_feature_map_size: min edge length of feature maps in bottleneck
    :param max_numpool:
    :return:
    """
    # todo review this code
    dim = len(spacing)

    current_spacing = deepcopy(list(spacing))
    current_size = deepcopy(list(patch_size))

    pool_op_kernel_sizes = [[1] * len(spacing)]
    conv_kernel_sizes = []

    num_pool_per_axis = [0] * dim
    kernel_size = [1] * dim

    while True:
        # exclude axes that we cannot pool further because of min_feature_map_size constraint
        valid_axes_for_pool = [i for i in range(dim) if current_size[i] >= 2*min_feature_map_size]
        if len(valid_axes_for_pool) < 1:
            break

        spacings_of_axes = [current_spacing[i] for i in valid_axes_for_pool]

        # find axis that are within factor of 2 within smallest spacing
        min_spacing_of_valid = min(spacings_of_axes)
        valid_axes_for_pool = [i for i in valid_axes_for_pool if current_spacing[i] / min_spacing_of_valid < 2]

        # max_numpool constraint
        valid_axes_for_pool = [i for i in valid_axes_for_pool if num_pool_per_axis[i] < max_numpool]

        if len(valid_axes_for_pool) == 1:
            if current_size[valid_axes_for_pool[0]] >= 3 * min_feature_map_size:
                pass
            else:
                break
        if len(valid_axes_for_pool) < 1:
            break

        # now we need to find kernel sizes
        # kernel sizes are initialized to 1. They are successively set to 3 when their associated axis becomes within
        # factor 2 of min_spacing. Once they are 3 they remain 3
        for d in range(dim):
            if kernel_size[d] == 3:
                continue
            else:
                if spacings_of_axes[d] / min(current_spacing) < 2:
                    kernel_size[d] = 3

        other_axes = [i for i in range(dim) if i not in valid_axes_for_pool]

        pool_kernel_sizes = [0] * dim
        for v in valid_axes_for_pool:
            pool_kernel_sizes[v] = 2
            num_pool_per_axis[v] += 1
            current_spacing[v] *= 2
            current_size[v] = np.ceil(current_size[v] / 2)
        for nv in other_axes:
            pool_kernel_sizes[nv] = 1

        pool_op_kernel_sizes.append(pool_kernel_sizes)
        conv_kernel_sizes.append(deepcopy(kernel_size))
        #print(conv_kernel_sizes)

    must_be_divisible_by = get_shape_must_be_divisible_by(num_pool_per_axis)
    patch_size = pad_shape(patch_size, must_be_divisible_by)

    # we need to add one more conv_kernel_size for the bottleneck. We always use 3x3(x3) conv here
    conv_kernel_sizes.append([3]*dim)
    return num_pool_per_axis, pool_op_kernel_sizes, conv_kernel_sizes, patch_size, must_be_divisible_by


class DefaultPreprocessor(object):
    def __init__(self, 
                 base_dir,
                 image_dir, 
                #  output_dir,
                #  out_spacing,
                 label_dir=None,
                 data_type="CT"):
        """
        Everything we need is in the plans. Those are given when run() is called
        """
        self.base_dir = base_dir
        self.image_dir = image_dir
        self.label_dir = label_dir
     
        self.data_type = data_type

    def run_case_npy(self, data: np.ndarray, seg, properties: dict):
        # let's not mess up the inputs!
        data = np.copy(data)
        old_shape = data.shape
        original_spacing = list(properties['spacing'])
        ## 由于old spacing读出来是反的，因此这里需要转置一下

        original_spacing_trans = original_spacing[::-1]
        properties["original_spacing_trans"] = original_spacing_trans
        properties["target_spacing_trans"] = self.out_spacing

        shape_before_cropping = data.shape[1:]
        ## crop
        properties['shape_before_cropping'] = shape_before_cropping
        # this command will generate a segmentation. This is important because of the nonzero mask which we may need
        data, seg, bbox = crop_to_nonzero(data, seg)
        properties['bbox_used_for_cropping'] = bbox

        # crop, remember to store size before cropping!
        shape_before_resample = data.shape[1:]
        properties['shape_after_cropping_before_resample'] = shape_before_resample

        new_shape = compute_new_shape(data.shape[1:], original_spacing_trans, self.out_spacing)

        if seg is None :
            seg_norm = np.zeros_like(data)
        else :
            seg_norm = seg 
        data = self._normalize(data, seg_norm,
                               self.foreground_intensity_properties_per_channel)

        assert len(data.shape) == 4

        data = resample_data_or_seg_to_shape(data, new_shape, 
                                             original_spacing, 
                                             self.out_spacing,
                                             order=3,
                                             order_z=0)
        properties['shape_after_resample'] = new_shape
        
        if seg is not None :
            assert len(seg.shape) == 4
            seg = resample_data_or_seg_to_shape(seg, new_shape, 
                                                original_spacing, 
                                                self.out_spacing,
                                                is_seg=True,
                                                order=1,
                                                order_z=0)

            properties['class_locations'] = self._sample_foreground_locations(seg, 
                                                                              self.all_labels,
                                                                              )
            
            if np.max(seg) > 127:
                seg = seg.astype(np.int16)
            else:
                seg = seg.astype(np.int8)
            
        #     assert len(seg.shape) == 4
        #     seg = create_image(seg[0], original_spacing)
        #     seg = resample_img(seg, out_spacing=self.out_spacing, is_label=True)
        #     seg = sitk.GetArrayFromImage(seg)[None]
        #     print(f"all_labels is {np.unique(seg)}")
        #     if np.max(seg) > 127:
        #         seg = seg.astype(np.int16)
        #     else:
        #         seg = seg.astype(np.int8)
            # seg = resample_data_or_seg_to_spacing(seg, current_spacing=original_spacing, 
            #                                    new_spacing=self.out_spacing, is_seg=True)
       
        print(f'old shape: {old_shape}, new_shape after crop and resample: {new_shape}, old_spacing: {original_spacing}, '
                f'new_spacing: {self.out_spacing}, boxes is {bbox}')
           
        return data, seg

    # need to modify
    def get_iterable_list(self):
        all_cases = os.listdir(os.path.join(self.base_dir, self.image_dir))

        return all_cases

    def _normalize(self, data: np.ndarray, seg: np.ndarray,
                   foreground_intensity_properties_per_channel: dict) -> np.ndarray:
        for c in range(data.shape[0]):
            normalizer_class = CTNormalization
            normalizer = normalizer_class(use_mask_for_norm=False,
                                          intensityproperties=foreground_intensity_properties_per_channel[str(c)])
            data[c] = normalizer.run(data[c], seg[0])
        return data

    # need to modify
    def read_data(self, case_name):
        ## only for CT dataset
        data = sitk.ReadImage(os.path.join(self.base_dir, self.image_dir, case_name))
        seg_arr = None
        ## 一定要是float32！！！！
        data_arr = sitk.GetArrayFromImage(data).astype(np.float32)
        data_arr = data_arr[None]

        if self.label_dir is not None:
            seg = sitk.ReadImage(os.path.join(self.base_dir, self.label_dir, case_name))
            ## 读出来以后一定转float32!!!
            seg_arr = sitk.GetArrayFromImage(seg).astype(np.float32)
            seg_arr = seg_arr[None]
            intensities_per_channel, intensity_statistics_per_channel = self.collect_foreground_intensities(seg_arr, data_arr)

        else :
            intensities_per_channel = []
            intensity_statistics_per_channel = []

        properties = {"spacing": data.GetSpacing(), 
                      "raw_size": data_arr.shape[1:], 
                      "name": case_name.split(".")[0],
                      "intensities_per_channel": intensities_per_channel,
                      "intensity_statistics_per_channel": intensity_statistics_per_channel}

        return data_arr, seg_arr, properties
    
    def run_case(self, case_name):
        """
        seg file can be none (test cases)

        order of operations is: transpose -> crop -> resample
        so when we export we need to run the following order: resample -> crop -> transpose (we could also run
        transpose at a different place, but reverting the order of operations done during preprocessing seems cleaner)
        """
        data, seg, properties = self.read_data(case_name)
        
        data, seg = self.run_case_npy(data, seg, properties)
        return data, seg, properties 

    def run_case_save(self, case_name):
        print(case_name + "~~~~~~~~" * 10)
        data, seg, properties = self.run_case(case_name)
        # print('dtypes', data.dtype, seg.dtype)
        case_name = case_name.split(".")[0]
        np.savez_compressed(os.path.join(self.output_dir, case_name) + '.npz', data=data, seg=seg)
        write_pickle(properties, os.path.join(self.output_dir, case_name) + '.pkl')
        print(f"data is saved at: {os.path.join(self.output_dir, case_name) + '.npz'}")
    
    def experiment_plan(self, case_name):

        data, seg, properties = self.read_data(case_name)
        print(f"labels is {np.unique(seg)}")
        spacing = properties["spacing"]
        raw_size = properties["raw_size"]
        intensities_per_channel = properties["intensities_per_channel"]

        return spacing, raw_size, intensities_per_channel

    def determine_fullres_target_spacing(self, spacings, sizes) -> np.ndarray:
        # if self.overwrite_target_spacing is not None:
        #     return np.array(self.overwrite_target_spacing)

        # spacings = self.dataset_fingerprint['spacings']
        # sizes = self.dataset_fingerprint['shapes_after_crop']

        target = np.percentile(np.vstack(spacings), 50, 0)
        target_size = np.percentile(np.vstack(sizes), 50, 0)
        # we need to identify datasets for which a different target spacing could be beneficial. These datasets have
        # the following properties:
        # - one axis which much lower resolution than the others
        # - the lowres axis has much less voxels than the others
        # - (the size in mm of the lowres axis is also reduced)
        worst_spacing_axis = np.argmax(target)
        other_axes = [i for i in range(len(target)) if i != worst_spacing_axis]
        other_spacings = [target[i] for i in other_axes]
        other_sizes = [target_size[i] for i in other_axes]

        has_aniso_spacing = target[worst_spacing_axis] > (3 * max(other_spacings))
        has_aniso_voxels = target_size[worst_spacing_axis] * 3 < min(other_sizes)

        if has_aniso_spacing and has_aniso_voxels:
            spacings_of_that_axis = np.vstack(spacings)[:, worst_spacing_axis]
            target_spacing_of_that_axis = np.percentile(spacings_of_that_axis, 10)
            # don't let the spacing of that axis get higher than the other axes
            if target_spacing_of_that_axis < max(other_spacings):
                target_spacing_of_that_axis = max(max(other_spacings), target_spacing_of_that_axis) + 1e-5
            target[worst_spacing_axis] = target_spacing_of_that_axis
        return target

    def compute_new_shape(self, old_shape: Union[Tuple[int, ...], List[int], np.ndarray],
                      old_spacing: Union[Tuple[float, ...], List[float], np.ndarray],
                      new_spacing: Union[Tuple[float, ...], List[float], np.ndarray]) -> np.ndarray:
        ## spacing need to be transposed
        old_spacing = list(old_spacing)[::-1]
        new_spacing = list(new_spacing)[::-1]

        assert len(old_spacing) == len(old_shape)
        assert len(old_shape) == len(new_spacing)
        new_shape = np.array([int(round(i / j * k)) for i, j, k in zip(old_spacing, new_spacing, old_shape)])
        return new_shape

    def run_plan(self):
        all_iter = self.get_iterable_list()
        spacings = []
        sizes = []
        intensities_per_channels = []
        print(f"analysing data......")
        for case in tqdm(all_iter, total=len(all_iter)):
            spacing, size, intensities_per_channel = self.experiment_plan(case)
            spacings.append(spacing)
            sizes.append(size)
            intensities_per_channels.append(intensities_per_channel)
        
        print(f"all spacing is {spacings}")
        print(f"all sizes is {sizes}")
        foreground_intensities_per_channel = [np.concatenate([r[i] for r in intensities_per_channels]) for i in
                                                  range(len(intensities_per_channels[0]))]
        
        num_channels = len(intensities_per_channels[0])

        intensity_statistics_per_channel = {}
        for i in range(num_channels):
            intensity_statistics_per_channel[i] = {
                'mean': float(np.mean(foreground_intensities_per_channel[i])),
                'median': float(np.median(foreground_intensities_per_channel[i])),
                'std': float(np.std(foreground_intensities_per_channel[i])),
                'min': float(np.min(foreground_intensities_per_channel[i])),
                'max': float(np.max(foreground_intensities_per_channel[i])),
                'percentile_99_5': float(np.percentile(foreground_intensities_per_channel[i], 99.5)),
                'percentile_00_5': float(np.percentile(foreground_intensities_per_channel[i], 0.5)),
            }

        print(f"intensity_statistics_per_channel is {intensity_statistics_per_channel}")

        fullres_spacing = self.determine_fullres_target_spacing(spacings, sizes)
        print(f"fullres spacing is {fullres_spacing[::-1]}")

        # get transposed new median shape (what we would have after resampling)
        new_shapes = [self.compute_new_shape(j, i, fullres_spacing) for i, j in
                      zip(spacings, sizes)]
        new_median_shape = np.median(new_shapes, 0)
        print(f"median_shape is {new_median_shape}")

        tmp = 1 / np.array(fullres_spacing)
        initial_patch_size = [round(i) for i in tmp * (256 ** 3 / np.prod(tmp)) ** (1 / 3)]

        print(f"initial_patch_size is {initial_patch_size[::-1]}")

        network_num_pool_per_axis, pool_op_kernel_sizes, conv_kernel_sizes, patch_size, \
        shape_must_be_divisible_by = get_pool_and_conv_props(fullres_spacing, initial_patch_size,
                                                             4,
                                                             999999)
        print(f"target medium patch size is {patch_size[::-1]}")

        analysis_path = "./data_analysis_result.txt"
        with open(analysis_path, "w") as f:

            f.write(json.dumps({
                "intensity_statistics_per_channel": intensity_statistics_per_channel,
                "fullres spacing": fullres_spacing.tolist(),
                "median_shape": new_median_shape.tolist(),
                "initial_patch_size": initial_patch_size,
                "target medium patch size": patch_size[::-1].tolist()
            }))
        print(f"Analysis done, save to {analysis_path}")
        

    def collect_foreground_intensities(self, segmentation: np.ndarray, images: np.ndarray, seed: int = 1234,
                                       num_samples: int = 10000):
        """
        images=image with multiple channels = shape (c, x, y(, z))
        """
        assert len(images.shape) == 4
        assert len(segmentation.shape) == 4

        assert not np.any(np.isnan(segmentation)), "Segmentation contains NaN values. grrrr.... :-("
        assert not np.any(np.isnan(images)), "Images contains NaN values. grrrr.... :-("

        rs = np.random.RandomState(seed)

        intensities_per_channel = []
        # we don't use the intensity_statistics_per_channel at all, it's just something that might be nice to have
        intensity_statistics_per_channel = []

        # segmentation is 4d: 1,x,y,z. We need to remove the empty dimension for the following code to work
        foreground_mask = segmentation[0] > 0

        for i in range(len(images)):
            foreground_pixels = images[i][foreground_mask]
            num_fg = len(foreground_pixels)
            # sample with replacement so that we don't get issues with cases that have less than num_samples
            # foreground_pixels. We could also just sample less in those cases but that would than cause these
            # training cases to be underrepresented
            intensities_per_channel.append(
                rs.choice(foreground_pixels, num_samples, replace=True) if num_fg > 0 else [])
            intensity_statistics_per_channel.append({
                'mean': np.mean(foreground_pixels) if num_fg > 0 else np.nan,
                'median': np.median(foreground_pixels) if num_fg > 0 else np.nan,
                'min': np.min(foreground_pixels) if num_fg > 0 else np.nan,
                'max': np.max(foreground_pixels) if num_fg > 0 else np.nan,
                'percentile_99_5': np.percentile(foreground_pixels, 99.5) if num_fg > 0 else np.nan,
                'percentile_00_5': np.percentile(foreground_pixels, 0.5) if num_fg > 0 else np.nan,

            })

        return intensities_per_channel, intensity_statistics_per_channel

    @staticmethod
    def _sample_foreground_locations(seg: np.ndarray, classes_or_regions: Union[List[int], List[Tuple[int, ...]]],
                                     seed: int = 1234, verbose: bool = False):
        num_samples = 10000
        min_percent_coverage = 0.01  # at least 1% of the class voxels need to be selected, otherwise it may be too
        # sparse
        rndst = np.random.RandomState(seed)
        class_locs = {}
        for c in classes_or_regions:
            k = c if not isinstance(c, list) else tuple(c)
            if isinstance(c, (tuple, list)):
                ## region
                mask = seg == c[0]
                for cc in c[1:]:
                    mask = mask | (seg == cc)
                all_locs = np.argwhere(mask)
            else:
                all_locs = np.argwhere(seg == c)
            if len(all_locs) == 0:
                class_locs[k] = []
                continue
            target_num_samples = min(num_samples, len(all_locs))
            target_num_samples = max(target_num_samples, int(np.ceil(len(all_locs) * min_percent_coverage)))

            selected = all_locs[rndst.choice(len(all_locs), target_num_samples, replace=False)]
            class_locs[k] = selected
            if verbose:
                print(c, target_num_samples)

        return class_locs
    
    def run(self, output_spacing, 
            output_dir, 
            all_labels,
            foreground_intensity_properties_per_channel=None, 
            num_processes=8):
        self.out_spacing = output_spacing
        self.all_labels = all_labels
        self.output_dir = output_dir
        self.foreground_intensity_properties_per_channel = foreground_intensity_properties_per_channel

        all_iter = self.get_iterable_list()
        
        maybe_mkdir_p(self.output_dir)

        # test_run 
        for case_name in all_iter:
            self.run_case_save(case_name)
            break

        # multiprocessing magic.
        r = []
        with multiprocessing.get_context("spawn").Pool(num_processes) as p:
            for case_name in all_iter:
                r.append(p.starmap_async(self.run_case_save,
                                         ((case_name, ),)))
            remaining = list(range(len(all_iter)))
            # p is pretty nifti. If we kill workers they just respawn but don't do any work.
            # So we need to store the original pool of workers.
            workers = [j for j in p._pool]
            with tqdm(desc=None, total=len(all_iter)) as pbar:
                while len(remaining) > 0:
                    all_alive = all([j.is_alive() for j in workers])
                    if not all_alive:
                        raise RuntimeError('Some background worker is 6 feet under. Yuck. \n'
                                           'OK jokes aside.\n'
                                           'One of your background processes is missing. This could be because of '
                                           'an error (look for an error message) or because it was killed '
                                           'by your OS due to running out of RAM. If you don\'t see '
                                           'an error message, out of RAM is likely the problem. In that case '
                                           'reducing the number of workers might help')
                    done = [i for i in remaining if r[i].ready()]
                    for _ in done:
                        pbar.update()
                    remaining = [i for i in remaining if i not in done]
                    sleep(0.1)