Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
from batchgenerators.augmentations.utils import resize_segmentation
import numpy as np
# Internal libraries/scripts
from miscnn.processing.subfunctions.abstract_subfunction import Abstract_Subfunction
#-----------------------------------------------------#
# Subfunction class: Resize #
#-----------------------------------------------------#
""" A Resize Subfunction class which resizes an images according to a desired shape.
Methods:
__init__ Object creation function
preprocessing: Resize imaging data to the desired shape
postprocessing: Resize a prediction to the desired shape
"""
class Resize(Abstract_Subfunction):
#---------------------------------------------#
# Initialization #
#---------------------------------------------#
def __init__(self, new_shape=(128,128,128)):
self.new_shape = new_shape
self.original_shape = None
#---------------------------------------------#
# Preprocessing #
#---------------------------------------------#
def preprocessing(self, sample, training=True):
# Access data
img_data = sample.img_data
seg_data = sample.seg_data
# Cache current spacing for later postprocessing
if not training : self.original_shape = (1,) + img_data.shape[0:-1]
""" A Padding Subfunction class which pads an images if required to a provided size.
An image will only be padded, if its shape is smaller than the minimum size.
Args:
min_size (tuple of integers): Minimum shape of image. Every axis under this minimum size will be padded.
pad_mode (string): Mode for padding. See in NumPy pad(array, mode="constant") documentation.
pad_value_img (integer): Value which will be used in padding mode "constant".
pad_value_seg (integer): Value which will be used in padding mode "constant".
shape_must_be_divisible_by (integer): Ensure that new shape is divisibly by provided number.
Methods:
__init__ Object creation function
preprocessing: Padding to desired size of the imaging data
postprocessing: Cropping back to original size of the imaging data
"""
class Padding(Abstract_Subfunction):
#---------------------------------------------#
# Initialization #
#---------------------------------------------#
def __init__(self, min_size, pad_mode="constant",
pad_value_img=0, pad_value_seg=0,
shape_must_be_divisible_by=None):
self.min_size = min_size
self.pad_mode = pad_mode
self.pad_value_img = pad_value_img
self.pad_value_seg = pad_value_seg
self.shape_must_be_divisible_by = shape_must_be_divisible_by
self.original_coords = None
#---------------------------------------------#
# Preprocessing #
#---------------------------------------------#
# Internal libraries/scripts
from miscnn.processing.subfunctions.abstract_subfunction import Abstract_Subfunction
#-----------------------------------------------------#
# Subfunction class: Resampling #
#-----------------------------------------------------#
""" A Resampling Subfunction class which resizes an images according to a desired voxel spacing.
This function only works with already cached "spacing" matrix in the detailed information
dictionary of the sample.
Methods:
__init__ Object creation function
preprocessing: Resample to desired spacing between voxels in the imaging data
postprocessing: Resample to original spacing between voxels in the imaging data
"""
class Resampling(Abstract_Subfunction):
#---------------------------------------------#
# Initialization #
#---------------------------------------------#
def __init__(self, new_spacing=(1,1,1)):
self.new_spacing = new_spacing
self.original_shape = None
#---------------------------------------------#
# Preprocessing #
#---------------------------------------------#
def preprocessing(self, sample, training=True):
# Access data
img_data = sample.img_data
seg_data = sample.seg_data
# Identify current spacing
try : current_spacing = sample.details["spacing"]
# External libraries
import numpy as np
# Internal libraries/scripts
from miscnn.processing.subfunctions.abstract_subfunction import Abstract_Subfunction
#-----------------------------------------------------#
# Subfunction class: Clipping #
#-----------------------------------------------------#
""" A Clipping Subfunction class which can be used for clipping intensity pixel values on a certain range.
Methods:
__init__ Object creation function
preprocessing: Clipping the imaging data
postprocessing: Do nothing
"""
class Clipping(Abstract_Subfunction):
#---------------------------------------------#
# Initialization #
#---------------------------------------------#
def __init__(self, min, max):
self.min = min
self.max = max
#---------------------------------------------#
# Preprocessing #
#---------------------------------------------#
def preprocessing(self, sample, training=True):
# Access image
image = sample.img_data
# Perform clipping
image_clipped = np.clip(image, self.min, self.max)
# Update the sample with the normalized image
import numpy as np
# Internal libraries/scripts
from miscnn.processing.subfunctions.abstract_subfunction import Abstract_Subfunction
#-----------------------------------------------------#
# Subfunction class: TransformHU #
#-----------------------------------------------------#
""" A function to scale CT raw data according to HU units .
Methods:
__init__ Object creation function
preprocessing: Transforms CT raw data to HU .
normalize_HU: Normalizes HU values in a range between 0-1.
postprocessing: no postprocessing needed.
"""
class TransformHU(Abstract_Subfunction):
#---------------------------------------------#
# Initialization #
#---------------------------------------------#
def __init__(self, normalize = True, slope = 1, intercept = -1024,
clipScan_value = -2000, minmaxBound = (-1000, 400)):
"""
Args:
normalize (bool): Normalizes HU units between 0-1 if True.
slope (float): slope value derived from DICOM files.
intercept (float): intercept value derived from DICOM files.
ClipScan_value (int): sets scan values at clipping value to 0 (used for out of scan values).
minmaxBound (tuple): Normalization boundaries.
"""
self.normalize = normalize
self.slope = slope
self.intercept = intercept
#-----------------------------------------------------#
# Subfunction class: Normalization #
#-----------------------------------------------------#
""" A Normalization Subfunction class which normalizes the intensity pixel values of an image using
the Z-Score technique (default setting), through scaling to [0,1] or to grayscale [0,255].
Args:
mode (string): Mode which normalization approach should be performed.
Possible modi: "z-score", "minmax" or "grayscale"
Methods:
__init__ Object creation function
preprocessing: Pixel intensity value normalization the imaging data
postprocessing: Do nothing
"""
class Normalization(Abstract_Subfunction):
#---------------------------------------------#
# Initialization #
#---------------------------------------------#
def __init__(self, mode="z-score"):
self.mode = mode
#---------------------------------------------#
# Preprocessing #
#---------------------------------------------#
def preprocessing(self, sample, training=True):
# Access image
image = sample.img_data
# Perform z-score normalization
if self.mode == "z-score":
# Compute mean and standard deviation
mean = np.mean(image)