mosamatic2 2.0.24__py3-none-any.whl

mosamatic2/core/data/multidicomimage.py

@@ -0,0 +1,30 @@
+import os
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.core.data.filedata import FileData
+from mosamatic2.core.data.dicomimage import DicomImage
+
+LOG = LogManager()
+
+
+class MultiDicomImage(FileData):
+    def __init__(self):
+        super(MultiDicomImage, self).__init__()
+        self._images = []
+
+    def images(self):
+        return self._images
+    
+    def load(self):
+        series_instance_uids = []
+        if self.path():
+            for f in os.listdir(self.path()):
+                f_path = os.path.join(self.path(), f)
+                image = DicomImage()
+                image.set_path(f_path)
+                if image.load():
+                    series_instance_uid = image.object().SeriesInstanceUID
+                    if series_instance_uid in series_instance_uids:
+                        RuntimeError('Cannot load DICOM images with identical series instance UID')
+                    self._images.append(image)
+            return True
+        return False

mosamatic2/core/data/multiniftiimage.py

@@ -0,0 +1,26 @@
+import os
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.core.data.filedata import FileData
+from mosamatic2.core.data.niftiimage import NiftiImage
+
+LOG = LogManager()
+
+
+class MultiNiftiImage(FileData):
+    def __init__(self):
+        super(MultiNiftiImage, self).__init__()
+        self._images = []
+
+    def images(self):
+        return self._images
+    
+    def load(self):
+        if self.path():
+            for f in os.listdir(self.path()):
+                f_path = os.path.join(self.path(), f)
+                image = NiftiImage()
+                image.set_path(f_path)
+                if image.load():
+                    self._images.append(image)
+            return True
+        return False

mosamatic2/core/data/multinumpyimage.py

@@ -0,0 +1,26 @@
+import os
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.core.data.filedata import FileData
+from mosamatic2.core.data.numpyimage import NumpyImage
+
+LOG = LogManager()
+
+
+class MultiNumpyImage(FileData):
+    def __init__(self):
+        super(MultiNumpyImage, self).__init__()
+        self._images = []
+
+    def images(self):
+        return self._images
+    
+    def load(self):
+        if self.path():
+            for f in os.listdir(self.path()):
+                f_path = os.path.join(self.path(), f)
+                image = NumpyImage()
+                image.set_path(f_path)
+                if image.load():
+                    self._images.append(image)
+            return True
+        return False

mosamatic2/core/data/niftiimage.py

@@ -0,0 +1,13 @@
+from mosamatic2.core.data.filedata import FileData
+from mosamatic2.core.utils import (
+    is_nifti,
+    load_nifti,
+)
+
+class NiftiImage(FileData):
+    def load(self):
+        if self.path():
+            if is_nifti(self.path()):
+                self.set_object(load_nifti(self.path()))
+                return True
+        return False

mosamatic2/core/data/numpyimage.py

@@ -0,0 +1,13 @@
+from mosamatic2.core.data.filedata import FileData
+from mosamatic2.core.utils import (
+    is_numpy,
+    load_numpy_array,
+)
+
+class NumpyImage(FileData):
+    def load(self):
+        if self.path():
+            if is_numpy(self.path()):
+                self.set_object(load_numpy_array(self.path()))
+                return True
+        return False

mosamatic2/core/managers/logmanager.py

@@ -0,0 +1,45 @@
+import os
+import atexit
+import datetime
+from pathlib import Path
+from mosamatic2.core.singleton import singleton
+
+
+@singleton
+class LogManager:
+    def __init__(self, suppress_print=False):
+        self._suppress_print = suppress_print
+        self._listeners = []
+        file_path = os.path.join(Path.home(), 'mosamatic2.log')
+        self._file_handle = open(file_path, 'w', buffering=1)
+        atexit.register(self.close_file)
+
+    def _log(self, level, message):
+        timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        message = f'[{timestamp}] {level} : {message}'
+        if not self._suppress_print:
+            print(message)
+        self._file_handle.write(message + '\n')
+        self.notify_listeners(message)
+        return message
+
+    def info(self, message):
+        return self._log('INFO', message)
+
+    def warning(self, message):
+        return self._log('WARNING', message)
+
+    def error(self, message):
+        return self._log('ERROR', message)
+    
+    def add_listener(self, listener):
+        if listener not in self._listeners:
+            self._listeners.append(listener)
+
+    def notify_listeners(self, message):
+        for listener in self._listeners:
+            listener.new_message(message)
+
+    def close_file(self):
+        if self._file_handle:
+            self._file_handle.close()

mosamatic2/core/managers/logmanagerlistener.py

@@ -0,0 +1,3 @@
+class LogManagerListener:
+    def new_message(self, message):
+        raise NotImplementedError()

mosamatic2/core/pipelines/__init__.py

@@ -0,0 +1,4 @@
+from mosamatic2.core.pipelines.defaultpipeline.defaultpipeline import DefaultPipeline
+from mosamatic2.core.pipelines.defaultdockerpipeline.defaultdockerpipeline import DefaultDockerPipeline
+from mosamatic2.core.pipelines.boadockerpipeline.boadockerpipeline import BoaDockerPipeline
+from mosamatic2.core.pipelines.liveranalysispipeline.liveranalysispipeline import LiverAnalysisPipeline

mosamatic2/core/pipelines/boadockerpipeline/boadockerpipeline.py

@@ -0,0 +1,70 @@
+import os
+from mosamatic2.core.pipelines.pipeline import Pipeline
+from mosamatic2.core.tasks import Dicom2NiftiTask
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.core.utils import (
+    is_docker_running, 
+    to_unix_path,
+    current_time_in_seconds,
+    elapsed_time_in_seconds,
+    duration,
+)
+
+LOG = LogManager()
+
+
+class BoaDockerPipeline(Pipeline):
+    INPUTS = ['scans']
+    PARAMS = []
+
+    def __init__(self, inputs, params, output, overwrite):
+        super(BoaDockerPipeline, self).__init__(inputs, params, output, overwrite)
+
+    def load_nifti_files(self):
+        nifti_files_dir = os.path.join(self.output(), 'dicom2niftitask')
+        nifti_files = []
+        for f in os.listdir(nifti_files_dir):
+            f_path = os.path.join(nifti_files_dir, f)
+            if f.endswith('.nii') or f.endswith('.nii.gz'):
+                nifti_files.append(f_path)
+        return nifti_files
+
+    def run(self):
+        assert is_docker_running()
+        # First convert DICOM series to NIFTI format
+        dicom2nifti_task = Dicom2NiftiTask(
+            inputs={'scans': self.input('scans')},
+            params={'compressed': True},
+            output=self.output(),
+            overwrite=self.overwrite(),
+        )
+        dicom2nifti_task.run()
+        # Load NIFTI file paths
+        nifti_files = self.load_nifti_files()
+        workspaces_dir = to_unix_path(os.path.join(self.output(), 'workspaces'))
+        os.makedirs(workspaces_dir, exist_ok=True)
+        weights_dir = to_unix_path(os.path.join(self.output(), 'weights'))
+        start_time = current_time_in_seconds()
+        for f in nifti_files:
+            start_time_f = current_time_in_seconds()
+            f = to_unix_path(f)
+            dir_name = os.path.split(f)[1][:-7]
+            workspace = to_unix_path(os.path.join(workspaces_dir, dir_name))
+            # Build Docker script
+            docker_script = 'docker run --rm ' + \
+                '-v "{}":/image.nii.gz '.format(f) + \
+                '-v "{}":/workspace '.format(workspace) + \
+                '-v "{}":/app/weights '.format(weights_dir) + \
+                '--gpus all ' + \
+                '--network host ' + \
+                '--shm-size=8g --ulimit memlock=-1 --ulimit stack=67108864 ' + \
+                '--entrypoint /bin/sh ' + \
+                'shipai/boa-cli -c ' + \
+                '"python body_organ_analysis --input-image /image.nii.gz --output-dir /workspace/ --models all --verbose"'
+            LOG.info(f'Running BOA Docker script: {docker_script}')
+            # Run Docker script
+            os.system(docker_script)
+            elapsed_f = elapsed_time_in_seconds(start_time_f)
+            LOG.info(f'Elapsed {dir_name}: {duration(elapsed_f)}')
+        elapsed_total = elapsed_time_in_seconds(start_time)
+        LOG.info(f'Elapsed total: {duration(elapsed_total)}')

mosamatic2/core/pipelines/defaultdockerpipeline/defaultdockerpipeline.py

@@ -0,0 +1,28 @@
+import os
+from mosamatic2.core.pipelines.pipeline import Pipeline
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.core.utils import is_docker_running, to_unix_path
+
+LOG = LogManager()
+
+
+class DefaultDockerPipeline(Pipeline):
+    INPUTS = [
+        'images',
+        'model_files',
+    ]
+    PARAMS = ['version']
+    
+    def __init__(self, inputs, params, output, overwrite):
+        super(DefaultDockerPipeline, self).__init__(inputs, params, output, overwrite)
+
+    def run(self):
+        assert is_docker_running()
+        docker_script = 'docker run --rm ' + \
+            '-v "{}":/data/images '.format(to_unix_path(self.input('images'))) + \
+            '-v "{}":/data/model_files '.format(to_unix_path(self.input('model_files'))) + \
+            '-v "{}":/data/output '.format(to_unix_path(self.output())) + \
+            'brecheisen/mosamatic2-cli:{} defaultpipeline '.format(self.param('version')) + \
+            '--images /data/images --model_files /data/model_files --output /data/output --overwrite true'
+        LOG.info(f'Running Docker script: {docker_script}')
+        os.system(docker_script)

mosamatic2/core/pipelines/defaultpipeline/defaultpipeline.py

@@ -0,0 +1,90 @@
+import os
+
+from mosamatic2.core.pipelines.pipeline import Pipeline
+from mosamatic2.core.tasks import (
+    RescaleDicomImagesTask, 
+    SegmentMuscleFatL3TensorFlowTask,
+    SegmentMuscleFatL3TensorFlowTask,
+    CreatePngsFromSegmentationsTask,
+    CalculateScoresTask,
+)
+from mosamatic2.core.managers.logmanager import LogManager
+
+LOG = LogManager()
+
+
+class DefaultPipeline(Pipeline):
+    INPUTS = [
+        'images',
+        'model_files',
+    ]
+    PARAMS = [
+        'target_size',
+        'file_type',
+        'fig_width',
+        'fig_height',
+        'model_type',
+        'model_version',
+        'hu_low',
+        'hu_high',
+        'alpha',
+    ]
+    def __init__(self, inputs, params, output, overwrite):
+        super(DefaultPipeline, self).__init__(inputs, params, output, overwrite)
+        LOG.info('Found {} images to process'.format(len(os.listdir(self.input('images')))))
+        model_type = self.param('model_type')
+        # segmentation_task_class = SegmentMuscleFatL3Task if model_type == 'pytorch' else SegmentMuscleFatL3TensorFlowTask
+        segmentation_task_class = SegmentMuscleFatL3TensorFlowTask
+        self.add_task(
+            RescaleDicomImagesTask(
+                inputs={'images': self.input('images')},
+                params={'target_size': self.param('target_size')},
+                output=self.output(),
+                overwrite=self.overwrite(),
+            )
+        )
+        self.add_task(
+            segmentation_task_class(
+                inputs={
+                    'images': os.path.join(self.output(), 'rescaledicomimagestask'),
+                    'model_files': self.input('model_files'),
+                },
+                params={'model_version': self.param('model_version')},
+                output=self.output(),
+                overwrite=self.overwrite(),
+            )
+        )
+        self.add_task(
+            CalculateScoresTask(
+                inputs={
+                    'images': os.path.join(self.output(), 'rescaledicomimagestask'),
+                    'segmentations': os.path.join(
+                        self.output(),
+                        'segmentmusclefatl3pytorchtask' if model_type == 'pytorch' else 'segmentmusclefatl3tensorflowtask',
+                    )
+                },
+                params={'file_type': self.param('file_type')},
+                output=self.output(),
+                overwrite=self.overwrite(),
+            )
+        )
+        self.add_task(
+            CreatePngsFromSegmentationsTask(
+                inputs={
+                    'images': os.path.join(self.output(), 'rescaledicomimagestask'),
+                    'segmentations': os.path.join(
+                        self.output(),
+                        'segmentmusclefatl3pytorchtask' if model_type == 'pytorch' else 'segmentmusclefatl3tensorflowtask',
+                    )
+                },
+                params={
+                    'fig_width': self.param('fig_width'),
+                    'fig_height': self.param('fig_height'),
+                    'hu_low': self.param('hu_low'),
+                    'hu_high': self.param('hu_high'),
+                    'alpha': self.param('alpha'),
+                },
+                output=self.output(),
+                overwrite=self.overwrite(),
+            )
+        )

mosamatic2/core/pipelines/liveranalysispipeline/liveranalysispipeline.py

@@ -0,0 +1,48 @@
+import os
+from mosamatic2.core.pipelines.pipeline import Pipeline
+from mosamatic2.core.tasks import (
+    Dicom2NiftiTask,
+    TotalSegmentatorTask,
+    CalculateMaskStatisticsTask,
+)
+from mosamatic2.core.managers.logmanager import LogManager
+
+LOG = LogManager()
+
+
+class LiverAnalysisPipeline(Pipeline):
+    INPUTS = ['scans']
+    PARAMS = ['compressed']
+
+    def __init__(self, inputs, params, output, overwrite):
+        super(LiverAnalysisPipeline, self).__init__(inputs, params, output, overwrite)
+        self.add_task(
+            Dicom2NiftiTask(
+                inputs={'scans': self.input('scans')},
+                params={'compressed': self.param('compressed')},
+                output=self.output(),
+                overwrite=self.overwrite(),
+            )
+        )
+        self.add_task(
+            TotalSegmentatorTask(
+                inputs={'scans': os.path.join(self.output(), 'dicom2niftitask')},
+                params={
+                    'tasks': 'liver_segments', 
+                    'format': 'nifti',
+                },
+                output=self.output(),
+                overwrite=self.overwrite(),
+            )
+        )
+        self.add_task(
+            CalculateMaskStatisticsTask(
+                inputs={
+                    'scans': os.path.join(self.output(), 'dicom2niftitask'),
+                    'masks': os.path.join(self.output(), 'totalsegmentatortask'),
+                },
+                params=None,
+                output=self.output(),
+                overwrite=self.overwrite(),
+            )
+        )

mosamatic2/core/pipelines/pipeline.py

@@ -0,0 +1,14 @@
+from mosamatic2.core.tasks.task import Task
+
+
+class Pipeline(Task):
+    def __init__(self, inputs, params, output, overwrite=False):
+        super(Pipeline, self).__init__(inputs, params, output, overwrite)
+        self._tasks = []
+
+    def add_task(self, task):
+        self._tasks.append(task)
+
+    def run(self):
+        for task in self._tasks:
+            task.run()

mosamatic2/core/singleton.py

@@ -0,0 +1,9 @@
+def singleton(cls):
+    _instances = {}
+
+    def instance(*args, **kwargs):
+        if cls not in _instances:
+            _instances[cls] = cls(*args, **kwargs)
+        return _instances[cls]
+    
+    return instance

mosamatic2/core/tasks/__init__.py

@@ -0,0 +1,13 @@
+from mosamatic2.core.tasks.rescaledicomimagestask.rescaledicomimagestask import RescaleDicomImagesTask
+from mosamatic2.core.tasks.segmentmusclefatl3tensorflowtask.segmentmusclefatl3tensorflowtask import SegmentMuscleFatL3TensorFlowTask
+from mosamatic2.core.tasks.calculatescorestask.calculatescorestask import CalculateScoresTask
+from mosamatic2.core.tasks.createpngsfromsegmentationstask.createpngsfromsegmentationstask import CreatePngsFromSegmentationsTask
+from mosamatic2.core.tasks.dicom2niftitask.dicom2niftitask import Dicom2NiftiTask
+from mosamatic2.core.tasks.selectslicefromscanstask.selectslicefromscanstask import SelectSliceFromScansTask
+from mosamatic2.core.tasks.createdicomsummarytask.createdicomsummarytask import CreateDicomSummaryTask
+from mosamatic2.core.tasks.totalsegmentatortask.totalsegmentatortask import TotalSegmentatorTask
+from mosamatic2.core.tasks.calculatemaskstatisticstask.calculatemaskstatisticstask import CalculateMaskStatisticsTask
+from mosamatic2.core.tasks.segmentmusclefatt4pytorchtask.segmentmusclefatt4pytorchtask import SegmentMuscleFatT4PyTorchTask
+from mosamatic2.core.tasks.segmentationnumpy2niftitask.segmentationnumpy2niftitask import SegmentationNumpy2NiftiTask
+from mosamatic2.core.tasks.segmentationnifti2numpytask.segmentationnifti2numpytask import SegmentationNifti2NumpyTask
+from mosamatic2.core.tasks.applythresholdtosegmentationstask.applythresholdtosegmentationstask import ApplyThresholdToSegmentationsTask

mosamatic2/core/tasks/applythresholdtosegmentationstask/applythresholdtosegmentationstask.py

@@ -0,0 +1,117 @@
+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 ApplyThresholdToSegmentationsTask(Task):
+    INPUTS = [
+        'images',
+        'segmentations'
+    ]
+    PARAMS = [
+        'label',
+        'threshold_low', 
+        'threshold_high'
+    ]
+
+    def __init__(self, inputs, params, output, overwrite=True):
+        super(ApplyThresholdToSegmentationsTask, self).__init__(inputs, params, output, overwrite)
+
+    def collect_image_segmentation_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):
+        images = self.load_images().images()
+        segmentations = self.load_segmentations()
+        image_segmentation_pairs = self.collect_image_segmentation_pairs(images, segmentations)
+        threshold_low = self.param('threshold_low')
+        threshold_high = self.param('threshold_high')
+        label = self.param('label')
+        nr_steps = len(image_segmentation_pairs)
+        for step in range(nr_steps):
+            image, pixel_spacing = self.load_pixels_and_spacing(image_segmentation_pairs[step][0])
+            segmentation = self.load_segmentation(image_segmentation_pairs[step][1])
+            area = calculate_area(segmentation, label, pixel_spacing)
+            LOG.info(f'area: {area} mm')
+            segmentation_new = segmentation.copy()
+            segmentation_new[(segmentation_new == label) & (image < threshold_low)] = 0
+            area_new = calculate_area(segmentation_new, label, pixel_spacing)
+            LOG.info(f'area_new: {area_new} mm')
+            segmentation_new_file_name = os.path.split(image_segmentation_pairs[step][0].path())[1]
+            segmentation_new_file_path = os.path.join(self.output(), f'{segmentation_new_file_name}.seg.npy')
+            np.save(segmentation_new_file_path, segmentation_new)
+            self.set_progress(step, nr_steps)