mosamatic2 2.0.24__py3-none-any.whl

mosamatic2/core/tasks/calculatemaskstatisticstask/calculatemaskstatisticstask.py

@@ -0,0 +1,104 @@
+import os
+import numpy as np
+import nibabel as nb
+import pandas as pd
+import matplotlib.pyplot as plt
+from mosamatic2.core.tasks.task import Task
+from mosamatic2.core.managers.logmanager import LogManager
+
+LOG = LogManager()
+
+
+class CalculateMaskStatisticsTask(Task):
+    INPUTS = ['scans', 'masks']
+    PARAMS = []
+
+    def __init__(self, inputs, params, output, overwrite):
+        super(CalculateMaskStatisticsTask, self).__init__(inputs, params, output, overwrite)
+
+    def load_scans(self):
+        scans = []
+        for f in os.listdir(self.input('scans')):
+            if f.endswith('.nii.gz'):
+                scan = os.path.join(self.input('scans'), f)
+                if os.path.isfile(scan):
+                    scans.append(scan)
+        return scans
+
+    def load_mask_files(self):
+        mask_files = []
+        for f in os.listdir(self.input('masks')):
+            if f.endswith('.nii.gz') and 'liver_segment' in f:
+                mask_file = os.path.join(self.input('masks'), f)
+                if os.path.isfile(mask_file):
+                    mask_files.append(mask_file)
+        return mask_files
+    
+    def collect_scan_mask_file_pairs(self, scans, mask_files):
+        scan_mask_file_pairs = []
+        for scan in scans:
+            scan_name = os.path.split(scan)[1][:-7]
+            for mask_file in mask_files:
+                mask_file_name = os.path.split(mask_file)[1][:-7]
+                if scan_name in mask_file_name:
+                    scan_mask_file_pairs.append((scan, mask_file))
+        return scan_mask_file_pairs
+    
+    def get_masked_voxels(self, scan_mask_file_pair):
+        scan_image_file = scan_mask_file_pair[0]
+        scan_image = nb.load(scan_image_file)
+        scan_image_data = scan_image.get_fdata()
+        mask_file_image_file = scan_mask_file_pair[1]
+        mask_file_image_file_name = os.path.split(mask_file_image_file)[1]
+        mask_file_image = nb.load(mask_file_image_file)
+        mask_file_image_data = mask_file_image.get_fdata()
+        mask = mask_file_image_data > 0
+        masked_voxels = scan_image_data[mask]
+        return masked_voxels, mask_file_image_file_name
+    
+    def calculate_volume_in_mL(self, mask_file):
+        nifti_image = nb.load(mask_file)
+        nifti_image_data = nifti_image.get_fdata()
+        voxel_dims = nifti_image.header.get_zooms()[:3]
+        voxel_volume = np.prod(voxel_dims)
+        num_voxels = np.sum(nifti_image_data > 0.5)
+        mask_volume = num_voxels * voxel_volume / 1000.0
+        return mask_volume
+    
+    def create_histogram_png(self, masked_voxels, file_name):
+        histogram_png_file = os.path.join(self.output(), f'{file_name}.png')
+        plt.figure(figsize=(8,6))
+        plt.hist(masked_voxels, bins=100, color='steelblue', edgecolor='black')
+        plt.title(f'Histogram of HU values inside {file_name}')
+        plt.xlabel('HU')
+        plt.ylabel('Frequency')
+        plt.savefig(histogram_png_file, dpi=300, bbox_inches='tight')
+        plt.close()
+
+    def save_data_to_file(self, data):
+        csv_file_path = os.path.join(self.output(), 'statistics.csv')
+        xls_file_path = os.path.join(self.output(), 'statistics.xlsx')
+        df = pd.DataFrame(data=data)
+        df.to_csv(csv_file_path, index=False, sep=';')
+        df.to_excel(xls_file_path, index=False, engine='openpyxl')
+
+    def run(self):
+        scans = self.load_scans()
+        mask_files = self.load_mask_files()
+        scan_mask_file_pairs = self.collect_scan_mask_file_pairs(scans, mask_files)
+        nr_steps = len(scan_mask_file_pairs)
+        data = {
+            'file': [],
+            'mean_HU': [],
+            'std_HU': [],
+            'volume_mL': [],
+        }
+        for step in range(nr_steps):
+            masked_voxels, file_name = self.get_masked_voxels(scan_mask_file_pairs[step])
+            data['file'].append(file_name)
+            data['mean_HU'].append(round(np.mean(masked_voxels)))
+            data['std_HU'].append(round(np.std(masked_voxels)))
+            data['volume_mL'].append(round(self.calculate_volume_in_mL(scan_mask_file_pairs[step][1])))
+            self.create_histogram_png(masked_voxels, file_name)
+            self.set_progress(step, nr_steps)
+        self.save_data_to_file(data)

mosamatic2/core/tasks/calculatescorestask/calculatescorestask.py

@@ -0,0 +1,152 @@
+import os
+import numpy as np
+import pandas as pd
+from mosamatic2.core.tasks.task import Task
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.core.data.multidicomimage import MultiDicomImage
+from mosamatic2.core.data.numpyimage import NumpyImage
+from mosamatic2.core.utils import (
+    get_pixels_from_dicom_object,
+    calculate_area,
+    calculate_mean_radiation_attenuation,
+    calculate_lama_percentage,
+    get_pixels_from_tag_file,
+    MUSCLE,
+    SAT,
+    VAT,
+)
+
+LOG = LogManager()
+
+
+class CalculateScoresTask(Task):
+    INPUTS = [
+        'images', 
+        'segmentations'
+    ]
+    PARAMS = ['file_type']
+
+    def __init__(self, inputs, params, output, overwrite=True):
+        super(CalculateScoresTask, self).__init__(inputs, params, output, overwrite)
+
+    def collect_img_seg_pairs(self, images, segmentations, file_type='npy'):
+        file_type = '.tag' if file_type == 'tag' else '.seg.npy'
+        img_seg_pairs = []
+        for image in images:
+            f_img_path = image.path()
+            f_img_name = os.path.split(f_img_path)[1]
+            for f_seg_path in segmentations:
+                f_seg_name = os.path.split(f_seg_path)[1]
+                if file_type == '.seg.npy':
+                    f_seg_name = f_seg_name.removesuffix(file_type)
+                    if f_seg_name == f_img_name:
+                        img_seg_pairs.append((image, f_seg_path))
+                elif file_type == '.tag':
+                    f_seg_name = f_seg_name.removesuffix(file_type).removesuffix('.dcm')
+                    f_img_name = f_img_name.removesuffix('.dcm')
+                    if f_seg_name == f_img_name:
+                        img_seg_pairs.append((image, f_seg_path))
+                else:
+                    raise RuntimeError('Unknown file type')
+        return img_seg_pairs
+
+    def load_images(self):
+        image_data = MultiDicomImage()
+        image_data.set_path(self.input('images'))
+        if image_data.load():
+            return image_data
+        raise RuntimeError('Could not load images')
+    
+    def load_pixels_and_spacing(self, image):
+        p = image.object()
+        pixels = get_pixels_from_dicom_object(p, normalize=True)
+        return pixels, p.PixelSpacing
+
+    def load_segmentations(self, file_type='npy'):
+        file_type = '.tag' if file_type == 'tag' else '.seg.npy'
+        segmentations = []
+        for f in os.listdir(self.input('segmentations')):
+            f_path = os.path.join(self.input('segmentations'), f)
+            if f.endswith(file_type):
+                segmentations.append(f_path)
+        if len(segmentations) == 0:
+            raise RuntimeError('Input directory has no segmentation files')
+        return segmentations
+
+    def load_segmentation(self, f, file_type='npy'):
+        if file_type == 'npy':
+            segmentation = NumpyImage()
+            segmentation.set_path(f)
+            if segmentation.load():
+                return segmentation.object()
+            LOG.error(f'Could not load segmentation file {f}')
+        if file_type == 'tag':
+            pixels = get_pixels_from_tag_file(f)
+            try:
+                pixels = pixels.reshape(512, 512)
+                return pixels
+            except Exception:
+                LOG.warning(f'Could not reshape TAG pixels to (512, 512), skipping...')
+                return None
+        raise RuntimeError('Unknown file type')
+
+    def run(self):
+        image_data = self.load_images()
+        images = image_data.images()
+        file_type = self.param('file_type')
+        segmentations = self.load_segmentations(file_type)
+        img_seg_pairs = self.collect_img_seg_pairs(images, segmentations, file_type)
+        # Create empty data dictionary
+        data = {
+            'file': [], 
+            'muscle_area': [], 'muscle_idx': [], 'muscle_ra': [], 'muscle_lama_perc': [],
+            'vat_area': [], 'vat_idx': [], 'vat_ra': [],
+            'sat_area': [], 'sat_idx': [], 'sat_ra': []
+        }
+        nr_steps = len(img_seg_pairs)
+        for step in range(nr_steps):
+            # Get image and its pixel spacing
+            image, pixel_spacing = self.load_pixels_and_spacing(img_seg_pairs[step][0])
+            if image is None:
+                raise RuntimeError(f'Could not load DICOM image for file {img_seg_pairs[step][0]}')
+            # Get segmentation for this image
+            segmentation = self.load_segmentation(img_seg_pairs[step][1], file_type)
+            if segmentation is None:
+                LOG.warning(f'Could not load segmentation for file {img_seg_pairs[step][1]}')
+                continue
+            # Calculate metrics
+            file_name = os.path.split(img_seg_pairs[step][0].path())[1]
+            muscle_area = calculate_area(segmentation, MUSCLE, pixel_spacing)
+            muscle_idx = 0
+            muscle_ra = calculate_mean_radiation_attenuation(image, segmentation, MUSCLE)
+            muscle_lama_perc = calculate_lama_percentage(image, segmentation, MUSCLE)
+            vat_area = calculate_area(segmentation, VAT, pixel_spacing)
+            vat_idx = 0
+            vat_ra = calculate_mean_radiation_attenuation(image, segmentation, VAT)
+            sat_area = calculate_area(segmentation, SAT, pixel_spacing)
+            sat_idx = 0
+            sat_ra = calculate_mean_radiation_attenuation(image, segmentation, SAT)
+            LOG.info(f'file: {file_name}, ' +
+                    f'muscle_area: {muscle_area}, muscle_idx: {muscle_idx}, muscle_ra: {muscle_ra}, ' +
+                    f'vat_area: {vat_area}, vat_idx: {vat_idx}, vat_ra: {vat_ra}, ' +
+                    f'sat_area: {sat_area}, sat_idx: {sat_idx}, sat_ra: {sat_ra}')
+            # Update dataframe data
+            data['file'].append(file_name)
+            data['muscle_area'].append(muscle_area)
+            data['muscle_idx'].append(muscle_idx)
+            data['muscle_ra'].append(muscle_ra)
+            data['muscle_lama_perc'].append(muscle_lama_perc)
+            data['vat_area'].append(vat_area)
+            data['vat_idx'].append(vat_idx)
+            data['vat_ra'].append(vat_ra)
+            data['sat_area'].append(sat_area)
+            data['sat_idx'].append(sat_idx)
+            data['sat_ra'].append(sat_ra)
+            # Update progress
+            self.set_progress(step, nr_steps)
+        # Build dataframe and return the CSV file as output
+        csv_file_path = os.path.join(self.output(), 'bc_scores.csv')
+        xls_file_path = os.path.join(self.output(), 'bc_scores.xlsx')
+        df = pd.DataFrame(data=data)
+        df.to_csv(csv_file_path, index=False, sep=';')
+        df.to_excel(xls_file_path, index=False, engine='openpyxl')

mosamatic2/core/tasks/createdicomsummarytask/createdicomsummarytask.py

@@ -0,0 +1,88 @@
+import os
+import pandas as pd
+from mosamatic2.core.tasks.task import Task
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.core.utils import (
+    is_dicom, 
+    load_dicom,
+    current_time_in_seconds,
+    elapsed_time_in_seconds,
+    duration,
+)
+
+LOG = LogManager()
+
+
+class CreateDicomSummaryTask(Task):
+    INPUTS = ['directory']
+    PARAMS = []
+
+    def __init__(self, inputs, params, output, overwrite):
+        super(CreateDicomSummaryTask, self).__init__(inputs, params, output, overwrite)
+
+    def get_values(self, files, tag_name):
+        values = []
+        for f in files:
+            if tag_name in f.keys():
+                if f[tag_name] not in values:
+                    values.append(f[tag_name])
+        return values
+    
+    def get_tag_value(self, p, tag_name):
+        return p.data_element(tag_name).value
+    
+    def run(self):
+        series = {}
+        start_time = current_time_in_seconds()
+        for root, dirs, files in os.walk(self.input('directory')):
+            for f in files:
+                f_path = os.path.join(root, f)
+                if is_dicom(f_path):
+                    p = load_dicom(f_path, stop_before_pixels=True)
+                    if p:
+                        patient_id = self.get_tag_value(p, 'PatientID')
+                        if patient_id:
+                            if patient_id not in series.keys():
+                                series[patient_id] = {}
+                            series_instance_uid = self.get_tag_value(p, 'SeriesInstanceUID')
+                            if series_instance_uid:
+                                if series_instance_uid not in series[patient_id].keys():
+                                    series[patient_id][series_instance_uid] = []
+                                series[patient_id][series_instance_uid].append({
+                                    'series_description': self.get_tag_value(p, 'SeriesDescription'),
+                                    'slice_thickness': self.get_tag_value(p, 'SliceThickness'),
+                                    'rows': self.get_tag_value(p, 'Rows'),
+                                    'columns': self.get_tag_value(p, 'Columns'),
+                                    'pixel_spacing': self.get_tag_value(p, 'PixelSpacing'),
+                                    'modality': self.get_tag_value(p, 'Modality'),
+                                    'image_type': self.get_tag_value(p, 'ImageType'),
+                                })
+        data = {
+            'patient_id': [],
+            'series_description': [],
+            'nr_images': [],
+            'slice_thickness': [],
+            'rows': [],
+            'columns': [],
+            'pixel_spacing': [],
+            'modality': [],
+            'image_type': [],
+            'series_instance_uid': [],
+        }
+        for patient_id, v1 in series.items():
+            for series_instance_uid, v2 in v1.items():
+                data['patient_id'].append(patient_id)
+                data['series_description'].append(self.get_values(v2, tag_name='series_description'))
+                data['nr_images'].append(len(v2))
+                data['slice_thickness'].append(self.get_values(v2, tag_name='slice_thickness'))
+                data['rows'].append(self.get_values(v2, tag_name='rows'))
+                data['columns'].append(self.get_values(v2, tag_name='columns'))
+                data['pixel_spacing'].append(self.get_values(v2, tag_name='pixel_spacing'))
+                data['modality'].append(self.get_values(v2, tag_name='modality'))
+                data['image_type'].append(self.get_values(v2, tag_name='image_type'))
+                data['series_instance_uid'].append(series_instance_uid)
+        df = pd.DataFrame(data=data)
+        df.to_csv(os.path.join(self.output(), 'summary.csv'), index=False, sep=';')
+        df.to_excel(os.path.join(self.output(), 'summary.xlsx'), index=False, engine='openpyxl')
+        LOG.info(df)
+        LOG.info(f'Elapsed time: {duration(elapsed_time_in_seconds(start_time))}')

mosamatic2/core/tasks/createpngsfromsegmentationstask/createpngsfromsegmentationstask.py

@@ -0,0 +1,101 @@
+import os
+from mosamatic2.core.tasks.task import Task
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.core.data.multidicomimage import MultiDicomImage
+from mosamatic2.core.utils import (
+    convert_numpy_array_to_png_image, 
+    convert_muscle_mask_to_myosteatosis_map,
+    get_pixels_from_dicom_object,
+    AlbertaColorMap, 
+    load_numpy_array,
+)
+
+LOG = LogManager()
+
+
+class CreatePngsFromSegmentationsTask(Task):
+    INPUTS = ['images', 'segmentations']
+    PARAMS = [
+        'fig_width', 
+        'fig_height',
+        'hu_low',
+        'hu_high',
+        'alpha',
+    ]
+
+    def __init__(self, inputs, params, output, overwrite=True):
+        super(CreatePngsFromSegmentationsTask, self).__init__(inputs, params, output, overwrite)
+
+    def load_images(self):
+        image_data = MultiDicomImage()
+        image_data.set_path(self.input('images'))
+        if image_data.load():
+            return image_data
+        raise RuntimeError('Could not load images')
+
+    def load_segmentations(self):
+        segmentations = []
+        for f in os.listdir(self.input('segmentations')):
+            f_path = os.path.join(self.input('segmentations'), f)
+            if f.endswith('.seg.npy'):
+                segmentations.append(f_path)
+        if len(segmentations) == 0:
+            raise RuntimeError('Input directory has no segmentation files')
+        return segmentations
+    
+    def collect_img_seg_pairs(self, images, segmentations, file_type='npy'):
+        file_type = '.tag' if file_type == 'tag' else '.seg.npy'
+        img_seg_pairs = []
+        for image in images:
+            f_img_path = image.path()
+            f_img_name = os.path.split(f_img_path)[1]
+            for f_seg_path in segmentations:
+                f_seg_name = os.path.split(f_seg_path)[1]
+                if file_type == '.seg.npy':
+                    f_seg_name = f_seg_name.removesuffix(file_type)
+                    if f_seg_name == f_img_name:
+                        img_seg_pairs.append((image, f_seg_path))
+                elif file_type == '.tag':
+                    f_seg_name = f_seg_name.removesuffix(file_type).removesuffix('.dcm')
+                    f_img_name = f_img_name.removesuffix('.dcm')
+                    if f_seg_name == f_img_name:
+                        img_seg_pairs.append((image, f_seg_path))
+                else:
+                    raise RuntimeError('Unknown file type')
+        return img_seg_pairs
+
+    def run(self):
+        images = self.load_images()
+        segmentations = self.load_segmentations()
+        img_seg_pairs = self.collect_img_seg_pairs(images.images(), segmentations, 'npy')
+        # nr_steps = len(segmentations)
+        nr_steps = len(img_seg_pairs)
+        for step in range(nr_steps):
+            segmentation = img_seg_pairs[step][1]
+            segmentation_name = os.path.split(segmentation)[1]
+            segmentation_image = load_numpy_array(segmentation)
+            if segmentation_image is not None:
+                png_file_name = segmentation_name + '.png'
+                convert_numpy_array_to_png_image(
+                    segmentation_image, 
+                    self.output(),
+                    AlbertaColorMap(), 
+                    png_file_name,
+                    fig_width=int(self.param('fig_width')),
+                    fig_height=int(self.param('fig_height')),
+                )
+                image = img_seg_pairs[step][0]
+                image = get_pixels_from_dicom_object(image.object(), normalize=True)
+                png_file_name = segmentation_name + '_myosteatosis.png'
+                convert_muscle_mask_to_myosteatosis_map(
+                    image,
+                    segmentation_image,
+                    self.output(),
+                    png_file_name,
+                    hu_low=self.param('hu_low'),
+                    hu_high=self.param('hu_high'),
+                    alpha=self.param('alpha'),
+                )
+            else:
+                LOG.warning(f'File {segmentation} is not a valid NumPy array file')
+            self.set_progress(step, nr_steps)

mosamatic2/core/tasks/dicom2niftitask/dicom2niftitask.py

@@ -0,0 +1,45 @@
+import os
+import dicom2nifti
+from mosamatic2.core.tasks.task import Task
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.core.utils import is_dicom
+
+LOG = LogManager()
+
+
+class Dicom2NiftiTask(Task):
+    """
+    This task converts DICOM scans to NIFTI. Each scan should be stored in a separate 
+    directory (scan_dir). This task does not convert a single DICOM image!!
+    """
+    INPUTS = ['scans']
+    PARAMS = ['compressed']
+
+    def __init__(self, inputs, params, output, overwrite):
+        super(Dicom2NiftiTask, self).__init__(inputs, params, output, overwrite)
+
+    def load_scan_dirs(self):
+        scan_dirs = []
+        for d in os.listdir(self.input('scans')):
+            scan_dir = os.path.join(self.input('scans'), d)
+            if os.path.isdir(scan_dir):
+                scan_dirs.append(scan_dir)
+        return scan_dirs
+
+    def run(self):
+        scan_dirs = self.load_scan_dirs()
+        nr_steps = len(scan_dirs)
+        for step in range(nr_steps):
+            scan_dir = scan_dirs[step]
+            scan_name = os.path.split(scan_dir)[1]
+            if self.param('compressed'):
+                nifti_file_name = scan_name + '.nii.gz'
+            else:
+                nifti_file_name = scan_name + '.nii'
+            LOG.info(f'Converting DICOM series in {scan_dir} to {nifti_file_name}')
+            dicom2nifti.dicom_series_to_nifti(
+                scan_dir,
+                os.path.join(self.output(), nifti_file_name),
+                reorient_nifti=True,
+            )
+            self.set_progress(step, nr_steps)

mosamatic2/core/tasks/rescaledicomimagestask/rescaledicomimagestask.py

@@ -0,0 +1,64 @@
+import os
+import shutil
+import numpy as np
+from mosamatic2.core.tasks.task import Task
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.core.data.multidicomimage import MultiDicomImage
+from mosamatic2.core.data.dicomimage import DicomImage
+from mosamatic2.core.data.multidicomimage import MultiDicomImage
+from scipy.ndimage import zoom
+
+LOG = LogManager()
+
+
+class RescaleDicomImagesTask(Task):
+    INPUTS = ['images']
+    PARAMS = ['target_size']
+
+    def __init__(self, inputs, params, output=None, overwrite=True):
+        super(RescaleDicomImagesTask, self).__init__(inputs, params, output, overwrite)
+
+    def rescale_image(self, p, target_size):
+        pixel_array = p.pixel_array
+        hu_array = pixel_array * p.RescaleSlope + p.RescaleIntercept
+        hu_air = -1000
+        new_rows = max(p.Rows, p.Columns)
+        new_cols = max(p.Rows, p.Columns)
+        padded_hu_array = np.full((new_rows, new_cols), hu_air, dtype=hu_array.dtype)
+        padded_hu_array[:pixel_array.shape[0], :pixel_array.shape[1]] = hu_array
+        pixel_array_padded = (padded_hu_array - p.RescaleIntercept) / p.RescaleSlope
+        pixel_array_padded = pixel_array_padded.astype(pixel_array.dtype) # Image now has largest dimensions
+        pixel_array_rescaled = zoom(pixel_array_padded, zoom=(target_size / new_rows), order=3) # Cubic interpolation
+        pixel_array_rescaled = pixel_array_rescaled.astype(pixel_array.dtype)
+        original_pixel_spacing = p.PixelSpacing
+        new_pixel_spacing = [ps * (new_rows / target_size) for ps in original_pixel_spacing]
+        p.PixelSpacing = new_pixel_spacing
+        p.PixelData = pixel_array_rescaled.tobytes()
+        p.Rows = target_size
+        p.Columns = target_size
+        return p
+
+    def run(self):
+        image_data = MultiDicomImage()
+        image_data.set_path(self.input('images'))
+        if image_data.load():
+            images = image_data.images()
+            nr_steps = len(images)
+            for step in range(nr_steps):
+                source = images[step]
+                assert isinstance(source, DicomImage)
+                p = source.object()
+                if len(p.pixel_array.shape) == 2:
+                    source_name = os.path.split(source.path())[1]
+                    if p.Rows != self.param('target_size') or p.Columns != self.param('target_size'):
+                        p = self.rescale_image(p, self.param('target_size'))
+                        target = os.path.join(self.output(), source_name)
+                        p.save_as(target)
+                    else:
+                        target = os.path.join(self.output(), source_name)
+                        shutil.copy(source.path(), target)
+                else:
+                    LOG.warning(f'Shape of pixel data in file {source.path()} should be 2D but is {len(p.pixel_array.shape)}D')
+                self.set_progress(step, nr_steps)
+        else:
+            LOG.error('Error loading multi-DICOM image data')

mosamatic2/core/tasks/segmentationnifti2numpytask/segmentationnifti2numpytask.py

@@ -0,0 +1,57 @@
+import os
+import numpy as np
+import nibabel as nib
+import matplotlib.pyplot as plt
+from mosamatic2.core.tasks.task import Task
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.core.utils import (
+    convert_numpy_array_to_png_image,
+    AlbertaColorMap, 
+)
+LOG = LogManager()
+
+
+class SegmentationNifti2NumpyTask(Task):
+    INPUTS = ['segmentations']
+    PARAMS = ['png']
+
+    def __init__(self, inputs, params, output, overwrite):
+        super(SegmentationNifti2NumpyTask, self).__init__(inputs, params, output, overwrite)
+
+    def load_segmentations(self):
+        segmentations = []
+        for f in os.listdir(self.input('segmentations')):
+            if f.endswith('.seg.npy.nii.gz'):
+                f_path = os.path.join(self.input('segmentations'), f)
+                segmentations.append(f_path)
+        return segmentations
+    
+    def load_segmentation_as_nifti(self, segmentation):
+        nifti = nib.load(segmentation)
+        narray = np.asanyarray(nifti.dataobj)
+        narray = narray[..., 0]
+        narray = np.rot90(narray, k=3, axes=(0, 1))
+        return narray
+    
+    def create_png_from_array(self, data, file_path):
+        png_file_name = os.path.split(file_path)[1] + '.png'
+        convert_numpy_array_to_png_image(
+            data, 
+            self.output(),
+            AlbertaColorMap(), 
+            png_file_name,
+            fig_width=10, fig_height=10,
+        )
+
+    def run(self):
+        segmentations = self.load_segmentations()        
+        nr_steps = len(segmentations)
+        for step in range(nr_steps):
+            segmentation = segmentations[step]
+            segmentation_narray = self.load_segmentation_as_nifti(segmentation)
+            segmentation_narray_name = os.path.split(segmentation)[1][:-7]
+            segmentation_narray_path = os.path.join(self.output(), segmentation_narray_name)
+            np.save(segmentation_narray_path, segmentation_narray)
+            if self.param('png'):
+                self.create_png_from_array(segmentation_narray, segmentation_narray_path)
+            self.set_progress(step, nr_steps)