mosamatic2 2.0.16__py3-none-any.whl → 2.0.17__py3-none-any.whl

mosamatic2/cli.py

@@ -1,6 +1,7 @@
 import click
 from mosamatic2.commands import (
     calculatescores,
+    calculatemaskstatistics,
     rescaledicomimages,
     segmentmusclefatl3tensorflow,
     createpngsfromsegmentations,
@@ -10,6 +11,8 @@ from mosamatic2.commands import (
     defaultpipeline,
     defaultdockerpipeline,
     boadockerpipeline,
+    liveranalysispipeline,
+    totalsegmentator,
 )
 from mosamatic2.core.utils import show_doc_command
 
@@ -32,6 +35,7 @@ def main():
 
 
 main.add_command(calculatescores.calculatescores)
+main.add_command(calculatemaskstatistics.calculatemaskstatistics)
 main.add_command(rescaledicomimages.rescaledicomimages)
 main.add_command(segmentmusclefatl3tensorflow.segmentmusclefatl3tensorflow)
 main.add_command(createpngsfromsegmentations.createpngsfromsegmentations)
@@ -41,4 +45,6 @@ main.add_command(createdicomsummary.createdicomsummary)
 main.add_command(defaultpipeline.defaultpipeline)
 main.add_command(defaultdockerpipeline.defaultdockerpipeline)
 main.add_command(boadockerpipeline.boadockerpipeline)
+main.add_command(liveranalysispipeline.liveranalysispipeline)
+main.add_command(totalsegmentator.totalsegmentator)
 main.add_command(show_doc_command(main)) # Special command to show long description for command

mosamatic2/commands/calculatemaskstatistics.py

@@ -0,0 +1,59 @@
+import click
+
+from mosamatic2.core.tasks import CalculateMaskStatisticsTask
+
+
+@click.command(help='Calculates segmentation mask statistics')
+@click.option(
+    '--scans', 
+    required=True, 
+    type=click.Path(exists=True), 
+    help='Directory with scans in NIFTI format',
+)
+@click.option(
+    '--masks',
+    required=True,
+    type=click.Path(exists=True), 
+    help='Directory with segmentation mask files in NIFTI format',
+)
+@click.option(
+    '--output', 
+    required=True, 
+    type=click.Path(), 
+    help='Output directory'
+)
+@click.option(
+    '--overwrite', 
+    type=click.BOOL, 
+    default=False, 
+    help='Overwrite [true|false]'
+)
+def calculatemaskstatistics(scans, masks, output, overwrite):
+    """
+    Calculates segmentation mask statistics. The following metrics are calculated:
+
+    (1) Mean radiation attenuation (HU)
+    (2) Standard deviation radiation attenuation (HU)
+    (3) Segmentation mask volume (mL)
+    
+    Parameters
+    ----------
+    --scans : str
+        Directory with scans in NIFTI format
+
+    --masks : str
+        Directory with segmentation mask files in NIFTI format
+
+    --output : str
+        Path to output directory
+
+    --overwrite : bool
+        Overwrite contents output directory [true|false]
+    """
+    task = CalculateMaskStatisticsTask(
+        inputs={'scans': scans, 'masks': masks},
+        params=None,
+        output=output,
+        overwrite=overwrite,
+    )
+    task.run()

mosamatic2/commands/defaultdockerpipeline.py

@@ -16,6 +16,11 @@ from mosamatic2.core.pipelines import DefaultDockerPipeline
     type=click.Path(), 
     help='Input directory with AI model files (no spaces allowed)'
 )
+@click.option(
+    '--version', 
+    required=True, 
+    help='Docker image version'
+)
 @click.option(
     '--output', 
     required=True, 
@@ -28,7 +33,7 @@ from mosamatic2.core.pipelines import DefaultDockerPipeline
     default=False, 
     help='Overwrite [true|false]'
 )
-def defaultdockerpipeline(images, model_files, output, overwrite):
+def defaultdockerpipeline(images, model_files, version, output, overwrite):
     """
     Runs default L3 analysis pipeline through Docker
     
@@ -51,6 +56,11 @@ def defaultdockerpipeline(images, model_files, output, overwrite):
 
         Warning: This directory path cannot contain any spaces!
 
+    --version : str
+        Docker image version, e.g., 2.0.16
+        Check https://hub.docker.com/repository/docker/brecheisen/mosamatic2-cli/general
+        for the latest version and older versions.
+
     --output : str
         Path to output directory (no spaces!)
 
@@ -66,6 +76,7 @@ def defaultdockerpipeline(images, model_files, output, overwrite):
             'file_type': 'npy',
             'fig_width': 10,
             'fig_height': 10,
+            'version': version,
         },
         output=output,
         overwrite=overwrite,

mosamatic2/commands/liveranalysispipeline.py

@@ -0,0 +1,61 @@
+import click
+
+from mosamatic2.core.pipelines import LiverAnalysisPipeline
+
+
+@click.command(help='Runs liver analysis pipeline')
+@click.option(
+    '--scans', 
+    required=True, 
+    type=click.Path(exists=True), 
+    help='Root directory with scan directories for each patient (no spaces allowed)',
+)
+@click.option(
+    '--compressed', 
+    default=True,
+    help='Whether to produce compressed NIFTI file or not (default: True)'
+)
+@click.option(
+    '--output', 
+    required=True, 
+    type=click.Path(), 
+    help='Output directory (no spaces allowed)'
+)
+@click.option(
+    '--overwrite', 
+    type=click.BOOL, 
+    default=False, 
+    help='Overwrite [true|false]'
+)
+def liveranalysispipeline(scans, compressed, output, overwrite):
+    """
+    Runs liver analysis pipeline. This pipeline run the following steps on each scan: 
+
+    (1) DICOM to NIFTI conversion
+    (2) Extract liver segments using Total Segmentator
+    (3) Calculate segment statistics, e.g., volume (mL), mean HU, std HU and PNG image
+        of each segments HU histogram.
+    
+    Parameters
+    ----------
+    --scans : str
+        Root directory with scan directories for each patient. Each scan directory should 
+        contain DICOM images for a single scan only and nothing else. Also, the directory
+        paths cannot contain any spaces.
+
+    --compressed : str
+        Whether to produce compressed NIFTI file or not (default: True)
+
+    --output : str
+        Path to output directory. No spaces allowed.
+
+    --overwrite : bool
+        Overwrite contents output directory [true|false]
+    """
+    pipeline = LiverAnalysisPipeline(
+        inputs={'scans': scans},
+        params={'compressed': compressed},
+        output=output,
+        overwrite=overwrite,
+    )
+    pipeline.run()

mosamatic2/commands/totalsegmentator.py

@@ -21,13 +21,18 @@ from mosamatic2.core.tasks import TotalSegmentatorTask
     default='total',
     help='Comma-separated list of Total Segmentator tasks to run (no spaces!)'
 )
+@click.option(
+    '--format',
+    default='dicom',
+    help='Process scans in DICOM or NIFTI format [dicom|nifti] (default: dicom)'
+)
 @click.option(
     '--overwrite', 
     type=click.BOOL, 
     default=False, 
     help='Overwrite [true|false]'
 )
-def totalsegmentator(scans, tasks, output, overwrite):
+def totalsegmentator(scans, tasks, format, output, overwrite):
     """
     Run Total Segmentator on CT scans. If you want to run specialized tasks
     like "liver_segments" or "liver_vessels" you need an educational license.
@@ -56,12 +61,16 @@ def totalsegmentator(scans, tasks, output, overwrite):
     --tasks : str
         Comma-separated list of Total Segmentator tasks to run (no spaces!)
 
+    --format : str
+        Process scans in DICOM or NIFTI format. Options: [dicom|nifti]
+        Default is 'dicom'.
+
     --overwrite : bool
         Overwrite contents output directory [true|false]
     """
     task = TotalSegmentatorTask(
         inputs={'scans': scans},
-        params={'tasks': tasks},
+        params={'tasks': tasks, 'format': format},
         output=output,
         overwrite=overwrite,
     )

mosamatic2/core/pipelines/__init__.py

@@ -1,3 +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.boadockerpipeline.boadockerpipeline import BoaDockerPipeline
+from mosamatic2.core.pipelines.liveranalysispipeline.liveranalysispipeline import LiverAnalysisPipeline

mosamatic2/core/pipelines/defaultdockerpipeline/defaultdockerpipeline.py

@@ -11,15 +11,8 @@ class DefaultDockerPipeline(Pipeline):
         'images',
         'model_files',
     ]
-    PARAMS = [
-        'target_size',
-        'file_type',
-        'fig_width',
-        'fig_height',
-        'model_type',
-        'model_version',
-        'version',
-    ]
+    PARAMS = ['version']
+    
     def __init__(self, inputs, params, output, overwrite):
         super(DefaultDockerPipeline, self).__init__(inputs, params, output, 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/tasks/__init__.py

@@ -5,4 +5,5 @@ from mosamatic2.core.tasks.createpngsfromsegmentationstask.createpngsfromsegment
 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.totalsegmentatortask.totalsegmentatortask import TotalSegmentatorTask
+from mosamatic2.core.tasks.calculatemaskstatisticstask.calculatemaskstatisticstask import CalculateMaskStatisticsTask

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'):
+                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/totalsegmentatortask/totalsegmentatortask.py

@@ -11,7 +11,7 @@ TOTAL_SEGMENTATOR_OUTPUT_DIR = os.path.join(tempfile.gettempdir(), 'total_segmen
 
 class TotalSegmentatorTask(Task):
     INPUTS = ['scans']
-    PARAMS = ['tasks']
+    PARAMS = ['tasks', 'format']
 
     def __init__(self, inputs, params, output, overwrite):
         super(TotalSegmentatorTask, self).__init__(inputs, params, output, overwrite)
@@ -25,26 +25,51 @@ class TotalSegmentatorTask(Task):
                 scan_dirs.append(scan_dir)
         return scan_dirs
     
-    def extract_masks(self, scan_dir):
+    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 extract_masks(self, scan_dir_or_file):
         os.makedirs(TOTAL_SEGMENTATOR_OUTPUT_DIR, exist_ok=True)
         tasks = self.param('tasks').split(",") if self.param('tasks') else []
         for task in tasks:
             LOG.info(f'Running task {task}...')
-            totalsegmentator(input=scan_dir, output=TOTAL_SEGMENTATOR_OUTPUT_DIR, task=task)
+            totalsegmentator(input=scan_dir_or_file, output=TOTAL_SEGMENTATOR_OUTPUT_DIR, task=task)
+
+    def delete_total_segmentator_output(self):
+        if os.path.exists(TOTAL_SEGMENTATOR_OUTPUT_DIR):
+            shutil.rmtree(TOTAL_SEGMENTATOR_OUTPUT_DIR)
 
     def run(self):
-        scan_dirs = self.load_scan_dirs()
-        nr_steps = len(scan_dirs)
+        if self.param('format') == 'dicom':
+            scan_dirs_or_files = self.load_scan_dirs()
+        elif self.param('format') == 'nifti':
+            scan_dirs_or_files = self.load_scans()
+        else:
+            LOG.error('Unknown format: {}'.format(self.param('format')))
+            return
+        nr_steps = len(scan_dirs_or_files)
         for step in range(nr_steps):
-            scan_dir = scan_dirs[step]
+            scan_dir_or_file = scan_dirs_or_files[step]
+            scan_dir_or_file_name = os.path.split(scan_dir_or_file)[1]
+            if self.param('format') == 'nifti':
+                scan_dir_or_file_name = scan_dir_or_file_name[:-7]
             try:
-                self.extract_masks(scan_dir)
+                self.extract_masks(scan_dir_or_file)
             except Exception as e:
-                LOG.error(f'{scan_dir}: Could not extract masks [{str(e)}]. Skipping scan...')
+                LOG.error(f'{scan_dir_or_file}: Could not extract masks [{str(e)}]. Skipping scan...')
             self.set_progress(step, nr_steps)
             LOG.info(f'Copying temporary output to final output directory...')
             for f in os.listdir(TOTAL_SEGMENTATOR_OUTPUT_DIR):
                 if f.endswith('.nii') or f.endswith('.nii.gz'):
                     f_path = os.path.join(TOTAL_SEGMENTATOR_OUTPUT_DIR, f)
-                    shutil.move(f_path, self.output())
-                    LOG.info(f'Copied {f}')
+                    target_file = os.path.join(self.output(), f'{scan_dir_or_file_name}_{f}')
+                    shutil.copyfile(f_path, target_file)
+                    LOG.info(f'Copied {f} to {target_file}')
+            LOG.info('Cleaning up Total Segmentator temporary output...')
+            self.delete_total_segmentator_output()

mosamatic2/ui/mainwindow.py

@@ -22,9 +22,11 @@ from mosamatic2.ui.widgets.panels.tasks.dicom2niftitaskpanel import Dicom2NiftiT
 from mosamatic2.ui.widgets.panels.tasks.createdicomsummarytaskpanel import CreateDicomSummaryTaskPanel
 from mosamatic2.ui.widgets.panels.tasks.selectslicefromscanstaskpanel import SelectSliceFromScansTaskPanel
 from mosamatic2.ui.widgets.panels.tasks.totalsegmentatortaskpanel import TotalSegmentatorTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.calculatemaskstatisticstaskpanel import CalculateMaskStatisticsTaskPanel
 from mosamatic2.ui.widgets.panels.pipelines.defaultpipelinepanel import DefaultPipelinePanel
 from mosamatic2.ui.widgets.panels.pipelines.defaultdockerpipelinepanel import DefaultDockerPipelinePanel
 from mosamatic2.ui.widgets.panels.pipelines.boadockerpipelinepanel import BoaDockerPipelinePanel
+from mosamatic2.ui.widgets.panels.pipelines.liveranalysispipelinepanel import LiverAnalysisPipelinePanel
 from mosamatic2.ui.widgets.panels.visualizations.slicevisualization.slicevisualization import SliceVisualization
 
 LOG = LogManager()
@@ -45,9 +47,11 @@ class MainWindow(QMainWindow):
         self._create_dicom_summary_task_panel = None
         self._select_slice_from_scans_task_panel = None
         self._total_segmentator_task_panel = None
+        self._calculate_mask_statistics_task_panel = None
         self._default_pipeline_panel = None
         self._default_docker_pipeline_panel = None
         self._boa_docker_pipeline_panel = None
+        self._liver_analysis_pipeline_panel = None
         self._slice_visualization = None
         self.init_window()
 
@@ -94,6 +98,8 @@ class MainWindow(QMainWindow):
         select_slice_from_scans_task_action.triggered.connect(self.handle_select_slice_from_scans_task_action)
         total_segmentator_task_action = QAction('TotalSegmentatorTask', self)
         total_segmentator_task_action.triggered.connect(self.handle_total_segmentator_task_action)
+        calculate_mask_statistics_task_action = QAction('CalculateMaskStatisticsTask', self)
+        calculate_mask_statistics_task_action.triggered.connect(self.handle_calculate_mask_statistics_task_action)
         tasks_menu = self.menuBar().addMenu('Tasks')
         tasks_menu.addAction(rescale_dicom_images_task_action)
         tasks_menu.addAction(segment_muscle_fat_l3_tensorflow_task_action)
@@ -103,6 +109,7 @@ class MainWindow(QMainWindow):
         tasks_menu.addAction(create_dicom_summary_task_action)
         tasks_menu.addAction(select_slice_from_scans_task_action)
         tasks_menu.addAction(total_segmentator_task_action)
+        tasks_menu.addAction(calculate_mask_statistics_task_action)
 
     def init_pipelines_menu(self):
         default_pipeline_action = QAction('DefaultPipeline', self)
@@ -111,10 +118,13 @@ class MainWindow(QMainWindow):
         default_docker_pipeline_action.triggered.connect(self.handle_default_docker_pipeline_action)
         boa_docker_pipeline_action = QAction('BoaDockerPipeline', self)
         boa_docker_pipeline_action.triggered.connect(self.handle_boa_docker_pipeline_action)
+        liver_analysis_pipeline_action = QAction('LiverAnalysisPipeline', self)
+        liver_analysis_pipeline_action.triggered.connect(self.handle_liver_analysis_pipeline_action)
         pipelines_menu = self.menuBar().addMenu('Pipelines')
         pipelines_menu.addAction(default_pipeline_action)
         pipelines_menu.addAction(default_docker_pipeline_action)
         pipelines_menu.addAction(boa_docker_pipeline_action)
+        pipelines_menu.addAction(liver_analysis_pipeline_action)
 
     def init_visualizations_menu(self):
         slice_visualization_action = QAction('SliceVisualization', self)
@@ -143,9 +153,11 @@ class MainWindow(QMainWindow):
             self._main_panel.add_panel(self.create_dicom_summary_task_panel(), 'createdicomsummarytaskpanel')
             self._main_panel.add_panel(self.select_slice_from_scans_task_panel(), 'selectslicefromscanstaskpanel')
             self._main_panel.add_panel(self.total_segmentator_task_panel(), 'totalsegmentatortaskpanel')
+            self._main_panel.add_panel(self.calculate_mask_statistics_task_panel(), 'calculatemaskstatisticstaskpanel')
             self._main_panel.add_panel(self.default_pipeline_panel(), 'defaultpipelinepanel')
             self._main_panel.add_panel(self.default_docker_pipeline_panel(), 'defaultdockerpipelinepanel')
             self._main_panel.add_panel(self.boa_docker_pipeline_panel(), 'boadockerpipelinepanel')
+            self._main_panel.add_panel(self.liver_analysis_pipeline_panel(), 'liveranalysispipelinepanel')
             self._main_panel.add_panel(self.slice_visualization(), 'slicevisualization')
             self._main_panel.select_panel('defaultpipelinepanel')
         return self._main_panel
@@ -198,6 +210,11 @@ class MainWindow(QMainWindow):
             self._total_segmentator_task_panel = TotalSegmentatorTaskPanel()
         return self._total_segmentator_task_panel
     
+    def calculate_mask_statistics_task_panel(self):
+        if not self._calculate_mask_statistics_task_panel:
+            self._calculate_mask_statistics_task_panel = CalculateMaskStatisticsTaskPanel()
+        return self._calculate_mask_statistics_task_panel
+    
     def default_pipeline_panel(self):
         if not self._default_pipeline_panel:
             self._default_pipeline_panel = DefaultPipelinePanel()
@@ -213,6 +230,11 @@ class MainWindow(QMainWindow):
             self._boa_docker_pipeline_panel = BoaDockerPipelinePanel()
         return self._boa_docker_pipeline_panel
     
+    def liver_analysis_pipeline_panel(self):
+        if not self._liver_analysis_pipeline_panel:
+            self._liver_analysis_pipeline_panel = LiverAnalysisPipelinePanel()
+        return self._liver_analysis_pipeline_panel
+    
     def slice_visualization(self):
         if not self._slice_visualization:
             self._slice_visualization = SliceVisualization()
@@ -249,6 +271,9 @@ class MainWindow(QMainWindow):
     def handle_total_segmentator_task_action(self):
         self.main_panel().select_panel('totalsegmentatortaskpanel')
 
+    def handle_calculate_mask_statistics_task_action(self):
+        self.main_panel().select_panel('calculatemaskstatisticstaskpanel')
+
     def handle_default_pipeline_action(self):
         self.main_panel().select_panel('defaultpipelinepanel')
 
@@ -258,6 +283,9 @@ class MainWindow(QMainWindow):
     def handle_boa_docker_pipeline_action(self):
         self.main_panel().select_panel('boadockerpipelinepanel')
 
+    def handle_liver_analysis_pipeline_action(self):
+        self.main_panel().select_panel('liveranalysispipelinepanel')
+
     def handle_slice_visualization_action(self):
         self.main_panel().select_panel('slicevisualization')
 
@@ -275,9 +303,11 @@ class MainWindow(QMainWindow):
         self.create_dicom_summary_task_panel().save_inputs_and_parameters()
         self.select_slice_from_scans_task_panel().save_inputs_and_parameters()
         self.total_segmentator_task_panel().save_inputs_and_parameters()
+        self.calculate_mask_statistics_task_panel().save_inputs_and_parameters()
         self.default_pipeline_panel().save_inputs_and_parameters()
         self.default_docker_pipeline_panel().save_inputs_and_parameters()
         self.boa_docker_pipeline_panel().save_inputs_and_parameters()
+        self.liver_analysis_pipeline_panel().save_inputs_and_parameters()
         self.slice_visualization().save_inputs_and_parameters()
         return super().closeEvent(event)
 

mosamatic2/ui/resources/VERSION

@@ -1 +1 @@
-2.0.16 
+2.0.17 

mosamatic2/ui/widgets/panels/pipelines/defaultpipelinepanel.py

@@ -27,7 +27,7 @@ from mosamatic2.core.pipelines import DefaultPipeline
 LOG = LogManager()
 
 PANEL_TITLE = 'DefaultPipeline'
-PANEL_NAME = 'defaultpipeline'
+PANEL_NAME = 'defaultpipelinepanel'
 MODEL_TYPE_ITEM_NAMES = ['tensorflow', 'pytorch']
 MODEL_VERSION_ITEM_NAMES = ['1.0', '2.2']
 

mosamatic2/ui/widgets/panels/pipelines/liveranalysispipelinepanel.py

@@ -0,0 +1,187 @@
+import os
+
+from PySide6.QtWidgets import (
+    QLineEdit,
+    QSpinBox,
+    QComboBox,
+    QCheckBox,
+    QHBoxLayout,
+    QVBoxLayout,
+    QFormLayout,
+    QPushButton,
+    QFileDialog,
+    QMessageBox,
+)
+from PySide6.QtCore import (
+    QThread, 
+    Slot,
+)
+
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.ui.widgets.panels.pipelines.pipelinepanel import PipelinePanel
+from mosamatic2.ui.settings import Settings
+from mosamatic2.ui.utils import is_macos
+from mosamatic2.ui.worker import Worker
+from mosamatic2.core.pipelines import LiverAnalysisPipeline
+
+LOG = LogManager()
+
+PANEL_TITLE = 'LiverAnalysisPipeline'
+PANEL_NAME = 'liveranalysispipelinepanel'
+
+
+class LiverAnalysisPipelinePanel(PipelinePanel):
+    def __init__(self):
+        super(LiverAnalysisPipelinePanel, self).__init__()
+        self.set_title(PANEL_TITLE)
+        self._scans_dir_line_edit = None
+        self._scans_dir_select_button = None
+        self._output_dir_line_edit = None
+        self._output_dir_select_button = None
+        self._overwrite_checkbox = None
+        self._form_layout = None
+        self._run_pipeline_button = None
+        self._settings = None
+        self._task = None
+        self._worker = None
+        self._thread = None
+        self.init_layout()
+
+    def scans_dir_line_edit(self):
+        if not self._scans_dir_line_edit:
+            self._scans_dir_line_edit = QLineEdit()
+            self._scans_dir_line_edit.setText(self.settings().get(f'{PANEL_NAME}/scans_dir'))
+        return self._scans_dir_line_edit
+    
+    def scans_dir_select_button(self):
+        if not self._scans_dir_select_button:
+            self._scans_dir_select_button = QPushButton('Select')
+            self._scans_dir_select_button.clicked.connect(self.handle_scans_dir_select_button)
+        return self._scans_dir_select_button
+    
+    def output_dir_line_edit(self):
+        if not self._output_dir_line_edit:
+            self._output_dir_line_edit = QLineEdit()
+            self._output_dir_line_edit.setText(self.settings().get(f'{PANEL_NAME}/output_dir'))
+        return self._output_dir_line_edit
+    
+    def output_dir_select_button(self):
+        if not self._output_dir_select_button:
+            self._output_dir_select_button = QPushButton('Select')
+            self._output_dir_select_button.clicked.connect(self.handle_output_dir_select_button)
+        return self._output_dir_select_button
+
+    def overwrite_checkbox(self):
+        if not self._overwrite_checkbox:
+            self._overwrite_checkbox = QCheckBox('')
+            self._overwrite_checkbox.setChecked(self.settings().get_bool(f'{PANEL_NAME}/overwrite', True))
+        return self._overwrite_checkbox
+    
+    def form_layout(self):
+        if not self._form_layout:
+            self._form_layout = QFormLayout()
+            if is_macos():
+                self._form_layout.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow)
+        return self._form_layout
+    
+    def run_pipeline_button(self):
+        if not self._run_pipeline_button:
+            self._run_pipeline_button = QPushButton('Run pipeline')
+            self._run_pipeline_button.clicked.connect(self.handle_run_pipeline_button)
+        return self._run_pipeline_button
+    
+    def settings(self):
+        if not self._settings:
+            self._settings = Settings()
+        return self._settings
+    
+    def init_help_dialog(self):
+        self.help_dialog().set_text('Show some help information')
+    
+    def init_layout(self):
+        scans_dir_layout = QHBoxLayout()
+        scans_dir_layout.addWidget(self.scans_dir_line_edit())
+        scans_dir_layout.addWidget(self.scans_dir_select_button())
+        output_dir_layout = QHBoxLayout()
+        output_dir_layout.addWidget(self.output_dir_line_edit())
+        output_dir_layout.addWidget(self.output_dir_select_button())
+        self.form_layout().addRow('Scans directory', scans_dir_layout)
+        self.form_layout().addRow('Output directory', output_dir_layout)
+        self.form_layout().addRow('Overwrite', self.overwrite_checkbox())
+        layout = QVBoxLayout()
+        layout.addLayout(self.form_layout())
+        layout.addWidget(self.run_pipeline_button())
+        self.setLayout(layout)
+        self.setObjectName(PANEL_NAME)
+
+    def handle_scans_dir_select_button(self):
+        last_directory = self.settings().get('last_directory')
+        directory = QFileDialog.getExistingDirectory(dir=last_directory)
+        if directory:
+            self.scans_dir_line_edit().setText(directory)
+            self.settings().set('last_directory', directory)
+
+    def handle_output_dir_select_button(self):
+        last_directory = self.settings().get('last_directory')
+        directory = QFileDialog.getExistingDirectory(dir=last_directory)
+        if directory:
+            self.output_dir_line_edit().setText(directory)
+            self.settings().set('last_directory', directory)
+
+    def handle_run_pipeline_button(self):
+        errors = self.check_inputs_and_parameters()
+        if len(errors) > 0:
+            error_message = 'Following errors were encountered:\n'
+            for error in errors:
+                error_message += f' - {error}\n'
+            QMessageBox.information(self, 'Error', error_message)
+        else:
+            LOG.info('Running pipeline...')
+            self.run_pipeline_button().setEnabled(False)
+            self.save_inputs_and_parameters()
+            self._task = LiverAnalysisPipeline(
+                inputs={'scans': self.scans_dir_line_edit().text()},
+                params={'compressed': True},
+                output=self.output_dir_line_edit().text(),
+                overwrite=self.overwrite_checkbox().isChecked(),
+            )
+            self._worker = Worker(self._task)
+            self._thread = QThread()
+            self._worker.moveToThread(self._thread)
+            self._thread.started.connect(self._worker.run)
+            self._worker.progress.connect(self.handle_progress)
+            self._worker.status.connect(self.handle_status)
+            self._worker.finished.connect(self.handle_finished)
+            self._worker.finished.connect(self._thread.quit)
+            self._worker.finished.connect(self._worker.deleteLater)
+            self._thread.finished.connect(self._thread.deleteLater)
+            self._thread.start()
+
+    @Slot(int)
+    def handle_progress(self, progress):
+        LOG.info(f'Progress: {progress} / 100%')
+
+    @Slot(str)
+    def handle_status(self, status):
+        LOG.info(f'Status: {status}')
+
+    @Slot()
+    def handle_finished(self):
+        self.run_pipeline_button().setEnabled(True)
+
+    def check_inputs_and_parameters(self):
+        errors = []
+        if self.scans_dir_line_edit().text() == '':
+            errors.append('Empty scans directory path')
+        elif not os.path.isdir(self.scans_dir_line_edit().text()):
+            errors.append('Scans directory does not exist')
+        if self.output_dir_line_edit().text() == '':
+            errors.append('Empty output directory path')
+        elif os.path.isdir(self.output_dir_line_edit().text()) and not self.overwrite_checkbox().isChecked():
+            errors.append('Output directory exists but overwrite=False. Please remove output directory first')
+        return errors
+    
+    def save_inputs_and_parameters(self):
+        self.settings().set(f'{PANEL_NAME}/scans_dir', self.scans_dir_line_edit().text())
+        self.settings().set(f'{PANEL_NAME}/output_dir', self.output_dir_line_edit().text())
+        self.settings().set(f'{PANEL_NAME}/overwrite', self.overwrite_checkbox().isChecked())

mosamatic2/ui/widgets/panels/tasks/calculatemaskstatisticstaskpanel.py

@@ -0,0 +1,215 @@
+import os
+
+from PySide6.QtWidgets import (
+    QLineEdit,
+    QCheckBox,
+    QSpinBox,
+    QHBoxLayout,
+    QVBoxLayout,
+    QFormLayout,
+    QPushButton,
+    QFileDialog,
+    QMessageBox,
+)
+from PySide6.QtCore import (
+    QThread, 
+    Slot,
+)
+
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.ui.widgets.panels.tasks.taskpanel import TaskPanel
+from mosamatic2.ui.settings import Settings
+from mosamatic2.ui.utils import is_macos
+from mosamatic2.ui.worker import Worker
+from mosamatic2.core.tasks import CalculateMaskStatisticsTask
+
+LOG = LogManager()
+
+PANEL_TITLE = 'CalculateMaskStatisticsTask'
+PANEL_NAME = 'calculatemaskstatisticstaskpanel'
+
+
+class CalculateMaskStatisticsTaskPanel(TaskPanel):
+    def __init__(self):
+        super(CalculateMaskStatisticsTaskPanel, self).__init__()
+        self.set_title(PANEL_TITLE)
+        self._scans_dir_line_edit = None
+        self._scans_dir_select_button = None
+        self._masks_dir_line_edit = None
+        self._masks_dir_select_button = None
+        self._output_dir_line_edit = None
+        self._output_dir_select_button = None
+        self._overwrite_checkbox = None
+        self._form_layout = None
+        self._run_task_button = None
+        self._settings = None
+        self._task = None
+        self._worker = None
+        self._thread = None
+        self.init_layout()
+
+    def scans_dir_line_edit(self):
+        if not self._scans_dir_line_edit:
+            self._scans_dir_line_edit = QLineEdit(self.settings().get(f'{PANEL_NAME}/scans_dir'))
+        return self._scans_dir_line_edit
+    
+    def scans_dir_select_button(self):
+        if not self._scans_dir_select_button:
+            self._scans_dir_select_button = QPushButton('Select')
+            self._scans_dir_select_button.clicked.connect(self.handle_scans_dir_select_button)
+        return self._scans_dir_select_button
+    
+    def masks_dir_line_edit(self):
+        if not self._masks_dir_line_edit:
+            self._masks_dir_line_edit = QLineEdit(self.settings().get(f'{PANEL_NAME}/masks_dir'))
+        return self._masks_dir_line_edit
+    
+    def masks_dir_select_button(self):
+        if not self._masks_dir_select_button:
+            self._masks_dir_select_button = QPushButton('Select')
+            self._masks_dir_select_button.clicked.connect(self.handle_masks_dir_select_button)
+        return self._masks_dir_select_button
+    
+    def output_dir_line_edit(self):
+        if not self._output_dir_line_edit:
+            self._output_dir_line_edit = QLineEdit(self.settings().get(f'{PANEL_NAME}/output_dir'))
+        return self._output_dir_line_edit
+    
+    def output_dir_select_button(self):
+        if not self._output_dir_select_button:
+            self._output_dir_select_button = QPushButton('Select')
+            self._output_dir_select_button.clicked.connect(self.handle_output_dir_select_button)
+        return self._output_dir_select_button
+    
+    def overwrite_checkbox(self):
+        if not self._overwrite_checkbox:
+            self._overwrite_checkbox = QCheckBox('')
+            self._overwrite_checkbox.setChecked(self.settings().get_bool(f'{PANEL_NAME}/overwrite', True))
+        return self._overwrite_checkbox
+    
+    def form_layout(self):
+        if not self._form_layout:
+            self._form_layout = QFormLayout()
+            if is_macos():
+                self._form_layout.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow)
+        return self._form_layout
+    
+    def run_task_button(self):
+        if not self._run_task_button:
+            self._run_task_button = QPushButton('Run task')
+            self._run_task_button.clicked.connect(self.handle_run_task_button)
+        return self._run_task_button
+    
+    def settings(self):
+        if not self._settings:
+            self._settings = Settings()
+        return self._settings
+    
+    def init_layout(self):
+        scans_dir_layout = QHBoxLayout()
+        scans_dir_layout.addWidget(self.scans_dir_line_edit())
+        scans_dir_layout.addWidget(self.scans_dir_select_button())
+        masks_dir_layout = QHBoxLayout()
+        masks_dir_layout.addWidget(self.masks_dir_line_edit())
+        masks_dir_layout.addWidget(self.masks_dir_select_button())
+        output_dir_layout = QHBoxLayout()
+        output_dir_layout.addWidget(self.output_dir_line_edit())
+        output_dir_layout.addWidget(self.output_dir_select_button())
+        self.form_layout().addRow('Scans directory', scans_dir_layout)
+        self.form_layout().addRow('Masks directory', masks_dir_layout)
+        self.form_layout().addRow('Output directory', output_dir_layout)
+        self.form_layout().addRow('Overwrite', self.overwrite_checkbox())
+        layout = QVBoxLayout()
+        layout.addLayout(self.form_layout())
+        layout.addWidget(self.run_task_button())
+        self.setLayout(layout)
+        self.setObjectName(PANEL_NAME)
+
+    def handle_scans_dir_select_button(self):
+        last_directory = self.settings().get('last_directory')
+        directory = QFileDialog.getExistingDirectory(dir=last_directory)
+        if directory:
+            self.scans_dir_line_edit().setText(directory)
+            self.settings().set('last_directory', directory)
+
+    def handle_masks_dir_select_button(self):
+        last_directory = self.settings().get('last_directory')
+        directory = QFileDialog.getExistingDirectory(dir=last_directory)
+        if directory:
+            self.masks_dir_line_edit().setText(directory)
+            self.settings().set('last_directory', directory)
+
+    def handle_output_dir_select_button(self):
+        last_directory = self.settings().get('last_directory')
+        directory = QFileDialog.getExistingDirectory(dir=last_directory)
+        if directory:
+            self.output_dir_line_edit().setText(directory)
+            self.settings().set('last_directory', directory)
+
+    def handle_run_task_button(self):
+        errors = self.check_inputs_and_parameters()
+        if len(errors) > 0:
+            error_message = 'Following errors were encountered:\n'
+            for error in errors:
+                error_message += f' - {error}\n'
+            QMessageBox.information(self, 'Error', error_message)
+        else:
+            LOG.info('Running task...')
+            self.run_task_button().setEnabled(False)
+            self.save_inputs_and_parameters()
+            self._task = CalculateMaskStatisticsTask(
+                inputs={
+                    'scans': self.scans_dir_line_edit().text(),
+                    'masks': self.masks_dir_line_edit().text(),
+                },
+                params=None,
+                output=self.output_dir_line_edit().text(),
+                overwrite=self.overwrite_checkbox().isChecked(),
+            )
+            self._worker = Worker(self._task)
+            self._thread = QThread()
+            self._worker.moveToThread(self._thread)
+            self._thread.started.connect(self._worker.run)
+            self._worker.progress.connect(self.handle_progress)
+            self._worker.status.connect(self.handle_status)
+            self._worker.finished.connect(self.handle_finished)
+            self._worker.finished.connect(self._thread.quit)
+            self._worker.finished.connect(self._worker.deleteLater)
+            self._thread.finished.connect(self._thread.deleteLater)
+            self._thread.start()
+
+    @Slot(int)
+    def handle_progress(self, progress):
+        LOG.info(f'Progress: {progress} / 100%')
+
+    @Slot(str)
+    def handle_status(self, status):
+        LOG.info(f'Status: {status}')
+
+    @Slot()
+    def handle_finished(self):
+        self.run_task_button().setEnabled(True)
+
+    # HELPERS
+
+    def check_inputs_and_parameters(self):
+        errors = []
+        if self.scans_dir_line_edit().text() == '':
+            errors.append('Empty scans directory path')
+        if not os.path.isdir(self.scans_dir_line_edit().text()):
+            errors.append('Scans directory does not exist')
+        if self.masks_dir_line_edit().text() == '':
+            errors.append('Empty masks directory path')
+        if not os.path.isdir(self.masks_dir_line_edit().text()):
+            errors.append('Masks directory does not exist')
+        if self.output_dir_line_edit().text() == '':
+            errors.append('Empty output directory path')
+        if os.path.isdir(self.output_dir_line_edit().text()) and not self.overwrite_checkbox().isChecked():
+            errors.append('Output directory exists but overwrite=False. Please remove output directory first')
+        return errors
+    
+    def save_inputs_and_parameters(self):
+        self.settings().set(f'{PANEL_NAME}/scans_dir', self.scans_dir_line_edit().text())
+        self.settings().set(f'{PANEL_NAME}/masks_dir', self.masks_dir_line_edit().text())
+        self.settings().set(f'{PANEL_NAME}/output_dir', self.output_dir_line_edit().text())
+        self.settings().set(f'{PANEL_NAME}/overwrite', self.overwrite_checkbox().isChecked())

{mosamatic2-2.0.16.dist-info → mosamatic2-2.0.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mosamatic2
-Version: 2.0.16
+Version: 2.0.17
 Summary: 
 Author: Ralph Brecheisen
 Author-email: r.brecheisen@maastrichtuniversity.nl
@@ -9,9 +9,9 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: antspyx (>=0.5.4)
 Requires-Dist: dicom2nifti (>=2.6.2)
-Requires-Dist: docker
+Requires-Dist: docker (>=7.1.0)
 Requires-Dist: flask (>=3.1.2)
-Requires-Dist: moosez
+Requires-Dist: moosez (>=3.0.29)
 Requires-Dist: nibabel (>=5.3.2)
 Requires-Dist: numpy (>=1.26.4)
 Requires-Dist: openpyxl (>=3.1.5)
@@ -23,7 +23,7 @@ Requires-Dist: pyqtgraph (>=0.13.7)
 Requires-Dist: pyside6-essentials (>=6.9)
 Requires-Dist: python-gdcm (>=3.0.26)
 Requires-Dist: scipy (>=1.15.3)
-Requires-Dist: slicer
+Requires-Dist: slicer (>=0.0.8)
 Requires-Dist: tensorboard (==2.15.2)
 Requires-Dist: tensorboard-data-server (==0.7.2)
 Requires-Dist: tensorflow (==2.15.*) ; platform_system == "Linux"

{mosamatic2-2.0.16.dist-info → mosamatic2-2.0.17.dist-info}/RECORD

@@ -1,19 +1,21 @@
 models.py,sha256=Kx6oWKt7IpTTxrhBDrX61X-ZX12J7yPkJFuhVDsDHoQ,8807
 mosamatic2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mosamatic2/app.py,sha256=RIUa5tvMYFcmEII4xZPLZZdx9dXWqBvwkxkl_R97Jkw,860
-mosamatic2/cli.py,sha256=Fzsz1-uziNRabnBRvqyRcXFpQ7CGLF1dt4w7Js-Y1u8,1614
+mosamatic2/cli.py,sha256=pZIcsNPBYF1VLiQvo6CNv6_W-lw7toon1Mi0R9Huobw,1878
 mosamatic2/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mosamatic2/commands/boadockerpipeline.py,sha256=-k9rQlhixfcqGUy29SsKYVXxZFri6DcnWaV6utJ6mhI,1344
+mosamatic2/commands/calculatemaskstatistics.py,sha256=cCQkLhSczD0sk2wTmfwWF0A3ARkUPqqgrDoz8sT3kDw,1498
 mosamatic2/commands/calculatescores.py,sha256=Lb8Q8L2yq7Tt6VBJ6_lltRuldrev_pac6fcgF-xzZyE,1984
 mosamatic2/commands/createdicomsummary.py,sha256=qbVgWGIJPBL8vTBcAxfThloQ_q15OfQy5ohMprzZL4E,1955
 mosamatic2/commands/createpngsfromsegmentations.py,sha256=uUAQJVTqOkBCfENzi21RBNYvf6_nuesx1MeR3j_-7dM,1682
-mosamatic2/commands/defaultdockerpipeline.py,sha256=IxnpnIIsFH2u3aBLKgrHUb_Au72ajlIzzVe6Y0MFHJU,2025
+mosamatic2/commands/defaultdockerpipeline.py,sha256=oPi4UuZ0Xne0_fsAyzRyvhCgNV9KDH3nTyZJJlT3LpI,2368
 mosamatic2/commands/defaultpipeline.py,sha256=-kQRSXbEDimAdy_kT1qMxRlZWUoXdu3PkWf70PCIS5Y,1734
 mosamatic2/commands/dicom2nifti.py,sha256=uzI3-QT8_HtwXKkX5kRJzMKssM5dvJGUjZ1Z-XkwLYc,1366
+mosamatic2/commands/liveranalysispipeline.py,sha256=CiTTTIEpOAHwx7p919WH8XsEflEKyV6rgfgeG6XjIDs,1831
 mosamatic2/commands/rescaledicomimages.py,sha256=25QdCzB5s0sRwkTb3o5zco2bIwy6LttNf7i97kGBDYQ,1280
 mosamatic2/commands/segmentmusclefatl3tensorflow.py,sha256=CdScmA_EQicaN4GY5bBUOYwfhDPqy9om2sxY3WrtmM0,1424
 mosamatic2/commands/selectslicefromscans.py,sha256=3398PM2uBcxF6wpb0-c-Itp_qxoAxBf0SE2nDDI3Ct4,1715
-mosamatic2/commands/totalsegmentator.py,sha256=GY8wAFDHJW-dMWa3ZskHJnaYd71bKWUjpwV2-Wf38W4,1956
+mosamatic2/commands/totalsegmentator.py,sha256=VY3OWPmnQzqkWPjKj_HIcQu2kJoiwVAh2HveFC1Z6uE,2245
 mosamatic2/constants.py,sha256=MVYMwO-x2jQSN37o3zNkRseVQ1nYRA3mLv3v_Q0Mlds,1284
 mosamatic2/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mosamatic2/core/data/__init__.py,sha256=j9iGqUTJlGF0N0gPrzzpe_Dhv0Bj9c6FdQ1g7U-_j2g,298
@@ -29,16 +31,20 @@ mosamatic2/core/data/numpyimage.py,sha256=bnG6WVGSRxNdzIlb2DNj5u6Gv4BAYscIj2Buyj
 mosamatic2/core/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mosamatic2/core/managers/logmanager.py,sha256=NEaXvhl0aILjBbK710GaWanVuuNvB51HpHhE5rgYvng,1391
 mosamatic2/core/managers/logmanagerlistener.py,sha256=Gaig07yjBnyQq9I8sN85olTEeDCDyCFQnEJdwzvmgvc,99
-mosamatic2/core/pipelines/__init__.py,sha256=YPlyO5L_DMrTyO2-2TBq_Bdg-bbMHQiicXJafn66Dg8,283
+mosamatic2/core/pipelines/__init__.py,sha256=l2YJ5bc2PdscGYJGWUL1UvA-LeVvnckNDaMlxMvzdCc,388
 mosamatic2/core/pipelines/boadockerpipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mosamatic2/core/pipelines/boadockerpipeline/boadockerpipeline.py,sha256=KFZk_L_0KaTdUqHjqGW8MysbCIOKlUKWP8S-T9xyvis,2939
 mosamatic2/core/pipelines/defaultdockerpipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mosamatic2/core/pipelines/defaultdockerpipeline/defaultdockerpipeline.py,sha256=m_f9c7MmvSRqERF6n-nLGxa6xP13xtoSihW53d387zU,1315
+mosamatic2/core/pipelines/defaultdockerpipeline/defaultdockerpipeline.py,sha256=FlofeJE_eDHydoo-j_zBiorZXc9wg0a4YKpEesZYqgo,1164
 mosamatic2/core/pipelines/defaultpipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mosamatic2/core/pipelines/defaultpipeline/defaultpipeline.py,sha256=Bme0r_shnrllWYCYDNc6cLM2fQC2yD8RJKpRdoh_6Uc,3077
+mosamatic2/core/pipelines/liveranalysispipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mosamatic2/core/pipelines/liveranalysispipeline/liveranalysispipeline.py,sha256=OcIYJGI5eSZjNpnv5CBAz7cungCmgyT7aPmx7-_eGDc,1604
 mosamatic2/core/pipelines/pipeline.py,sha256=mRxKXLKwgKDpc8R9mCI6gDKGJ2lKVxRQ__Sf0Mfn_Qc,384
 mosamatic2/core/singleton.py,sha256=FV0k_LlOCmFhlWN6gf1c2x7YXWyd8-7DsIMvOKrI6NY,224
-mosamatic2/core/tasks/__init__.py,sha256=iJ4uMgLtN-PmZ43FAw8Y_QLh03ctiTaCGZxAUsVFXPM,857
+mosamatic2/core/tasks/__init__.py,sha256=JE-654XG0bel8n3EMM8nJmdZwQfMh_OzIRl61JWk-kw,976
+mosamatic2/core/tasks/calculatemaskstatisticstask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mosamatic2/core/tasks/calculatemaskstatisticstask/calculatemaskstatisticstask.py,sha256=e0VdrRLqEPQGqRTpAmCCkI4gDyo0IISd_0szonrbebI,4325
 mosamatic2/core/tasks/calculatescorestask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mosamatic2/core/tasks/calculatescorestask/calculatescorestask.py,sha256=cwGVedJR_BGSYzXq6ouTgCbSC6s2VtyD8FzRC-QBXUI,6617
 mosamatic2/core/tasks/createdicomsummarytask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -56,16 +62,16 @@ mosamatic2/core/tasks/selectslicefromscanstask/__init__.py,sha256=47DEQpj8HBSa-_
 mosamatic2/core/tasks/selectslicefromscanstask/selectslicefromscanstask.py,sha256=EIEHhWoGL30rcz8qckFl465rU40P-pIkvhMOfSud7Yw,7253
 mosamatic2/core/tasks/task.py,sha256=APPnid6dpSGkPuDqU1vm2RIMR5vkpvbP1CPHUMjympg,1691
 mosamatic2/core/tasks/totalsegmentatortask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mosamatic2/core/tasks/totalsegmentatortask/totalsegmentatortask.py,sha256=Yzy-V6psjhmt-idvLxBoUmbyQGnCBb0OiD0s9lXLmWk,2096
+mosamatic2/core/tasks/totalsegmentatortask/totalsegmentatortask.py,sha256=_phgEp-lPhsim53jdTyfzJzUF0EMcF-I-llQ3J9CyN4,3331
 mosamatic2/core/utils.py,sha256=4duREimHWkUfZIjSy16fsxF8-3ZxukfOi8eSNjAdxF8,12240
 mosamatic2/server.py,sha256=-cZ9BPsZUXoINKqwhCHN8c59mlvzzDXzTVxsYt9au70,4644
 mosamatic2/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mosamatic2/ui/mainwindow.py,sha256=DrX-6Hu4-3wJJy6rZkexYuTQ-pO_uliyEQVkYc4GuCM,15848
+mosamatic2/ui/mainwindow.py,sha256=goQVUGuWHHaUhs-oxnSRfZBth2VYYBNsvr2siA8wPnk,17866
 mosamatic2/ui/resources/icons/mosamatic2.icns,sha256=OfhC-diJTIgaNMOezxKKilGsY7mRkaGdU5dGr0MOjIA,2994125
 mosamatic2/ui/resources/icons/mosamatic2.ico,sha256=ySD3RYluHK3pgS0Eas7eKrVk_AskdLQ4qs_IT-wNhq4,12229
 mosamatic2/ui/resources/icons/spinner.gif,sha256=rvaac6GUZauHSPFSOLWr0RmLfjmtZih2Q8knQ2WP3Po,16240
 mosamatic2/ui/resources/images/body-composition.jpg,sha256=KD-BudbXwThB4lJOZZN-ad5-TZRaaZ5cKTH0Ar1TOZs,21227
-mosamatic2/ui/resources/VERSION,sha256=-cxAVNmHfDH3lZMAtwEaTEwW3lYerVGKI5FoPFpnQq0,9
+mosamatic2/ui/resources/VERSION,sha256=krMCj4G6-pLwCXMT7JLhq0fbjfA7zA6XnzVBHS_mgSc,9
 mosamatic2/ui/settings.py,sha256=YEVHYJIfNsqMO3v1pjzgh7Pih9GGoUX7S9s8S-sBNUk,2121
 mosamatic2/ui/utils.py,sha256=6bbPIrh4RJ_yhQKNZrgPbL4XeUEogjIjbk_e5c3QS5g,853
 mosamatic2/ui/widgets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -79,10 +85,12 @@ mosamatic2/ui/widgets/panels/mainpanel.py,sha256=KqI8dA7GpLFd2unqVRTBkNxdnh6AWGp
 mosamatic2/ui/widgets/panels/pipelines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mosamatic2/ui/widgets/panels/pipelines/boadockerpipelinepanel.py,sha256=f1VKob6SRi8dO2m1HF4JXwV_EkrzYWgTdkIOILDD5y4,8406
 mosamatic2/ui/widgets/panels/pipelines/defaultdockerpipelinepanel.py,sha256=VAYx8Ksb9yVaA2GngB5h-sJNfALXeQMmWqOEXQNCjKY,14215
-mosamatic2/ui/widgets/panels/pipelines/defaultpipelinepanel.py,sha256=qkfI4BnLIXqE_YvSQj4sO_FjnK0eVdIMqAZ8sktgI-8,13727
+mosamatic2/ui/widgets/panels/pipelines/defaultpipelinepanel.py,sha256=gxkDPLZIRbaOEPr0ekumfa9TlCRlzoaAYF8kiL1BzRw,13732
+mosamatic2/ui/widgets/panels/pipelines/liveranalysispipelinepanel.py,sha256=-bUv52mNWsrdWU0OBiOMfokOIgDnj8DWGzh47oRjvZ0,7778
 mosamatic2/ui/widgets/panels/pipelines/pipelinepanel.py,sha256=SlkKme8Wv2Bvp2Alen98mFjv3F5eZCwJylj294gd5uU,178
 mosamatic2/ui/widgets/panels/stackedpanel.py,sha256=dK1YWuHUzxRhVb5gP0Lu9rAiW4XagjcHmGF__5Lpufk,657
 mosamatic2/ui/widgets/panels/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mosamatic2/ui/widgets/panels/tasks/calculatemaskstatisticstaskpanel.py,sha256=o6cXLgzopOgT27DZb5DVdhGnRIABNGkTDu5yiIImJOg,9149
 mosamatic2/ui/widgets/panels/tasks/calculatescorestaskpanel.py,sha256=NmPLQizj4x9jgf9UA7VZSjARNHYJB_jrfB0kvaVncdw,9387
 mosamatic2/ui/widgets/panels/tasks/createdicomsummarytaskpanel.py,sha256=cRCaEmjjZP6RwEhezj2Axxuv8uAGe7ZzHoU67asoZ5s,7530
 mosamatic2/ui/widgets/panels/tasks/createpngsfromsegmentationstaskpanel.py,sha256=JFnmYjPemRtXPXV2fk2cjB45fseN5BZ8gI_T1zVLGV8,7879
@@ -100,7 +108,7 @@ mosamatic2/ui/widgets/panels/visualizations/slicevisualization/slicevisualizatio
 mosamatic2/ui/widgets/panels/visualizations/visualization.py,sha256=JvqTJi7cCGYK1-wrN2oURdCOBoPS2clVUyYglhkoVJg,178
 mosamatic2/ui/widgets/splashscreen.py,sha256=MS-OczOWfwwEQNQd-JWe9_Mh57css0cSQgbu973rwQo,4056
 mosamatic2/ui/worker.py,sha256=v7e3gq7MUudgpB1BJW-P7j5wurzu6-HG5m7I6WHgJp0,699
-mosamatic2-2.0.16.dist-info/entry_points.txt,sha256=MCUpKkgbej1clgp8EqlLQGs0BIKwGPcBPiVWLfGz9Gw,126
-mosamatic2-2.0.16.dist-info/METADATA,sha256=DZje4-e8ccI8_fErMX-LIRP0rjq-_p5QQpEezDXWIm0,1534
-mosamatic2-2.0.16.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-mosamatic2-2.0.16.dist-info/RECORD,,
+mosamatic2-2.0.17.dist-info/entry_points.txt,sha256=MCUpKkgbej1clgp8EqlLQGs0BIKwGPcBPiVWLfGz9Gw,126
+mosamatic2-2.0.17.dist-info/METADATA,sha256=NPrpAEWyQ33QauK_ymcmV-RE0vJTHetSGQGQxbvpfPM,1565
+mosamatic2-2.0.17.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+mosamatic2-2.0.17.dist-info/RECORD,,