mosamatic2 2.0.2__py3-none-any.whl → 2.0.4__py3-none-any.whl

mosamatic2/core/tasks/calculatescorestask/calculatescorestask.py

@@ -0,0 +1,149 @@
+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.utils import (
+    is_dicom, 
+    load_dicom,
+    is_jpeg2000_compressed,
+    get_pixels_from_dicom_object,
+    calculate_area,
+    calculate_mean_radiation_attenuation,
+    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((f_img_path, f_seg_path))
+                        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((f_img_path, f_seg_path))
+                        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':
+            return np.load(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': [],
+            '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)
+            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['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/createpngsfromsegmentationstask/createpngsfromsegmentationstask.py

@@ -0,0 +1,52 @@
+import os
+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, 
+    load_numpy_array,
+)
+
+LOG = LogManager()
+
+
+class CreatePngsFromSegmentationsTask(Task):
+    INPUTS = ['segmentations']
+    PARAMS = [
+        'fig_width', 
+        'fig_height'
+    ]
+
+    def __init__(self, inputs, params, output, overwrite=True):
+        super(CreatePngsFromSegmentationsTask, self).__init__(inputs, params, output, overwrite)
+
+    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 run(self):
+        segmnentations = self.load_segmentations()
+        nr_steps = len(segmnentations)
+        for step in range(nr_steps):
+            source = segmnentations[step]
+            source_name = os.path.split(source)[1]
+            source_image = load_numpy_array(source)
+            if source_image is not None:
+                png_file_name = source_name + '.png'
+                convert_numpy_array_to_png_image(
+                    source_image, 
+                    self.output(),
+                    AlbertaColorMap(), 
+                    png_file_name,
+                    fig_width=int(self.param('fig_width')),
+                    fig_height=int(self.param('fig_height')),
+                )
+            else:
+                LOG.warning(f'File {source} is not a valid NumPy array file')
+            self.set_progress(step, nr_steps)

mosamatic2/core/tasks/dicom2niftitask/dicom2niftitask.py

@@ -0,0 +1,24 @@
+import os
+import dicom2nifti
+from mosamatic2.core.tasks.task import Task
+from mosamatic2.core.managers.logmanager import LogManager
+
+LOG = LogManager()
+
+
+class Dicom2NiftiTask(Task):
+    INPUTS = ['images']
+    PARAMS = []
+
+    def __init__(self, inputs, params, output, overwrite):
+        super(Dicom2NiftiTask, self).__init__(inputs, params, output, overwrite)
+
+    def run(self):
+        nifti_file_name = os.path.split(self.input('images'))[1] + '.nii.gz'
+        LOG.info(f'Converting DICOM directory to {nifti_file_name}')
+        dicom2nifti.dicom_series_to_nifti(
+            self.input('images'),
+            os.path.join(self.output(), nifti_file_name),
+            reorient_nifti=True,
+        )
+        self.set_progress(0, 1)

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/segmentmusclefatl3tensorflowtask/paramloader.py

@@ -0,0 +1,39 @@
+import json
+
+
+class ParamLoader:
+    def __init__(self, json_path):
+        self.update(json_path)
+
+    def save(self, json_path):
+        """"
+        Save dict to json file
+
+        Parameters
+        ----------
+        json_path : string
+            Path to save location
+        """
+        with open(json_path, 'w') as f:
+            json.dump(self.__dict__, f, indent=4)
+
+    def update(self, json_path):
+        """
+        Load parameters from json file
+
+        Parameters
+        ----------
+        json_path : string
+            Path to json file
+        """
+        with open(json_path) as f:
+            params = json.load(f)
+            self.__dict__.update(params)
+
+    @property
+    def dict(self):
+        """"
+        Give dict-like access to Params instance
+        by: 'params.dict['learning_rate']'
+        """
+        return self.__dict__

mosamatic2/core/tasks/segmentmusclefatl3tensorflowtask/segmentmusclefatl3tensorflowtask.py

@@ -0,0 +1,121 @@
+import os
+import zipfile
+import tempfile
+import numpy as np
+
+import models
+
+from mosamatic2.core.tasks.task import Task
+from mosamatic2.core.tasks.segmentmusclefatl3tensorflowtask.paramloader import ParamLoader
+from mosamatic2.core.data.multidicomimage import MultiDicomImage
+from mosamatic2.core.data.dicomimage import DicomImage
+from mosamatic2.core.utils import (
+    normalize_between,
+    get_pixels_from_dicom_object,
+    convert_labels_to_157,
+)
+
+DEVICE = 'cpu'
+
+
+class SegmentMuscleFatL3TensorFlowTask(Task):
+    INPUTS = [
+        'images', 
+        'model_files'
+    ]
+    PARAMS = ['model_version']
+
+    def __init__(self, inputs, params, output, overwrite=True):
+        super(SegmentMuscleFatL3TensorFlowTask, 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_model_files(self):
+        model_files = []
+        for f in os.listdir(self.input('model_files')):
+            f_path = os.path.join(self.input('model_files'), f)
+            if f_path.endswith('.zip') or f_path.endswith('.json'):
+                model_files.append(f_path)
+        if len(model_files) != 3:
+            raise RuntimeError(f'Found {len(model_files)} model files. This should be 3!')
+        return model_files
+
+    def load_models_and_params(self, model_files, model_version):
+        tfLoaded = False
+        model, contour_model, params = None, None, None
+        for f_path in model_files:
+            f_name = os.path.split(f_path)[1]
+            if f_name == f'model-{str(model_version)}.zip':
+                if not tfLoaded:
+                    import tensorflow as tf
+                    tfLoaded = True
+                with tempfile.TemporaryDirectory() as model_dir_unzipped:
+                # model_dir_unzipped = os.path.join(os.path.split(f_path)[0], 'model_unzipped')
+                    os.makedirs(model_dir_unzipped, exist_ok=True)
+                    with zipfile.ZipFile(f_path) as zipObj:
+                        zipObj.extractall(path=model_dir_unzipped)
+                    model = tf.keras.models.load_model(model_dir_unzipped, compile=False)
+            elif f_name == f'contour_model-{str(model_version)}.zip':
+                if not tfLoaded:
+                    import tensorflow as tf
+                    tfLoaded = True
+                with tempfile.TemporaryDirectory() as contour_model_dir_unzipped:
+                # contour_model_dir_unzipped = os.path.join(os.path.split(f_path)[0], 'contour_model_unzipped')
+                    os.makedirs(contour_model_dir_unzipped, exist_ok=True)
+                    with zipfile.ZipFile(f_path) as zipObj:
+                        zipObj.extractall(path=contour_model_dir_unzipped)
+                    contour_model = tf.keras.models.load_model(contour_model_dir_unzipped, compile=False)
+            elif f_name == f'params-{model_version}.json':
+                params = ParamLoader(f_path)
+            else:
+                pass
+        return model, contour_model, params
+
+    def extract_contour(self, image, contour_model, params):
+        ct = np.copy(image)
+        ct = normalize_between(ct, params.dict['min_bound_contour'], params.dict['max_bound_contour'])
+        img2 = np.expand_dims(ct, 0)
+        img2 = np.expand_dims(img2, -1)
+        pred = contour_model.predict([img2])
+        pred_squeeze = np.squeeze(pred)
+        pred_max = pred_squeeze.argmax(axis=-1)
+        mask = np.uint8(pred_max)
+        return mask
+
+    def segment_muscle_and_fat(self, image, model):
+        img2 = np.expand_dims(image, 0)
+        img2 = np.expand_dims(img2, -1)
+        pred = model.predict([img2])
+        pred_squeeze = np.squeeze(pred)
+        pred_max = pred_squeeze.argmax(axis=-1)
+        return pred_max
+        
+    def process_file(self, image, output_dir, model, contour_model, params):
+        assert isinstance(image, DicomImage)
+        pixels = get_pixels_from_dicom_object(image.object(), normalize=True)
+        if contour_model:
+            mask = self.extract_contour(pixels, contour_model, params)
+            pixels = normalize_between(pixels, params.dict['min_bound'], params.dict['max_bound'])
+            pixels = pixels * mask
+        pixels = pixels.astype(np.float32)
+        segmentation = self.segment_muscle_and_fat(pixels, model)
+        segmentation = convert_labels_to_157(segmentation)
+        segmentation_file_name = os.path.split(image.path())[1]
+        segmentation_file_path = os.path.join(output_dir, f'{segmentation_file_name}.seg.npy')
+        np.save(segmentation_file_path, segmentation)
+
+    def run(self):
+        image_data = self.load_images()
+        model_files = self.load_model_files()
+        model_version = self.param('model_version')
+        model, contour_model, params = self.load_models_and_params(model_files, model_version)
+        images = image_data.images()
+        nr_steps = len(images)
+        for step in range(nr_steps):
+            self.process_file(images[step], self.output(), model, contour_model, params)
+            self.set_progress(step, nr_steps)

mosamatic2/core/tasks/task.py

@@ -0,0 +1,50 @@
+import os
+import shutil
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.core.utils import create_name_with_timestamp, mosamatic_output_dir
+
+LOG = LogManager()
+
+
+class Task:
+    INPUTS = []
+    PARAMS = []
+    OUTPUT = 'output'
+
+    def __init__(self, inputs, params, output, overwrite=True):
+        self._inputs = inputs
+        self._params = params
+        self._output = os.path.join(output, self.__class__.__name__.lower())
+        self._overwrite = overwrite
+        if self._overwrite and os.path.isdir(self._output):
+            shutil.rmtree(self._output)
+        os.makedirs(self._output, exist_ok=self._overwrite)
+        # Check that the inputs match specification and type
+        assert isinstance(self._inputs, dict)
+        assert len(self._inputs.keys()) == len(self.__class__.INPUTS)
+        for k, v in self._inputs.items():
+            assert k in self.__class__.INPUTS
+            assert isinstance(v, str)
+        # Check that param names match specification (if not None)
+        if self._params:
+            assert len(self._params.keys()) == len(self.__class__.PARAMS)
+            for k in self._params.keys():
+                assert k in self.__class__.PARAMS
+
+    def input(self, name):
+        return self._inputs[name]
+    
+    def param(self, name):
+        return self._params[name]
+    
+    def output(self):
+        return self._output
+    
+    def overwrite(self):
+        return self._overwrite
+    
+    def set_progress(self, step, nr_steps):
+        LOG.info(f'[{self.__class__.__name__}] step {step} from {nr_steps}')
+    
+    def run(self):
+        raise NotImplementedError()