mosamatic2 2.0.9__py3-none-any.whl → 2.0.11__py3-none-any.whl

mosamatic2/cli.py

@@ -7,6 +7,7 @@ from mosamatic2.commands import (
     dicom2nifti,
     selectslicefromscans,
     createdicomsummary,
+    defaultpipeline,
 )
 from mosamatic2.core.utils import show_doc_command
 
@@ -35,4 +36,5 @@ main.add_command(createpngsfromsegmentations.createpngsfromsegmentations)
 main.add_command(dicom2nifti.dicom2nifti)
 main.add_command(selectslicefromscans.selectslicefromscans)
 main.add_command(createdicomsummary.createdicomsummary)
+main.add_command(defaultpipeline.defaultpipeline)
 main.add_command(show_doc_command(main)) # Special command to show long description for command

mosamatic2/commands/defaultpipeline.py

@@ -0,0 +1,70 @@
+import click
+
+from mosamatic2.core.pipelines import DefaultPipeline
+
+
+@click.command(help='Runs default L3 analysis pipeline')
+@click.option(
+    '--images', 
+    required=True, 
+    type=click.Path(exists=True), 
+    help='Directory with L3 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', 
+    type=click.BOOL, 
+    default=False, 
+    help='Overwrite [true|false]'
+)
+def defaultpipeline(images, model_files, output, overwrite):
+    """
+    Runs default L3 analysis pipeline
+    
+    Parameters
+    ----------
+    --images : str
+        Directory with L3 images
+
+    --model_files : str
+        Directory with AI model files. This directory can ONLY contain the following
+        files:
+
+        (1) contour_model-1.0.zip
+        (2) model-1.0.zip
+        (3) params-1.0.json
+
+        These files can be downloaded from:
+        https://mosamatic.rbeesoft.nl/wordpress/mosamatic/installation/
+
+    --output : str
+        Path to output directory
+
+    --overwrite : bool
+        Overwrite contents output directory [true|false]
+    """
+    pipeline = DefaultPipeline(
+        inputs={'images': images, 'model_files': model_files},
+        params={
+            'target_size': 512,
+            'model_type': 'tensorflow',
+            'model_version': 1.0,
+            'file_type': 'npy',
+            'fig_width': 10,
+            'fig_height': 10,
+        },
+        output=output,
+        overwrite=overwrite,
+    )
+    pipeline.run()

mosamatic2/core/pipelines/__init__.py

@@ -1 +1,2 @@
-from mosamatic2.core.pipelines.defaultpipeline.defaultpipeline import DefaultPipeline
+from mosamatic2.core.pipelines.defaultpipeline.defaultpipeline import DefaultPipeline
+from mosamatic2.core.pipelines.defaultdockerpipeline.defaultdockerpipeline import DefaultDockerPipeline

mosamatic2/core/pipelines/defaultdockerpipeline/defaultdockerpipeline.py

@@ -0,0 +1,42 @@
+import os
+
+from mosamatic2.core.pipelines.pipeline import Pipeline
+from mosamatic2.core.managers.logmanager import LogManager
+
+LOG = LogManager()
+DOCKER_SCRIPT = """
+docker run --rm ^
+    -v "%IMAGES%":/data/images ^
+    -v "%MODEL_FILES%":/data/model_files ^
+    -v "%OUTPUT%":/data/output ^
+    brecheisen/mosamatic2-cli:%VERSION% defaultpipeline ^
+        --images /data/images --model_files /data/model_files --output /data/output --overwrite true
+"""
+
+
+class DefaultDockerPipeline(Pipeline):
+    INPUTS = [
+        'images',
+        'model_files',
+    ]
+    PARAMS = [
+        'target_size',
+        'file_type',
+        'fig_width',
+        'fig_height',
+        'model_type',
+        'model_version',
+        'version',
+    ]
+    def __init__(self, inputs, params, output, overwrite):
+        super(DefaultDockerPipeline, self).__init__(inputs, params, output, overwrite)
+
+    def run(self):
+        docker_script = 'docker run --rm ' + \
+            '-v "{}":/data/images '.format(self.input('images')) + \
+            '-v "{}":/data/model_files '.format(self.input('model_files')) + \
+            '-v "{}":/data/output '.format(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/tasks/selectslicefromscanstask/selectslicefromscanstask.py

@@ -25,6 +25,18 @@ class SelectSliceFromScansTask(Task):
 
     def __init__(self, inputs, params, output, overwrite):
         super(SelectSliceFromScansTask, self).__init__(inputs, params, output, overwrite)
+        self._error_dir = os.path.split(self.output())[0]
+        self._error_dir = os.path.join(self._error_dir, 'selectslicefromscanstask_errors')
+        os.makedirs(self._error_dir, exist_ok=True)
+        self._error_file = os.path.join(self._error_dir, 'errors.txt')
+        with open(self._error_file, 'w') as f:
+            f.write('Errors:\n')
+        LOG.info(f'Error directory: {self._error_dir}')
+
+    def write_error(self, message):
+        LOG.error(message)
+        with open(self._error_file, 'a') as f:
+            f.write(message + '\n')
 
     def load_scan_dirs(self):
         scan_dirs = []
@@ -37,6 +49,8 @@ class SelectSliceFromScansTask(Task):
     def extract_masks(self, scan_dir):
         os.makedirs(TOTAL_SEGMENTATOR_OUTPUT_DIR, exist_ok=True)
         totalsegmentator(input=scan_dir, output=TOTAL_SEGMENTATOR_OUTPUT_DIR, fast=True)
+        if not os.path.isfile(os.path.join(TOTAL_SEGMENTATOR_OUTPUT_DIR, 'vertebrae_L3.nii.gz')):
+            raise Exception(f'{scan_dir}: vertebrae_L3.nii.gz does not exist')
         # os.system(f'TotalSegmentator -i {scan_dir} -o {TOTAL_SEGMENTATOR_OUTPUT_DIR} --fast')
 
     def delete_total_segmentator_output(self):
@@ -54,25 +68,50 @@ class SelectSliceFromScansTask(Task):
         elif vertebra == 'T4':
             vertebral_level = 'vertebrae_T4'
         else:
-            raise RuntimeError(f'Unknown vertbra {vertebra}. Options are "L3" and "T4"')
+            self.write_error(f'{scan_dir}: Unknown vertbra {vertebra}. Options are "L3" and "T4"')
+            return None
         # Find Z-positions DICOM images
         z_positions = {}
         for f in os.listdir(scan_dir):
             f_path = os.path.join(scan_dir, f)
-            p = load_dicom(f_path, stop_before_pixels=True)
-            if p is not None:
-                z_positions[p.ImagePositionPatient[2]] = f_path
+            try:
+                p = load_dicom(f_path, stop_before_pixels=True)
+                if p is not None and hasattr(p, "ImagePositionPatient"):
+                    z_positions[p.ImagePositionPatient[2]] = f_path
+            except Exception as e:
+                self.write_error(f"{scan_dir}: Failed to load DICOM {f_path}: {e}")
+                break
+        if not z_positions:
+            self.write_error(f"{scan_dir}: No valid DICOM z-positions found.")
+            return None
         # Find Z-position L3 image
         mask_file = os.path.join(TOTAL_SEGMENTATOR_OUTPUT_DIR, f'{vertebral_level}.nii.gz')
-        mask_obj = nib.load(mask_file)
-        mask = mask_obj.get_fdata()
-        affine_transform = mask_obj.affine
+        if not os.path.exists(mask_file):
+            self.write_error(f"{scan_dir}: Mask file not found: {mask_file}")
+            return None
+        try:
+            mask_obj = nib.load(mask_file)
+            mask = mask_obj.get_fdata()
+            affine_transform = mask_obj.affine
+        except Exception as e:
+            self.write_error(f"{scan_dir}: Failed to load mask {mask_file}: {e}")
+            return None
         indexes = np.array(np.where(mask == 1))
-        index_min = indexes.min(axis=1)
-        index_max = indexes.max(axis=1)
+        if indexes.size == 0:
+            self.write_error(f"{scan_dir}: No voxels found in mask {mask_file} for {vertebral_level}")
+            return None        
+        try:
+            index_min = indexes.min(axis=1)
+            index_max = indexes.max(axis=1)
+        except ValueError as e:
+            self.write_error(f"{scan_dir}: Invalid indexes array for {vertebral_level}: {e}")
+            return None
         world_min = nib.affines.apply_affine(affine_transform, index_min)
         world_max = nib.affines.apply_affine(affine_transform, index_max)
         z_direction = affine_transform[:3, 2][2]
+        if z_direction == 0:
+            self.write_error(f"{scan_dir}: Affine z-direction is zero.")
+            return None
         z_sign = math.copysign(1, z_direction)
         z_delta_offset = self.get_z_delta_offset_for_mask(vertebral_level)
         if z_delta_offset is None:
@@ -88,6 +127,8 @@ class SelectSliceFromScansTask(Task):
                 closest_file = z_positions[closest_z]
                 LOG.info(f'Closest image: {closest_file}')
                 break
+        if closest_file is None:
+            self.write_error(f"{scan_dir}: No matching slice found.")
         return closest_file
 
     def run(self):
@@ -97,13 +138,25 @@ class SelectSliceFromScansTask(Task):
         for step in range(nr_steps):
             scan_dir = scan_dirs[step]
             scan_name = os.path.split(scan_dir)[1]
-            self.extract_masks(scan_dir)
-            file_path = self.find_slice(scan_dir, vertebra)
-            if file_path is not None:
-                extension = '' if file_path.endswith('.dcm') else '.dcm'
-                target_file_path = os.path.join(self.output(), vertebra + '_' + scan_name + extension)
-                shutil.copyfile(file_path, target_file_path)
-            else:
-                LOG.error(f'Could not find slice for vertebral level: {vertebra}')
-            self.delete_total_segmentator_output()
+            errors = False
+            LOG.info(f'Processing {scan_dir}...')
+            try:
+                self.extract_masks(scan_dir)
+            except Exception as e:
+                self.write_error(f'{scan_dir}: Could not extract masks [{str(e)}]. Skipping scan...')
+                errors = True
+            if not errors:
+                file_path = self.find_slice(scan_dir, vertebra)
+                if file_path is not None:
+                    extension = '' if file_path.endswith('.dcm') else '.dcm'
+                    target_file_path = os.path.join(self.output(), vertebra + '_' + scan_name + extension)
+                    shutil.copyfile(file_path, target_file_path)
+                else:
+                    self.write_error(f'{scan_dir}: Could not find slice for vertebral level: {vertebra}')
+                    errors = True
+                self.delete_total_segmentator_output()
+            if errors:
+                LOG.info(f'Copying problematic scan {scan_dir} to error directory: {self._error_dir}')
+                scan_error_dir = os.path.join(self._error_dir, scan_name)
+                shutil.copytree(scan_dir, scan_error_dir)
             self.set_progress(step, nr_steps)

mosamatic2/ui/mainwindow.py

@@ -22,6 +22,7 @@ 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.pipelines.defaultpipelinepanel import DefaultPipelinePanel
+from mosamatic2.ui.widgets.panels.pipelines.defaultdockerpipelinepanel import DefaultDockerPipelinePanel
 from mosamatic2.ui.widgets.panels.visualizations.slicevisualization.slicevisualization import SliceVisualization
 
 LOG = LogManager()
@@ -42,6 +43,7 @@ class MainWindow(QMainWindow):
         self._create_dicom_summary_task_panel = None
         self._select_slice_from_scans_task_panel = None
         self._default_pipeline_panel = None
+        self._default_docker_pipeline_panel = None
         self._slice_visualization = None
         self.init_window()
 
@@ -98,8 +100,11 @@ class MainWindow(QMainWindow):
     def init_pipelines_menu(self):
         default_pipeline_action = QAction('DefaultPipeline', self)
         default_pipeline_action.triggered.connect(self.handle_default_pipeline_action)
+        default_docker_pipeline_action = QAction('DefaultDockerPipeline', self)
+        default_docker_pipeline_action.triggered.connect(self.handle_default_docker_pipeline_action)
         pipelines_menu = self.menuBar().addMenu('Pipelines')
         pipelines_menu.addAction(default_pipeline_action)
+        pipelines_menu.addAction(default_docker_pipeline_action)
 
     def init_visualizations_menu(self):
         slice_visualization_action = QAction('SliceVisualization', self)
@@ -128,6 +133,7 @@ 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.default_pipeline_panel(), 'defaultpipelinepanel')
+            self._main_panel.add_panel(self.default_docker_pipeline_panel(), 'defaultdockerpipelinepanel')
             self._main_panel.add_panel(self.slice_visualization(), 'slicevisualization')
             self._main_panel.select_panel('defaultpipelinepanel')
         return self._main_panel
@@ -179,6 +185,11 @@ class MainWindow(QMainWindow):
         if not self._default_pipeline_panel:
             self._default_pipeline_panel = DefaultPipelinePanel()
         return self._default_pipeline_panel
+
+    def default_docker_pipeline_panel(self):
+        if not self._default_docker_pipeline_panel:
+            self._default_docker_pipeline_panel = DefaultDockerPipelinePanel()
+        return self._default_docker_pipeline_panel
     
     def slice_visualization(self):
         if not self._slice_visualization:
@@ -216,6 +227,9 @@ class MainWindow(QMainWindow):
     def handle_default_pipeline_action(self):
         self.main_panel().select_panel('defaultpipelinepanel')
 
+    def handle_default_docker_pipeline_action(self):
+        self.main_panel().select_panel('defaultdockerpipelinepanel')
+
     def handle_slice_visualization_action(self):
         self.main_panel().select_panel('slicevisualization')
 
@@ -233,6 +247,7 @@ 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.default_pipeline_panel().save_inputs_and_parameters()
+        self.default_docker_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.9 
+2.0.11 

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

@@ -0,0 +1,311 @@
+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 DefaultDockerPipeline
+
+LOG = LogManager()
+
+PANEL_TITLE = 'DefaultDockerPipeline'
+PANEL_NAME = 'defaultdockerpipeline'
+MODEL_TYPE_ITEM_NAMES = ['tensorflow', 'pytorch']
+MODEL_VERSION_ITEM_NAMES = ['1.0', '2.2']
+
+
+class DefaultDockerPipelinePanel(PipelinePanel):
+    def __init__(self):
+        super(DefaultDockerPipelinePanel, self).__init__()
+        self.set_title(PANEL_TITLE)
+        self._images_dir_line_edit = None
+        self._images_dir_select_button = None
+        self._model_files_dir_line_edit = None
+        self._model_files_dir_select_button = None
+        self._output_dir_line_edit = None
+        self._output_dir_select_button = None
+        self._target_size_spinbox = None
+        self._model_type_combobox = None
+        self._model_version_combobox = None
+        self._fig_width_spinbox = None
+        self._fig_height_spinbox = None
+        self._full_scan_checkbox = None
+        self._overwrite_checkbox = None
+        self._version_line_edit = 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 images_dir_line_edit(self):
+        if not self._images_dir_line_edit:
+            self._images_dir_line_edit = QLineEdit()
+            self._images_dir_line_edit.setText(self.settings().get(f'{PANEL_NAME}/images_dir'))
+        return self._images_dir_line_edit
+    
+    def images_dir_select_button(self):
+        if not self._images_dir_select_button:
+            self._images_dir_select_button = QPushButton('Select')
+            self._images_dir_select_button.clicked.connect(self.handle_images_dir_select_button)
+        return self._images_dir_select_button
+    
+    def model_files_dir_line_edit(self):
+        if not self._model_files_dir_line_edit:
+            self._model_files_dir_line_edit = QLineEdit()
+            self._model_files_dir_line_edit.setText(self.settings().get(f'{PANEL_NAME}/model_files_dir'))
+        return self._model_files_dir_line_edit
+    
+    def model_files_dir_select_button(self):
+        if not self._model_files_dir_select_button:
+            self._model_files_dir_select_button = QPushButton('Select')
+            self._model_files_dir_select_button.clicked.connect(self.handle_model_files_dir_select_button)
+        return self._model_files_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 target_size_spinbox(self):
+        if not self._target_size_spinbox:
+            self._target_size_spinbox = QSpinBox()
+            self._target_size_spinbox.setMinimum(0)
+            self._target_size_spinbox.setMaximum(1024)
+            self._target_size_spinbox.setValue(self.settings().get_int(f'{PANEL_NAME}/target_size', 512))
+        return self._target_size_spinbox
+    
+    def model_type_combobox(self):
+        if not self._model_type_combobox:
+            self._model_type_combobox = QComboBox()
+            self._model_type_combobox.addItems(MODEL_TYPE_ITEM_NAMES)
+            self._model_type_combobox.setCurrentText(self.settings().get(f'{PANEL_NAME}/model_type'))
+            self._model_type_combobox.currentTextChanged.connect(self.handle_model_type_combobox)
+        return self._model_type_combobox
+    
+    def model_version_combobox(self):
+        if not self._model_version_combobox:
+            self._model_version_combobox = QComboBox()
+            self._model_version_combobox.addItems(MODEL_VERSION_ITEM_NAMES)
+            self._model_version_combobox.setCurrentText(self.settings().get(f'{PANEL_NAME}/model_version'))
+            self._model_version_combobox.currentTextChanged.connect(self.handle_model_version_combobox)
+        return self._model_version_combobox
+    
+    def fig_width_spinbox(self):
+        if not self._fig_width_spinbox:
+            self._fig_width_spinbox = QSpinBox()
+            self._fig_width_spinbox.setValue(self.settings().get_int(f'{PANEL_NAME}/fig_width', default=10))
+        return self._fig_width_spinbox
+    
+    def fig_height_spinbox(self):
+        if not self._fig_height_spinbox:
+            self._fig_height_spinbox = QSpinBox()
+            self._fig_height_spinbox.setValue(self.settings().get_int(f'{PANEL_NAME}/fig_height', default=10))
+        return self._fig_height_spinbox
+    
+    def full_scan_checkbox(self):
+        if not self._full_scan_checkbox:
+            self._full_scan_checkbox = QCheckBox('')
+            self._full_scan_checkbox.setChecked(self.settings().get_bool(f'{PANEL_NAME}/full_scan', False))
+        return self._full_scan_checkbox
+
+    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 version_line_edit(self):
+        if not self._version_line_edit:
+            self._version_line_edit = QLineEdit()
+            self._version_line_edit.setText(self.settings().get(f'{PANEL_NAME}/version'))
+        return self._version_line_edit
+    
+    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):
+        images_dir_layout = QHBoxLayout()
+        images_dir_layout.addWidget(self.images_dir_line_edit())
+        images_dir_layout.addWidget(self.images_dir_select_button())
+        model_files_dir_layout = QHBoxLayout()
+        model_files_dir_layout.addWidget(self.model_files_dir_line_edit())
+        model_files_dir_layout.addWidget(self.model_files_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('Images directory', images_dir_layout)
+        self.form_layout().addRow('Model files directory', model_files_dir_layout)
+        self.form_layout().addRow('Output directory', output_dir_layout)
+        # self.form_layout().addRow('Version', self.version_line_edit())
+        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_images_dir_select_button(self):
+        last_directory = self.settings().get('last_directory')
+        directory = QFileDialog.getExistingDirectory(dir=last_directory)
+        if directory:
+            self.images_dir_line_edit().setText(directory)
+            self.settings().set('last_directory', directory)
+
+    def handle_model_files_dir_select_button(self):
+        last_directory = self.settings().get('last_directory')
+        directory = QFileDialog.getExistingDirectory(dir=last_directory)
+        if directory:
+            self.model_files_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_model_type_combobox(self, text):
+        if text == 'tensorflow':
+            self.model_version_combobox().setCurrentText('1.0')
+        if text == 'pytorch':
+            self.model_version_combobox().setCurrentText('2.2')
+
+    def handle_model_version_combobox(self, text):
+        if text == '1.0':
+            self.model_type_combobox().setCurrentText('tensorflow')
+        if text == '2.2':
+            self.model_type_combobox().setCurrentText('pytorch')
+
+    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 = DefaultDockerPipeline(
+                inputs={
+                    'images': self.images_dir_line_edit().text(),
+                    'model_files': self.model_files_dir_line_edit().text(),
+                },
+                params={
+                    'file_type': 'npy',
+                    'model_type': 'tensorflow',
+                    'model_version': 1.0,
+                    'target_size': 512,
+                    'fig_width': 10,
+                    'fig_height': 10,
+                    'version': '2.0.10',
+                },
+                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.images_dir_line_edit().text() == '':
+            errors.append('Empty images directory path')
+        elif not os.path.isdir(self.images_dir_line_edit().text()):
+            errors.append('Images directory does not exist')
+        if self.model_files_dir_line_edit().text() == '':
+            errors.append('Empty model files directory path')
+        elif not os.path.isdir(self.model_files_dir_line_edit().text()):
+            errors.append('Model files 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')
+        # if self.version_line_edit().text() == '':
+        #     errors.append('Empty version. Should be same as current Mosamatic version')
+        # if self.target_size_spinbox().value() != 512:
+        #     errors.append('Target size must be 512')
+        # if self.full_scan_checkbox().isChecked():
+        #     errors.append('Full scan support is not available yet')
+        return errors
+    
+    def save_inputs_and_parameters(self):
+        self.settings().set(f'{PANEL_NAME}/images_dir', self.images_dir_line_edit().text())
+        self.settings().set(f'{PANEL_NAME}/model_files_dir', self.model_files_dir_line_edit().text())
+        self.settings().set(f'{PANEL_NAME}/output_dir', self.output_dir_line_edit().text())
+        # self.settings().set(f'{PANEL_NAME}/version', self.version_line_edit().text())
+        # self.settings().set(f'{PANEL_NAME}/target_size', self.target_size_spinbox().value())
+        # self.settings().set(f'{PANEL_NAME}/model_type', self.model_type_combobox().currentText())
+        # self.settings().set(f'{PANEL_NAME}/model_version', self.model_version_combobox().currentText())
+        # self.settings().set(f'{PANEL_NAME}/fig_width', self.fig_width_spinbox().value())
+        # self.settings().set(f'{PANEL_NAME}/fig_height', self.fig_height_spinbox().value())
+        # self.settings().set(f'{PANEL_NAME}/full_scan', self.full_scan_checkbox().isChecked())
+        self.settings().set(f'{PANEL_NAME}/overwrite', self.overwrite_checkbox().isChecked())

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

@@ -25,7 +25,7 @@ from mosamatic2.core.tasks import SelectSliceFromScansTask
 
 LOG = LogManager()
 
-PANEL_TITLE = 'Automatically select L3 slice from full CT scan'
+PANEL_TITLE = 'SelectSliceFromScansTaskPanel'
 PANEL_NAME = 'selectslicefromscanstaskpanel'
 
 

{mosamatic2-2.0.9.dist-info → mosamatic2-2.0.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mosamatic2
-Version: 2.0.9
+Version: 2.0.11
 Summary: 
 Author: Ralph Brecheisen
 Author-email: r.brecheisen@maastrichtuniversity.nl
@@ -29,8 +29,8 @@ Requires-Dist: tensorflow-intel (==2.15.0) ; platform_system == "Windows"
 Requires-Dist: tensorflow-io-gcs-filesystem (==0.31.0) ; platform_system == "Windows"
 Requires-Dist: tensorflow-io-gcs-filesystem (>=0.31.0) ; platform_system == "Darwin" and platform_machine == "arm64"
 Requires-Dist: tensorflow-macos (==2.15.0) ; platform_system == "Darwin" and platform_machine == "arm64"
-Requires-Dist: torch (>=2.8.0)
-Requires-Dist: torchvision (>=0.23.0)
+Requires-Dist: torch (==2.5.1)
+Requires-Dist: torchvision (>=0.20.1)
 Requires-Dist: totalsegmentator (>=2.11.0)
 Requires-Dist: vtk (>=9.5.1)
 Description-Content-Type: text/markdown

{mosamatic2-2.0.9.dist-info → mosamatic2-2.0.11.dist-info}/RECORD

@@ -1,11 +1,12 @@
 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=kqLdLCZCA7-xxgOOWohsCCrD6Jz3MamslmCl-41R2rA,1371
+mosamatic2/cli.py,sha256=EhGBs8AZjgZBBDFkWBNRuKd9o37Zo116DlKHHFBhoBo,1444
 mosamatic2/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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/defaultpipeline.py,sha256=-kQRSXbEDimAdy_kT1qMxRlZWUoXdu3PkWf70PCIS5Y,1734
 mosamatic2/commands/dicom2nifti.py,sha256=4hMvglxdOid7p7P_Jc-Tudsf93JRMlYaQsEQctLq2d4,1015
 mosamatic2/commands/rescaledicomimages.py,sha256=25QdCzB5s0sRwkTb3o5zco2bIwy6LttNf7i97kGBDYQ,1280
 mosamatic2/commands/segmentmusclefatl3tensorflow.py,sha256=CdScmA_EQicaN4GY5bBUOYwfhDPqy9om2sxY3WrtmM0,1424
@@ -23,7 +24,9 @@ mosamatic2/core/data/numpyimage.py,sha256=ZbJ9JRAVOgvXzTZ6kscEuGZJqKT-MPdt42IAlm
 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=Esb4TQFvY2soU2dfQPgVlhfTx1LdxYrPBiuAKDosHqA,85
+mosamatic2/core/pipelines/__init__.py,sha256=2RjHG0xLO-_QK-yw0RHrJe85B-SZ4oAKUJWrDzrLdGI,190
+mosamatic2/core/pipelines/defaultdockerpipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mosamatic2/core/pipelines/defaultdockerpipeline/defaultdockerpipeline.py,sha256=gb-rez0Y3jY6_c7llfwN2IDnl9l5Fz3XyvScLmWA7Y4,1490
 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/pipeline.py,sha256=mRxKXLKwgKDpc8R9mCI6gDKGJ2lKVxRQ__Sf0Mfn_Qc,384
@@ -43,17 +46,17 @@ mosamatic2/core/tasks/segmentmusclefatl3tensorflowtask/__init__.py,sha256=47DEQp
 mosamatic2/core/tasks/segmentmusclefatl3tensorflowtask/paramloader.py,sha256=VxTCOYK_1VRAG83P-ulm0LPvqXI-0iT5BCr0Rdr7MWg,900
 mosamatic2/core/tasks/segmentmusclefatl3tensorflowtask/segmentmusclefatl3tensorflowtask.py,sha256=E3GHzGtl-v_qIdLjSy3cbDnf8vfWK6Bax3RAZcKCqXg,5149
 mosamatic2/core/tasks/selectslicefromscanstask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mosamatic2/core/tasks/selectslicefromscanstask/selectslicefromscanstask.py,sha256=1a_QHcIdS4VB39cNEBniaaDzUx3k8DcR0wCtdr8G1d0,4586
+mosamatic2/core/tasks/selectslicefromscanstask/selectslicefromscanstask.py,sha256=kENwpV4Omlg-EUPTQYaSqDbkNhIQ8vZeA3Tlz15eXBw,7251
 mosamatic2/core/tasks/task.py,sha256=APPnid6dpSGkPuDqU1vm2RIMR5vkpvbP1CPHUMjympg,1691
 mosamatic2/core/utils.py,sha256=iib_o_dD4hnqGIgOxLOfvMFOqLZOpt0iT_8Oarkmdjs,11723
 mosamatic2/server.py,sha256=-cZ9BPsZUXoINKqwhCHN8c59mlvzzDXzTVxsYt9au70,4644
 mosamatic2/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mosamatic2/ui/mainwindow.py,sha256=nV9RqqSZVoVbU2opJIk7E3n4GvZWtuDETxmzwzmx4mg,13099
+mosamatic2/ui/mainwindow.py,sha256=H1X1pLJjqd2DhxJY0ZU6QkktX28zl0pmtFflmOxrGZA,14048
 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=GK-SWujODPcbTcVr82R22iPUlrjhCG6gyHU--L4NyBQ,8
+mosamatic2/ui/resources/VERSION,sha256=y0GqH9MTkPlMyl8fiOr-IbS7ffiCOAoUIM8ee5UYv7s,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
@@ -65,6 +68,7 @@ mosamatic2/ui/widgets/panels/defaultpanel.py,sha256=Ry32Xv6ibxm6NdZ7eBOCcisWNcmn
 mosamatic2/ui/widgets/panels/logpanel.py,sha256=ogswJ6_ryb6u7JeVnOsh2Ez8KWg6jtCFZwij8s87xO4,1861
 mosamatic2/ui/widgets/panels/mainpanel.py,sha256=KqI8dA7GpLFd2unqVRTBkNxdnh6AWGpVPwQuaEg8PmI,2431
 mosamatic2/ui/widgets/panels/pipelines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mosamatic2/ui/widgets/panels/pipelines/defaultdockerpipelinepanel.py,sha256=SRS6gBhnymgRM6TmaqJgzHzHfffkWucMCjsuzDgJdBg,14415
 mosamatic2/ui/widgets/panels/pipelines/defaultpipelinepanel.py,sha256=qkfI4BnLIXqE_YvSQj4sO_FjnK0eVdIMqAZ8sktgI-8,13727
 mosamatic2/ui/widgets/panels/pipelines/pipelinepanel.py,sha256=SlkKme8Wv2Bvp2Alen98mFjv3F5eZCwJylj294gd5uU,178
 mosamatic2/ui/widgets/panels/stackedpanel.py,sha256=dK1YWuHUzxRhVb5gP0Lu9rAiW4XagjcHmGF__5Lpufk,657
@@ -75,7 +79,7 @@ mosamatic2/ui/widgets/panels/tasks/createpngsfromsegmentationstaskpanel.py,sha25
 mosamatic2/ui/widgets/panels/tasks/dicom2niftitaskpanel.py,sha256=gIv5xo0z2EEfFzHI4Q6H87maf-nPIeC8yIxLL5iWuCw,7480
 mosamatic2/ui/widgets/panels/tasks/rescaledicomimagestaskpanel.py,sha256=ds7JxynpMeNvqfHKtg1LQR23rb3_Y7xoDLbZ2wl-TMw,7597
 mosamatic2/ui/widgets/panels/tasks/segmentmusclefatl3tensorflowtaskpanel.py,sha256=QCEZs9lqaE-XAJuyyrfZVnFkNRyjMw6Cfa-6qP9WaV8,9630
-mosamatic2/ui/widgets/panels/tasks/selectslicefromscanstaskpanel.py,sha256=iZu_li_7Zr3n8nVp-FI1GFV_HuCf_I4NY9PNr9aX-oY,8077
+mosamatic2/ui/widgets/panels/tasks/selectslicefromscanstaskpanel.py,sha256=meKltgxPReZ9HioSop6jW_2CFm18URBy3LX11U8tbtc,8059
 mosamatic2/ui/widgets/panels/tasks/taskpanel.py,sha256=t8lIx1P8sS1Fa-aNm6eEha6297pJQNbBRizkobBexz8,170
 mosamatic2/ui/widgets/panels/visualizations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mosamatic2/ui/widgets/panels/visualizations/slicevisualization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -85,7 +89,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.9.dist-info/entry_points.txt,sha256=MCUpKkgbej1clgp8EqlLQGs0BIKwGPcBPiVWLfGz9Gw,126
-mosamatic2-2.0.9.dist-info/METADATA,sha256=ghYgnAGDjhsgKeX6PpcMuQ_Dr2ZkEI4HMXkMXBRpLW8,1489
-mosamatic2-2.0.9.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-mosamatic2-2.0.9.dist-info/RECORD,,
+mosamatic2-2.0.11.dist-info/entry_points.txt,sha256=MCUpKkgbej1clgp8EqlLQGs0BIKwGPcBPiVWLfGz9Gw,126
+mosamatic2-2.0.11.dist-info/METADATA,sha256=PB1v5wdjawm3d8_s3bvssSzlrxfPNLSGLMD-U8X9NrI,1490
+mosamatic2-2.0.11.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+mosamatic2-2.0.11.dist-info/RECORD,,