mosamatic2 2.0.1__py3-none-any.whl → 2.0.3__py3-none-any.whl

mosamatic2/app.py

@@ -1,2 +1,32 @@
+import sys
+import traceback
+import mosamatic2.constants as constants
+from PySide6 import QtWidgets
+from mosamatic2.ui.settings import Settings
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.ui.widgets.splashscreen import SplashScreen
+
+LOG = LogManager()
+
+
+def run_tests():
+    return 'PASSED'
+
+
 def main():
-    print('Running mosamatic2...')
+    settings = Settings()
+    application_name = settings.get(constants.MOSAMATIC2_WINDOW_TITLE)
+    QtWidgets.QApplication.setApplicationName(application_name)
+    app = QtWidgets.QApplication(sys.argv)
+    app.setApplicationName(application_name)
+    try:
+        splash = SplashScreen()
+        splash.show()
+        sys.exit(app.exec())
+    except Exception as e:
+        LOG.error(str(e))
+        LOG.error(traceback.format_exc())
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()

mosamatic2/cli.py

@@ -0,0 +1,32 @@
+import click
+from mosamatic2.commands import (
+    calculatescores,
+    rescaledicomimages,
+    segmentmusclefatl3tensorflow,
+    createpngsfromsegmentations,
+)
+from mosamatic2.core.utils import show_doc_command
+
+
+class CustomHelpGroup(click.Group):
+    def format_commands(self, ctx, formatter):
+        commands = self.list_commands(ctx)
+        with formatter.section('Commands'):
+            for command_name in commands:
+                command = self.get_command(ctx, command_name)
+                if command is None or command.hidden:
+                    continue
+                help_text = command.get_short_help_str()
+                formatter.write_text(f'{command_name:15} {help_text}')
+
+
+@click.group(cls=CustomHelpGroup)
+def main():
+    pass
+
+
+main.add_command(calculatescores.calculatescores)
+main.add_command(rescaledicomimages.rescaledicomimages)
+main.add_command(segmentmusclefatl3tensorflow.segmentmusclefatl3tensorflow)
+main.add_command(createpngsfromsegmentations.createpngsfromsegmentations)
+main.add_command(show_doc_command(main)) # Special command to show long description for command

mosamatic2/commands/calculatescores.py

@@ -0,0 +1,73 @@
+import click
+
+from mosamatic2.core.tasks import CalculateScoresTask
+
+
+@click.command(help='Calculates body composition scores')
+@click.option(
+    '--images', 
+    required=True, 
+    type=click.Path(exists=True), 
+    help='Directory with images',
+)
+@click.option(
+    '--segmentations',
+    required=True,
+    type=click.Path(exists=True), 
+    help='Directory with segmentations',
+)
+@click.option(
+    '--output', 
+    required=True, 
+    type=click.Path(), 
+    help='Output directory'
+)
+@click.option(
+    '--file_type',
+    default='npy',
+    help='Options: [npy, tag]'
+)
+@click.option(
+    '--overwrite', 
+    type=click.BOOL, 
+    default=False, 
+    help='Overwrite [true|false]'
+)
+def calculatescores(images, segmentations, output, file_type, overwrite):
+    """
+    Calculates the following body composition metrics from the muscle and fat 
+    images and segmentation files:
+
+    (1) Muscle area (cm^2)
+    (2) Mean muscle radiation attenuation (HU)
+    (3) Subcutaneous fat area (cm^2)
+    (4) Mean subcutaneous fat radiation attenuation (HU)
+    (5) Visceral fat area (cm^2)
+    (6) Mean visceral fat radiation attenuation (HU)
+    
+    Parameters
+    ----------
+    --images : str
+        Directory with with input L3 images
+
+    --segmentations : str
+        Directory with L3 muscle and fat segmenation files. Must be output of 
+        "mosamatic2-cli segmentmusclefatl3tensorflow" OR a list of TAG files
+        corresponding to the input images
+
+    --output : str
+        Path to output directory
+
+    --file_type : str
+        Type of segmentation file to use. Can be either "npy" or "tag"
+    
+    --overwrite : bool
+        Overwrite contents output directory [true|false]
+    """
+    task = CalculateScoresTask(
+        inputs={'images': images, 'segmentations': segmentations},
+        params={'file_type': file_type},
+        output=output,
+        overwrite=overwrite,
+    )
+    task.run()

mosamatic2/commands/createpngsfromsegmentations.py

@@ -0,0 +1,65 @@
+import click
+
+from mosamatic2.core.tasks import CreatePngsFromSegmentationsTask
+
+
+@click.command(help='Create PNG images from segmentation files')
+@click.option(
+    '--segmentations', 
+    required=True, 
+    type=click.Path(exists=True), 
+    help='Input directory to segmentation files'
+)
+@click.option(
+    '--output', 
+    required=True, 
+    type=click.Path(), 
+    help='Output directory for PNG images'
+)
+@click.option(
+    '--fig_width', 
+    type=click.Path(), 
+    default=10,
+    help='Figure width (default: 10)'
+)
+@click.option(
+    '--fig_height', 
+    type=click.Path(), 
+    default=10,
+    help='Figure height (default: 10)'
+)
+@click.option(
+    '--overwrite', 
+    type=click.BOOL, 
+    default=False, 
+    help='Overwrite [true|false]'
+)
+def createpngsfromsegmentations(segmentations, output, fig_width, fig_height, overwrite):
+    """
+    Creates PNG images from L3 muscle and fat segmentation files
+    
+    Parameters
+    ----------
+    --segmentations : str
+        Directory with with input segmentation files. Must be L3 muscle and fat segmentations
+        (output of "mosamatic2-cli segmentmusclefatl3tensorflow")
+
+    --output : str
+        Path to output directory
+
+    --fig_width : int
+        Width of PNG image
+
+    --fig_height : int
+        Height of PNG image
+
+    --overwrite : bool
+        Overwrite contents output directory [true|false]
+    """
+    task = CreatePngsFromSegmentationsTask(
+        inputs={'segmentations': segmentations},
+        params={'fig_width': fig_width, 'fig_height': fig_height},
+        output=output,
+        overwrite=overwrite,
+    )
+    task.run()

mosamatic2/commands/rescaledicomimages.py

@@ -0,0 +1,54 @@
+import click
+
+from mosamatic2.core.tasks import RescaleDicomImagesTask
+
+
+@click.command(help='Rescale DICOM files to target size')
+@click.option(
+    '--images', 
+    required=True, 
+    type=click.Path(exists=True), 
+    help='Input directory with images'
+)
+@click.option(
+    '--output', 
+    required=True, 
+    type=click.Path(), 
+    help='Output directory'
+)
+@click.option(
+    '--target_size', 
+    default=512,
+    help='Target size of rescaled images (default: 512)'
+)
+@click.option(
+    '--overwrite', 
+    type=click.BOOL, 
+    default=False, 
+    help='Overwrite [true|false]'
+)
+def rescaledicomimages(images, output, target_size, overwrite):
+    """
+    Rescales DICOM images to given (square) target size
+
+    Parameters
+    ----------
+    --images : str
+        Directory with with input DICOM images
+
+    --output : str
+        Path to output directory
+
+    --target_size : int
+        Target size for rescaled images (default: 512)
+    
+    --overwrite : bool
+        Overwrite contents output directory: [true|false]
+    """
+    task = RescaleDicomImagesTask(
+        inputs={'images': images}, 
+        params={'target_size': target_size}, 
+        output=output, 
+        overwrite=overwrite
+    )
+    task.run()

mosamatic2/commands/segmentmusclefatl3tensorflow.py

@@ -0,0 +1,55 @@
+import click
+
+from mosamatic2.core.tasks import SegmentMuscleFatL3TensorFlowTask
+
+
+@click.command(help='Extracts muscle and fat regions from CT images at L3 (uses PyTorch)')
+@click.option(
+    '--images', 
+    required=True, 
+    type=click.Path(), 
+    help='Input directory with images'
+)
+@click.option(
+    '--model_files', 
+    required=True, 
+    type=click.Path(), 
+    help='Input directory with AI model files'
+)
+@click.option(
+    '--output', 
+    required=True, 
+    type=click.Path(), 
+    help='Output directory'
+)
+@click.option(
+    '--overwrite', 
+    default=False, 
+    type=click.BOOL, 
+    help='Overwrite [true|false]'
+)
+def segmentmusclefatl3tensorflow(images, model_files, output, overwrite):
+    """
+    Automatically segments muscle and fat tissue in CT images at L3 level.
+    
+    Parameters
+    ----------
+    --images : str
+        Directory with with input L3 images
+
+    --model_files : str
+        Directory with AI model files (model-1.0.zip, contour_model-1.0.zip, params-1.0.json)
+
+    --output : str
+        Path to output directory
+
+    --overwrite : bool
+        Overwrite contents output directory [true|false]
+    """
+    task = SegmentMuscleFatL3TensorFlowTask(
+        inputs={'images': images, 'model_files': model_files},
+        params={'model_version': 1.0},
+        output=output,
+        overwrite=overwrite,
+    )
+    task.run()

mosamatic2/constants.py

@@ -0,0 +1,27 @@
+MOSAMATIC2_BUNDLE_IDENTIFIER = 'org.mumc'
+MOSAMATIC2_APP_NAME = 'mosamatic2'
+MOSAMATIC2_VERSION_FILE = 'mosamatic2/ui/resources/VERSION'
+MOSAMATIC2_IMAGES_DIR_PATH = 'mosamatic2/ui/resources/images'
+MOSAMATIC2_ICONS_DIR_PATH = 'mosamatic2/ui/resources/icons'
+MOSAMATIC2_APP_ICON_FILE_NAME_WIN = 'mosamatic2.ico'
+MOSAMATIC2_APP_ICON_FILE_NAME_MAC = 'mosamatic2.icns'
+MOSAMATIC2_BACKGROUND_IMAGE_FILE_NAME = 'body-composition.jpg'
+MOSAMATIC2_BACKGROUND_IMAGE_OPACITY = 0.4
+
+MOSAMATIC2_SERVER_PORT = 8000
+MOSAMATIC2_SERVER_DEBUG = True
+
+MOSAMATIC2_WINDOW_TITLE = 'Mosamatic'
+MOSAMATIC2_WINDOW_W = 1000
+MOSAMATIC2_WINDOW_H = 600
+MOSAMATIC2_WINDOW_GEOMETRY_KEY = 'mainwindow/geometry'
+MOSAMATIC2_WINDOW_STATE_KEY = 'mainwindow/state'
+
+MOSAMATIC2_SPLASH_SCREEN_TITLE = MOSAMATIC2_WINDOW_TITLE
+MOSAMATIC2_SPLASH_SCREEN_TITLE_STYLESHEET = 'color: rgb(64, 64, 64); font-weight: bold; font-size: 32pt;'
+MOSAMATIC2_SPLASH_SCREEN_SUB_TEXT = 'This software is for research only'
+MOSAMATIC2_SPLASH_SCREEN_SUB_TEXT_STYLE_SHEET = 'color: rgb(64, 64, 64); font-style: italic; font-size: 10pt;'
+MOSAMATIC2_SPLASH_SCREEN_START_BUTTON_TEXT = 'Start Application'
+MOSAMATIC2_SPLASH_SCREEN_QUIT_BUTTON_TEXT = 'Quit'
+MOSAMATIC2_SPLASH_SCREEN_W = 600
+MOSAMATIC2_SPLASH_SCREEN_H = 300

mosamatic2/core/data/__init__.py

@@ -0,0 +1,5 @@
+from mosamatic2.core.data.filedata import FileData
+from mosamatic2.core.data.dicomimage import DicomImage
+from mosamatic2.core.data.dicomimageseries import DicomImageSeries
+from mosamatic2.core.data.multidicomimage import MultiDicomImage
+from mosamatic2.core.data.dixonseries import DixonSeries

mosamatic2/core/data/dicomimage.py

@@ -0,0 +1,18 @@
+from mosamatic2.core.data.filedata import FileData
+from mosamatic2.core.utils import (
+    is_dicom,
+    load_dicom,
+    is_jpeg2000_compressed,
+)
+
+
+class DicomImage(FileData):
+    def load(self):
+        if self.path():
+            if is_dicom(self.path()):
+                p = load_dicom(self.path())
+                if is_jpeg2000_compressed(p):
+                    p.decompress()
+                self.set_object(p)
+                return True
+        return False

mosamatic2/core/data/dicomimageseries.py

@@ -0,0 +1,26 @@
+import os
+from mosamatic2.core.data.filedata import FileData
+from mosamatic2.core.data.dicomimage import DicomImage
+
+
+class DicomImageSeries(FileData):
+    def __init__(self):
+        super(DicomImageSeries, self).__init__()
+        self._images = []
+
+    def images(self):
+        return self._images
+    
+    def load(self):
+        if self.path():
+            images = []
+            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():
+                    images.append(image)
+            # Sort DICOM objects by instance number
+            self._images = sorted(images, key=lambda image: int(image.object().get('InstanceNumber')))
+            return True
+        return False

mosamatic2/core/data/dixonseries.py

@@ -0,0 +1,22 @@
+from mosamatic2.core.data.filedata import FileData
+
+
+class DixonSeries(FileData):
+    def __init__(self):
+        super(DixonSeries, self).__init__()
+        self._series = {'ip': None, 'op': None, 'water': None, 'fat': None}
+
+    def ip(self):
+        return self._series['ip']
+    
+    def op(self):
+        return self._series['op']
+    
+    def water(self):
+        return self._series['water']
+    
+    def fat(self):
+        return self._series['fat']
+    
+    def load(self):
+        pass

mosamatic2/core/data/filedata.py

@@ -0,0 +1,26 @@
+import os
+
+
+class FileData:
+    def __init__(self):
+        self._path = None
+        self._name = None
+        self._object = None
+
+    def path(self):
+        return self._path
+    
+    def set_path(self, path):
+        self._path = path
+
+    def name(self):
+        return os.path.split(self.path())[1]
+    
+    def object(self):
+        return self._object
+    
+    def set_object(self, object):
+        self._object = object
+    
+    def load(self):
+        raise NotImplementedError()

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/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 @@
+from mosamatic2.core.pipelines.defaultpipeline import DefaultPipeline

mosamatic2/core/pipelines/defaultpipeline.py

@@ -0,0 +1,79 @@
+import os
+
+from mosamatic2.core.pipelines.pipeline import Pipeline
+from mosamatic2.core.tasks import (
+    RescaleDicomImagesTask, 
+    SegmentMuscleFatL3TensorFlowTask,
+    SegmentMuscleFatL3TensorFlowTask,
+    CreatePngsFromSegmentationsTask,
+    CalculateScoresTask,
+)
+
+
+class DefaultPipeline(Pipeline):
+    INPUTS = [
+        'images',
+        'model_files',
+    ]
+    PARAMS = [
+        'target_size',
+        'file_type',
+        'fig_width',
+        'fig_height',
+        'model_type',
+        'model_version',
+    ]
+    def __init__(self, inputs, params, output, overwrite):
+        super(DefaultPipeline, self).__init__(inputs, params, output, overwrite)
+        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={
+                    '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'),
+                },
+                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,4 @@
+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