mosamatic2 2.0.4__tar.gz → 2.0.6__tar.gz

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mosamatic2
-Version: 2.0.4
+Version: 2.0.6
 Summary: 
 Author: Ralph Brecheisen
 Author-email: r.brecheisen@maastrichtuniversity.nl
@@ -17,6 +17,7 @@ Requires-Dist: pandas (>=2.3.2)
 Requires-Dist: pendulum (>=3.1.0)
 Requires-Dist: pillow (>=11.3.0)
 Requires-Dist: pydicom (>=3.0.1)
+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)
@@ -30,6 +31,7 @@ Requires-Dist: tensorflow-macos (==2.15.0) ; platform_system == "Darwin" and pla
 Requires-Dist: torch (>=2.8.0)
 Requires-Dist: torchvision (>=0.23.0)
 Requires-Dist: totalsegmentator (>=2.11.0)
+Requires-Dist: vtk (>=9.5.1)
 Description-Content-Type: text/markdown
 
 

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mosamatic2"
-version = "2.0.4"
+version = "2.0.6"
 description = ""
 authors = [
     {name = "Ralph Brecheisen", email = "r.brecheisen@maastrichtuniversity.nl"}
@@ -31,6 +31,8 @@ dependencies = [
     "totalsegmentator>=2.11.0",
     "flask>=3.1.2",
     "antspyx>=0.5.4",
+    "vtk>=9.5.1",
+    "pyqtgraph>=0.13.7",
 ]
 
 [tool.poetry]

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/src/mosamatic2/cli.py

@@ -5,6 +5,7 @@ from mosamatic2.commands import (
     segmentmusclefatl3tensorflow,
     createpngsfromsegmentations,
     dicom2nifti,
+    selectslicefromscans,
 )
 from mosamatic2.core.utils import show_doc_command
 
@@ -31,4 +32,5 @@ main.add_command(rescaledicomimages.rescaledicomimages)
 main.add_command(segmentmusclefatl3tensorflow.segmentmusclefatl3tensorflow)
 main.add_command(createpngsfromsegmentations.createpngsfromsegmentations)
 main.add_command(dicom2nifti.dicom2nifti)
+main.add_command(selectslicefromscans.selectslicefromscans)
 main.add_command(show_doc_command(main)) # Special command to show long description for command

mosamatic2-2.0.6/src/mosamatic2/commands/selectslicefromscans.py

@@ -0,0 +1,65 @@
+import click
+
+from mosamatic2.core.tasks import SelectSliceFromScansTask
+
+
+@click.command(help='Selects specific slice from CT scans')
+@click.option(
+    '--scans', 
+    required=True, 
+    type=click.Path(exists=True), 
+    help='Directory with scans (each patient separate subdirectory)',
+)
+@click.option(
+    '--output', 
+    required=True, 
+    type=click.Path(), 
+    help='Output directory'
+)
+@click.option(
+    '--vertebra', 
+    required=True,
+    help='Vertebral level for selecting slice (default: "L3")'
+)
+@click.option(
+    '--overwrite', 
+    type=click.BOOL, 
+    default=False, 
+    help='Overwrite [true|false]'
+)
+def selectslicefromscans(scans, vertebra, output, overwrite):
+    """
+    Selects specific slice from list of CT scans
+    
+    Parameters
+    ----------
+    --scans : str
+        Directory to scans. Each patient's scan should be in a separate
+        subdirectory. For example:
+
+        /scans
+        /scans/patient1
+        /scans/patient1/file1.dcm
+        /scans/patient1/file2.dcm
+        ...
+        /scans/patient2
+        ...
+
+    --output : str
+        Path to output directory where selected slices will be placed. Each
+        slice's file name will be the same as the scan directory name, so in
+        the example above that would be "patient1", "patient2", etc.
+
+    --vertebra : str
+        Vertebral level where to take slice [L3|T4]
+
+    --overwrite : bool
+        Overwrite contents output directory [true|false]
+    """
+    task = SelectSliceFromScansTask(
+        inputs={'scans': scans},
+        params={'vertebra': vertebra},
+        output=output,
+        overwrite=overwrite,
+    )
+    task.run()

mosamatic2-2.0.6/src/mosamatic2/core/data/multinumpyimage.py

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

mosamatic2-2.0.6/src/mosamatic2/core/data/numpyimage.py

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

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/src/mosamatic2/core/tasks/__init__.py

@@ -2,4 +2,5 @@ from mosamatic2.core.tasks.rescaledicomimagestask.rescaledicomimagestask import
 from mosamatic2.core.tasks.segmentmusclefatl3tensorflowtask.segmentmusclefatl3tensorflowtask import SegmentMuscleFatL3TensorFlowTask
 from mosamatic2.core.tasks.calculatescorestask.calculatescorestask import CalculateScoresTask
 from mosamatic2.core.tasks.createpngsfromsegmentationstask.createpngsfromsegmentationstask import CreatePngsFromSegmentationsTask
-from mosamatic2.core.tasks.dicom2niftitask.dicom2niftitask import Dicom2NiftiTask
+from mosamatic2.core.tasks.dicom2niftitask.dicom2niftitask import Dicom2NiftiTask
+from mosamatic2.core.tasks.selectslicefromscanstask.selectslicefromscanstask import SelectSliceFromScansTask

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/src/mosamatic2/core/tasks/calculatescorestask/calculatescorestask.py

@@ -4,10 +4,8 @@ import pandas as pd
 from mosamatic2.core.tasks.task import Task
 from mosamatic2.core.managers.logmanager import LogManager
 from mosamatic2.core.data.multidicomimage import MultiDicomImage
+from mosamatic2.core.data.numpyimage import NumPyImage
 from mosamatic2.core.utils import (
-    is_dicom, 
-    load_dicom,
-    is_jpeg2000_compressed,
     get_pixels_from_dicom_object,
     calculate_area,
     calculate_mean_radiation_attenuation,
@@ -41,13 +39,11 @@ class CalculateScoresTask(Task):
                 if file_type == '.seg.npy':
                     f_seg_name = f_seg_name.removesuffix(file_type)
                     if f_seg_name == f_img_name:
-                        # img_seg_pairs.append((f_img_path, f_seg_path))
                         img_seg_pairs.append((image, f_seg_path))
                 elif file_type == '.tag':
                     f_seg_name = f_seg_name.removesuffix(file_type).removesuffix('.dcm')
                     f_img_name = f_img_name.removesuffix('.dcm')
                     if f_seg_name == f_img_name:
-                        # img_seg_pairs.append((f_img_path, f_seg_path))
                         img_seg_pairs.append((image, f_seg_path))
                 else:
                     raise RuntimeError('Unknown file type')
@@ -78,7 +74,11 @@ class CalculateScoresTask(Task):
 
     def load_segmentation(self, f, file_type='npy'):
         if file_type == 'npy':
-            return np.load(f)
+            segmentation = NumPyImage()
+            segmentation.set_path(f)
+            if segmentation.load():
+                return segmentation.object()
+            LOG.error(f'Could not load segmentation file {f}')
         if file_type == 'tag':
             pixels = get_pixels_from_tag_file(f)
             try:

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/src/mosamatic2/core/tasks/segmentmusclefatl3tensorflowtask/segmentmusclefatl3tensorflowtask.py

@@ -28,7 +28,7 @@ class SegmentMuscleFatL3TensorFlowTask(Task):
     def __init__(self, inputs, params, output, overwrite=True):
         super(SegmentMuscleFatL3TensorFlowTask, self).__init__(inputs, params, output, overwrite)
 
-    def load_images(self):
+    def load_images(self):        
         image_data = MultiDicomImage()
         image_data.set_path(self.input('images'))
         if image_data.load():
@@ -55,7 +55,6 @@ class SegmentMuscleFatL3TensorFlowTask(Task):
                     import tensorflow as tf
                     tfLoaded = True
                 with tempfile.TemporaryDirectory() as model_dir_unzipped:
-                # model_dir_unzipped = os.path.join(os.path.split(f_path)[0], 'model_unzipped')
                     os.makedirs(model_dir_unzipped, exist_ok=True)
                     with zipfile.ZipFile(f_path) as zipObj:
                         zipObj.extractall(path=model_dir_unzipped)
@@ -65,7 +64,6 @@ class SegmentMuscleFatL3TensorFlowTask(Task):
                     import tensorflow as tf
                     tfLoaded = True
                 with tempfile.TemporaryDirectory() as contour_model_dir_unzipped:
-                # contour_model_dir_unzipped = os.path.join(os.path.split(f_path)[0], 'contour_model_unzipped')
                     os.makedirs(contour_model_dir_unzipped, exist_ok=True)
                     with zipfile.ZipFile(f_path) as zipObj:
                         zipObj.extractall(path=contour_model_dir_unzipped)

mosamatic2-2.0.6/src/mosamatic2/core/tasks/selectslicefromscanstask/selectslicefromscanstask.py

@@ -0,0 +1,109 @@
+import os
+import math
+import tempfile
+import shutil
+import nibabel as nib
+import numpy as np
+from totalsegmentator.python_api import totalsegmentator
+from mosamatic2.core.tasks.task import Task
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.core.utils import load_dicom
+
+LOG = LogManager()
+
+TOTAL_SEGMENTATOR_OUTPUT_DIR = os.path.join(tempfile.gettempdir(), 'total_segmentator_output')
+TOTAL_SEGMENTATOR_TASK = 'total'
+Z_DELTA_OFFSETS = {
+    'vertebrae_L3': 0.333,
+    'vertebrae_T4': 0.5,
+}
+
+
+class SelectSliceFromScansTask(Task):
+    INPUTS = ['scans']
+    PARAMS = ['vertebra']
+
+    def __init__(self, inputs, params, output, overwrite):
+        super(SelectSliceFromScansTask, self).__init__(inputs, params, output, overwrite)
+
+    def load_scan_dirs(self):
+        scan_dirs = []
+        for d in os.listdir(self.input('scans')):
+            scan_dir = os.path.join(self.input('scans'), d)
+            if os.path.isdir(scan_dir):
+                scan_dirs.append(scan_dir)
+        return scan_dirs
+    
+    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)
+        # os.system(f'TotalSegmentator -i {scan_dir} -o {TOTAL_SEGMENTATOR_OUTPUT_DIR} --fast')
+
+    def delete_total_segmentator_output(self):
+        if os.path.exists(TOTAL_SEGMENTATOR_OUTPUT_DIR):
+            shutil.rmtree(TOTAL_SEGMENTATOR_OUTPUT_DIR)
+
+    def get_z_delta_offset_for_mask(self, mask_name):
+        if mask_name not in Z_DELTA_OFFSETS.keys():
+            return None
+        return Z_DELTA_OFFSETS[mask_name]
+
+    def find_slice(self, scan_dir, vertebra):
+        if vertebra == 'L3':
+            vertebral_level = 'vertebrae_L3'
+        elif vertebra == 'T4':
+            vertebral_level = 'vertebrae_T4'
+        else:
+            raise RuntimeError(f'Unknown vertbra {vertebra}. Options are "L3" and "T4"')
+        # 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
+        # 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
+        indexes = np.array(np.where(mask == 1))
+        index_min = indexes.min(axis=1)
+        index_max = indexes.max(axis=1)
+        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]
+        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:
+            return None
+        z_delta = 0.333 * abs(world_max[2] - world_min[2]) # This needs to be vertebra-specific perhaps
+        z_l3 = world_max[2] - z_sign * z_delta
+        # Find closest L3 image in DICOM set
+        positions = sorted(z_positions.keys())
+        closest_file = None
+        for z1, z2 in zip(positions[:-1], positions[1:]):
+            if min(z1, z2) <= z_l3 <= max(z1, z2):
+                closest_z = min(z_positions.keys(), key=lambda z: abs(z - z_l3))
+                closest_file = z_positions[closest_z]
+                LOG.info(f'Closest image: {closest_file}')
+                break
+        return closest_file
+
+    def run(self):
+        scan_dirs = self.load_scan_dirs()
+        vertebra = self.param('vertebra')
+        nr_steps = len(scan_dirs)
+        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()
+            self.set_progress(step, nr_steps)

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/src/mosamatic2/core/utils.py

@@ -119,10 +119,18 @@ def is_numpy_array(value):
     return isinstance(value, np.array)
 
 
-def load_numpy_array(f):
+def is_numpy(f):
     try:
+        np.load(f)
+        return True
+    except:
+        return False
+
+
+def load_numpy_array(f):
+    if is_numpy(f):
         return np.load(f)
-    except Exception as e:
+    else:
         return None
 
 

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/src/mosamatic2/server.py

@@ -6,6 +6,7 @@ from mosamatic2.core.tasks import SegmentMuscleFatL3TensorFlowTask
 from mosamatic2.core.tasks import CalculateScoresTask
 from mosamatic2.core.tasks import CreatePngsFromSegmentationsTask
 from mosamatic2.core.tasks import Dicom2NiftiTask
+from mosamatic2.core.tasks import SelectSliceFromScansTask
 
 app = Flask(__name__)
 
@@ -105,6 +106,22 @@ def run_dicom2nifti():
     return 'PASSED'
 
 
+@app.route('/selectslicefromscans')
+def run_selectslicefromscans():
+    scans = request.args.get('scans')
+    vertebra = request.args.get('vertebra')
+    output = request.args.get('output')
+    overwrite = request.args.get('overwrite', default=True, type=bool)
+    task = SelectSliceFromScansTask(
+        inputs={'scans': scans},
+        params={'vertebra': vertebra},
+        output=output,
+        overwrite=overwrite,
+    )
+    task.run()
+    return 'PASSED'
+
+
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument('--port', type=int, default=constants.MOSAMATIC2_SERVER_PORT)

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/src/mosamatic2/ui/mainwindow.py

@@ -19,7 +19,9 @@ from mosamatic2.ui.widgets.panels.tasks.segmentmusclefatl3tensorflowtaskpanel im
 from mosamatic2.ui.widgets.panels.tasks.createpngsfromsegmentationstaskpanel import CreatePngsFromSegmentationsTaskPanel
 from mosamatic2.ui.widgets.panels.tasks.calculatescorestaskpanel import CalculateScoresTaskPanel
 from mosamatic2.ui.widgets.panels.tasks.dicom2niftitaskpanel import Dicom2NiftiTaskPanel
+from mosamatic2.ui.widgets.panels.tasks.selectslicefromscanstaskpanel import SelectSliceFromScansTaskPanel
 from mosamatic2.ui.widgets.panels.pipelines.defaultpipelinepanel import DefaultPipelinePanel
+from mosamatic2.ui.widgets.panels.visualizations.slicevisualization.slicevisualization import SliceVisualization
 
 LOG = LogManager()
 
@@ -36,7 +38,9 @@ class MainWindow(QMainWindow):
         self._create_pngs_from_segmentations_task_panel = None
         self._calculate_scores_task_panel = None
         self._dicom2nifti_task_panel = None
+        self._select_slice_from_scans_task_panel = None
         self._default_pipeline_panel = None
+        self._slice_visualization = None
         self.init_window()
 
     def init_window(self):
@@ -55,6 +59,7 @@ class MainWindow(QMainWindow):
         self.init_app_menu()
         self.init_tasks_menu()
         self.init_pipelines_menu()
+        self.init_visualizations_menu()
         if is_macos():            
             self.menuBar().setNativeMenuBar(False)
 
@@ -75,12 +80,15 @@ class MainWindow(QMainWindow):
         create_pngs_from_segmentations_task_action.triggered.connect(self.handle_create_pngs_from_segmentations_task_action)
         dicom2nifti_task_action = QAction('Dicom2NiftiTask', self)
         dicom2nifti_task_action.triggered.connect(self.handle_dicom2nifti_task_action)
+        select_slice_from_scans_task_action = QAction('SelectSliceFromScansTask', self)
+        select_slice_from_scans_task_action.triggered.connect(self.handle_select_slice_from_scans_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)
         tasks_menu.addAction(calculate_scores_task_action)
         tasks_menu.addAction(create_pngs_from_segmentations_task_action)
         tasks_menu.addAction(dicom2nifti_task_action)
+        tasks_menu.addAction(select_slice_from_scans_task_action)
 
     def init_pipelines_menu(self):
         default_pipeline_action = QAction('DefaultPipeline', self)
@@ -88,6 +96,12 @@ class MainWindow(QMainWindow):
         pipelines_menu = self.menuBar().addMenu('Pipelines')
         pipelines_menu.addAction(default_pipeline_action)
 
+    def init_visualizations_menu(self):
+        slice_visualization_action = QAction('SliceVisualization', self)
+        slice_visualization_action.triggered.connect(self.handle_slice_visualization_action)
+        visualizations_menu = self.menuBar().addMenu('Visualizations')
+        visualizations_menu.addAction(slice_visualization_action)
+
     def init_status_bar(self):
         self.set_status('Ready')
 
@@ -106,7 +120,9 @@ class MainWindow(QMainWindow):
             self._main_panel.add_panel(self.create_pngs_from_segmentations_task_panel(), 'createpngsfromsegmentationstaskpanel')
             self._main_panel.add_panel(self.calculate_scores_task_panel(), 'calculatescorestaskpanel')
             self._main_panel.add_panel(self.dicom2nifti_task_panel(), 'dicom2niftitaskpanel')
+            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.slice_visualization(), 'slicevisualization')
             self._main_panel.select_panel('defaultpipelinepanel')
         return self._main_panel
     
@@ -142,11 +158,21 @@ class MainWindow(QMainWindow):
         if not self._dicom2nifti_task_panel:
             self._dicom2nifti_task_panel = Dicom2NiftiTaskPanel()
         return self._dicom2nifti_task_panel
+
+    def select_slice_from_scans_task_panel(self):
+        if not self._select_slice_from_scans_task_panel:
+            self._select_slice_from_scans_task_panel = SelectSliceFromScansTaskPanel()
+        return self._select_slice_from_scans_task_panel
     
     def default_pipeline_panel(self):
         if not self._default_pipeline_panel:
             self._default_pipeline_panel = DefaultPipelinePanel()
         return self._default_pipeline_panel
+    
+    def slice_visualization(self):
+        if not self._slice_visualization:
+            self._slice_visualization = SliceVisualization()
+        return self._slice_visualization
 
     # SETTERS
 
@@ -170,9 +196,15 @@ class MainWindow(QMainWindow):
     def handle_dicom2nifti_task_action(self):
         self.main_panel().select_panel('dicom2niftitaskpanel')
 
+    def handle_select_slice_from_scans_task_action(self):
+        self.main_panel().select_panel('selectslicefromscanstaskpanel')
+
     def handle_default_pipeline_action(self):
         self.main_panel().select_panel('defaultpipelinepanel')
 
+    def handle_slice_visualization_action(self):
+        self.main_panel().select_panel('slicevisualization')
+
     def showEvent(self, event):
         return super().showEvent(event)
 
@@ -184,7 +216,9 @@ class MainWindow(QMainWindow):
         self.create_pngs_from_segmentations_task_panel().save_inputs_and_parameters()
         self.calculate_scores_task_panel().save_inputs_and_parameters()
         self.dicom2nifti_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.slice_visualization().save_inputs_and_parameters()
         return super().closeEvent(event)
 
     def load_geometry_and_state(self):

mosamatic2-2.0.6/src/mosamatic2/ui/resources/VERSION

@@ -0,0 +1 @@
+2.0.6 

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/src/mosamatic2/ui/widgets/panels/pipelines/defaultpipelinepanel.py

@@ -18,7 +18,7 @@ from PySide6.QtCore import (
 )
 
 from mosamatic2.core.managers.logmanager import LogManager
-from mosamatic2.ui.widgets.panels.defaultpanel import DefaultPanel
+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
@@ -32,7 +32,7 @@ MODEL_TYPE_ITEM_NAMES = ['tensorflow', 'pytorch']
 MODEL_VERSION_ITEM_NAMES = ['1.0', '2.2']
 
 
-class DefaultPipelinePanel(DefaultPanel):
+class DefaultPipelinePanel(PipelinePanel):
     def __init__(self):
         super(DefaultPipelinePanel, self).__init__()
         self.set_title(PANEL_TITLE)

mosamatic2-2.0.6/src/mosamatic2/ui/widgets/panels/pipelines/pipelinepanel.py

@@ -0,0 +1,6 @@
+from mosamatic2.ui.widgets.panels.defaultpanel import DefaultPanel
+
+
+class PipelinePanel(DefaultPanel):
+    def __init__(self):
+        super(PipelinePanel, self).__init__()

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/src/mosamatic2/ui/widgets/panels/tasks/calculatescorestaskpanel.py

@@ -17,7 +17,7 @@ from PySide6.QtCore import (
 )
 
 from mosamatic2.core.managers.logmanager import LogManager
-from mosamatic2.ui.widgets.panels.taskpanel import TaskPanel
+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

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/src/mosamatic2/ui/widgets/panels/tasks/createpngsfromsegmentationstaskpanel.py

@@ -17,7 +17,7 @@ from PySide6.QtCore import (
 )
 
 from mosamatic2.core.managers.logmanager import LogManager
-from mosamatic2.ui.widgets.panels.taskpanel import TaskPanel
+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

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/src/mosamatic2/ui/widgets/panels/tasks/dicom2niftitaskpanel.py

@@ -17,7 +17,7 @@ from PySide6.QtCore import (
 )
 
 from mosamatic2.core.managers.logmanager import LogManager
-from mosamatic2.ui.widgets.panels.taskpanel import TaskPanel
+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

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/src/mosamatic2/ui/widgets/panels/tasks/rescaledicomimagestaskpanel.py

@@ -17,7 +17,7 @@ from PySide6.QtCore import (
 )
 
 from mosamatic2.core.managers.logmanager import LogManager
-from mosamatic2.ui.widgets.panels.taskpanel import TaskPanel
+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

{mosamatic2-2.0.4 → mosamatic2-2.0.6}/src/mosamatic2/ui/widgets/panels/tasks/segmentmusclefatl3tensorflowtaskpanel.py

@@ -16,7 +16,7 @@ from PySide6.QtCore import (
 )
 
 from mosamatic2.core.managers.logmanager import LogManager
-from mosamatic2.ui.widgets.panels.taskpanel import TaskPanel
+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

mosamatic2-2.0.4/src/mosamatic2/ui/widgets/panels/tasks/selectslicefromscantaskpanel.py → mosamatic2-2.0.6/src/mosamatic2/ui/widgets/panels/tasks/selectslicefromscanstaskpanel.py

@@ -3,7 +3,7 @@ import os
 from PySide6.QtWidgets import (
     QLineEdit,
     QCheckBox,
-    QSpinBox,
+    QComboBox,
     QHBoxLayout,
     QVBoxLayout,
     QFormLayout,
@@ -16,26 +16,26 @@ from PySide6.QtCore import (
     Slot,
 )
 
-from mosamaticdesktop.core.utils.logmanager import LogManager
-from mosamaticdesktop.ui.panels.taskpanel import TaskPanel
-from mosamaticdesktop.ui.settings import Settings
-from mosamaticdesktop.ui.utils import is_macos
-from mosamaticdesktop.ui.worker import Worker
-
-from mosamatic.tasks import SelectSliceFromScanTask
+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 SelectSliceFromScansTask
 
 LOG = LogManager()
 
-PANEL_TITLE = 'Automatically select L3 or T4 slice from full CT scan'
-PANEL_NAME = 'selectslicefromscantaskpanel'
+PANEL_TITLE = 'Automatically select L3 slice from full CT scan'
+PANEL_NAME = 'selectslicefromscanstaskpanel'
 
 
-class SelectSliceFromScanTaskPanel(TaskPanel):
+class SelectSliceFromScansTaskPanel(TaskPanel):
     def __init__(self):
-        super(SelectSliceFromScanTaskPanel, self).__init__()
+        super(SelectSliceFromScansTaskPanel, self).__init__()
         self.set_title(PANEL_TITLE)
         self._scans_dir_line_edit = None
         self._scans_dir_select_button = None
+        self._vertebra_combobox = None
         self._output_dir_line_edit = None
         self._output_dir_select_button = None
         self._overwrite_checkbox = None
@@ -58,6 +58,13 @@ class SelectSliceFromScanTaskPanel(TaskPanel):
             self._scans_dir_select_button.clicked.connect(self.handle_scans_dir_select_button)
         return self._scans_dir_select_button
     
+    def vertebra_combobox(self):
+        if not self._vertebra_combobox:
+            self._vertebra_combobox = QComboBox()
+            self._vertebra_combobox.addItems(['L3'])
+            self._vertebra_combobox.setCurrentText(self.settings().get(f'{PANEL_NAME}/vertebra'))
+        return self._vertebra_combobox
+    
     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'))
@@ -101,6 +108,7 @@ class SelectSliceFromScanTaskPanel(TaskPanel):
         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('Vertebra', self.vertebra_combobox())
         self.form_layout().addRow('Output directory', output_dir_layout)
         self.form_layout().addRow('Overwrite', self.overwrite_checkbox())
         layout = QVBoxLayout()
@@ -134,11 +142,11 @@ class SelectSliceFromScanTaskPanel(TaskPanel):
             LOG.info('Running task...')
             self.run_task_button().setEnabled(False)
             self.save_inputs_and_parameters()
-            self._task = SelectSliceFromScanTask(
-                self.scans_dir_line_edit().text(), 
-                self.output_dir_line_edit().text(), 
-                'vertebrae_L3',
-                self.overwrite_checkbox().isChecked()
+            self._task = SelectSliceFromScansTask(
+                inputs={'scans': self.scans_dir_line_edit().text()},
+                params={'vertebra': 'L3'},
+                output=self.output_dir_line_edit().text(),
+                overwrite=self.overwrite_checkbox().isChecked(),
             )
             self._worker = Worker(self._task)
             self._thread = QThread()
@@ -180,5 +188,6 @@ class SelectSliceFromScanTaskPanel(TaskPanel):
     
     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}/vertebra', self.vertebra_combobox().currentText())
         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.6/src/mosamatic2/ui/widgets/panels/visualizations/slicevisualization/custominteractorstyle.py

@@ -0,0 +1,62 @@
+import vtk
+
+
+class CustomInteractorStyle(vtk.vtkInteractorStyleImage):
+    def __init__(self, image_data, slice_mapper, status_actor, slice_obj, orientation="axial"):
+        super(CustomInteractorStyle, self).__init__()
+        self.AddObserver("MouseWheelForwardEvent", self.move_slice_forward)
+        self.AddObserver("MouseWheelBackwardEvent", self.move_slice_backward)
+        self.AddObserver("MouseMoveEvent", self.update_overlay, 1.0)
+        self.AddObserver("KeyPressEvent", self.key_press_event)
+
+        self.image_data = image_data
+        self.slice_mapper = slice_mapper
+        self.status_actor = status_actor
+        self.slice_obj = slice_obj
+        self.orientation = orientation
+
+        xmin, xmax, ymin, ymax, zmin, zmax = image_data.GetExtent()
+        if orientation == "axial":
+            self.min_slice, self.max_slice = zmin, zmax
+        elif orientation == "sagittal":
+            self.min_slice, self.max_slice = xmin, xmax
+        elif orientation == "coronal":
+            self.min_slice, self.max_slice = ymin, ymax
+        else:
+            raise ValueError(f"Unknown orientation: {orientation}")
+
+        self.slice = (self.min_slice + self.max_slice) // 2
+        self.slice_mapper.SetSliceNumber(self.slice)
+        self.update_status_message()
+
+    def update_status_message(self):
+        window = int(self.slice_obj.GetProperty().GetColorWindow())
+        level = int(self.slice_obj.GetProperty().GetColorLevel())
+        message = f'Slice {self.slice + 1}/{self.max_slice + 1} | W: {window} L: {level}'
+        self.status_actor.GetMapper().SetInput(message)
+
+    def move_slice_forward(self, obj, event):
+        if self.slice < self.max_slice:
+            self.slice += 1
+            self.slice_mapper.SetSliceNumber(self.slice)
+            self.update_status_message()
+            self.GetInteractor().GetRenderWindow().Render()
+
+    def move_slice_backward(self, obj, event):
+        if self.slice > self.min_slice:
+            self.slice -= 1
+            self.slice_mapper.SetSliceNumber(self.slice)
+            self.update_status_message()
+            self.GetInteractor().GetRenderWindow().Render()
+
+    def key_press_event(self, obj, event):
+        key = self.GetInteractor().GetKeySym()
+        if key == "Up":
+            self.move_slice_forward(obj, event)
+        elif key == "Down":
+            self.move_slice_backward(obj, event)
+
+    def update_overlay(self, obj, event):
+        super(CustomInteractorStyle, self).OnMouseMove()
+        self.update_status_message()
+        self.GetInteractor().GetRenderWindow().Render()

mosamatic2-2.0.6/src/mosamatic2/ui/widgets/panels/visualizations/slicevisualization/sliceviewer.py

@@ -0,0 +1,98 @@
+import os
+import vtk
+import pydicom
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QMessageBox
+from mosamatic2.ui.widgets.panels.visualizations.slicevisualization.custominteractorstyle import CustomInteractorStyle
+from vtkmodules.qt.QVTKRenderWindowInteractor import QVTKRenderWindowInteractor
+
+COLOR_WINDOW = 400
+COLOR_LEVEL = 40
+IMAGE_SHIFT_SCALE = -1000
+
+
+class SliceViewer(QWidget):
+    def __init__(self):
+        super(SliceViewer, self).__init__()
+        self._nifti_file_or_dicom_dir = None
+        self._view_orientation = 'axial'
+        self._vtk_widget = QVTKRenderWindowInteractor(self)
+        self._render_window = self._vtk_widget.GetRenderWindow()
+        self._interactor = self._render_window.GetInteractor()
+        self._interactor_style = None
+        layout = QVBoxLayout()
+        layout.addWidget(self._vtk_widget)
+        self.setLayout(layout)
+        self._default_renderer = vtk.vtkRenderer()
+        self._default_renderer.SetBackground(0.0, 0.0, 0.0)  # black
+        self._render_window.AddRenderer(self._default_renderer)
+        self._render_window.Render()
+
+    def nifti_file_or_dicom_dir(self):
+        return self._nifti_file_or_dicom_dir
+    
+    def set_nifti_file_or_dicom_dir(self, nifti_file_or_dicom_dir):
+        self._nifti_file_or_dicom_dir = nifti_file_or_dicom_dir
+
+    def create_text_actor(self, text, x, y, font_size, align_bottom=False, normalized=False):
+        text_prop = vtk.vtkTextProperty()
+        text_prop.SetFontFamilyToCourier()
+        text_prop.SetFontSize(font_size)
+        text_prop.SetVerticalJustificationToBottom() if align_bottom else text_prop.SetVerticalJustificationToTop()
+        text_prop.SetJustificationToLeft()
+        text_mapper = vtk.vtkTextMapper()
+        text_mapper.SetInput(text)
+        text_mapper.SetTextProperty(text_prop)
+        text_actor = vtk.vtkActor2D()
+        text_actor.SetMapper(text_mapper)
+        if normalized:
+            text_actor.GetPositionCoordinate().SetCoordinateSystemToNormalizedDisplay()
+        text_actor.SetPosition(x, y)
+        return text_actor
+    
+    def is_nifti_file(self, file_path):
+        return file_path.endswith('.nii') or file_path.endswith('.nii.gz')
+    
+    def is_dicom_dir(self, dir_path):
+        first_dicom_file = os.path.join(dir_path, os.listdir(dir_path)[0])
+        return pydicom.dcmread(first_dicom_file, stop_before_pixels=True)
+
+    def load_image(self):
+        if not self.nifti_file_or_dicom_dir():
+            QMessageBox.warning(self, 'Warning', 'No NIFTI file or DICOM directory set')
+            return
+        if self.is_nifti_file(self.nifti_file_or_dicom_dir()):
+            reader = vtk.vtkNIFTIImageReader()
+            reader.SetFileName(self.nifti_file_or_dicom_dir())
+        elif self.is_dicom_dir(self.nifti_file_or_dicom_dir()):
+            reader = vtk.vtkDICOMImageReader()
+            reader.SetDirectoryName(self.nifti_file_or_dicom_dir())
+        reader.Update()
+        image_data = reader.GetOutput()
+        xmin, xmax, ymin, ymax, zmin, zmax = image_data.GetExtent()
+        axial_index = (zmin + zmax) // 2
+        slice_mapper = vtk.vtkImageSliceMapper()
+        slice_mapper.SetInputData(image_data)
+        slice_mapper.SetOrientationToZ()  # axial orientation
+        slice_mapper.SetSliceNumber(axial_index)
+        slice = vtk.vtkImageSlice()
+        slice.GetProperty().SetColorWindow(400)
+        slice.GetProperty().SetColorLevel(40)
+        slice.SetMapper(slice_mapper)
+        slice_text_actor = self.create_text_actor("", 0.01, 0.01, 12, align_bottom=True, normalized=True)
+        usage_text_actor = self.create_text_actor(
+            "- Slice with mouse wheel or Up/Down-Key (first click inside viewer)\n"
+            "- Zoom with pressed right mouse button while dragging\n"
+            "- Pan with middle mouse button while dragging\n"
+            "- Change contrast/brightness with pressed left mouse while dragging",
+            0.01, 0.99, 12, normalized=True)
+        ren = vtk.vtkRenderer()
+        ren.AddActor2D(slice_text_actor)
+        ren.AddActor2D(usage_text_actor)
+        ren.AddViewProp(slice)
+        ren.ResetCamera()
+        self._render_window.RemoveRenderer(self._default_renderer)
+        self._render_window.AddRenderer(ren)
+        self._interactor_style = CustomInteractorStyle(image_data, slice_mapper, slice_text_actor, slice)
+        self._interactor.SetInteractorStyle(self._interactor_style)
+        self._interactor.Initialize()
+        self._render_window.Render()

mosamatic2-2.0.6/src/mosamatic2/ui/widgets/panels/visualizations/slicevisualization/slicevisualization.py

@@ -0,0 +1,106 @@
+from PySide6.QtWidgets import (
+    QLineEdit,
+    QHBoxLayout,
+    QVBoxLayout,
+    QFormLayout,
+    QPushButton,
+    QFileDialog,
+)
+from mosamatic2.ui.widgets.panels.visualizations.visualization import Visualization
+from mosamatic2.ui.widgets.panels.visualizations.slicevisualization.sliceviewer import SliceViewer
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.ui.settings import Settings
+from mosamatic2.ui.utils import is_macos
+
+LOG = LogManager()
+PANEL_TITLE = 'SliceVisualization'
+PANEL_NAME = 'slicevisualization'
+
+
+class SliceVisualization(Visualization):
+    def __init__(self):
+        super(SliceVisualization, self).__init__()
+        self.set_title(PANEL_TITLE)
+        self._image_line_edit = None
+        self._image_select_button = None
+        self._image_dir_select_button = None
+        self._load_image_button = None
+        self._slice_viewer = None
+        self._form_layout = None
+        self._settings = None
+        self.init_layout()
+
+    def image_line_edit(self):
+        if not self._image_line_edit:
+            self._image_line_edit = QLineEdit(self.settings().get(f'{PANEL_NAME}/image'))
+        return self._image_line_edit
+    
+    def image_select_button(self):
+        if not self._image_select_button:
+            self._image_select_button = QPushButton('Select Image')
+            self._image_select_button.clicked.connect(self.handle_image_select_button)
+        return self._image_select_button
+    
+    def image_dir_select_button(self):
+        if not self._image_dir_select_button:
+            self._image_dir_select_button = QPushButton('Select Directory')
+            self._image_dir_select_button.clicked.connect(self.handle_image_dir_select_button)
+        return self._image_dir_select_button
+    
+    def load_image_button(self):
+        if not self._load_image_button:
+            self._load_image_button = QPushButton('Load')
+            self._load_image_button.clicked.connect(self.handle_load_image_button)
+        return self._load_image_button
+    
+    def slice_viewer(self):
+        if not self._slice_viewer:
+            self._slice_viewer = SliceViewer()
+        return self._slice_viewer
+
+    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 settings(self):
+        if not self._settings:
+            self._settings = Settings()
+        return self._settings
+
+    def init_layout(self):
+        image_layout = QHBoxLayout()
+        image_layout.addWidget(self.image_line_edit())
+        image_layout.addWidget(self.image_select_button())
+        image_layout.addWidget(self.image_dir_select_button())
+        self.form_layout().addRow('NIFTI file or DICOM directory', image_layout)
+        layout = QVBoxLayout()
+        layout.addLayout(self.form_layout())
+        layout.addWidget(self.load_image_button())
+        layout.addWidget(self.slice_viewer())
+        self.setLayout(layout)
+        self.setObjectName(PANEL_NAME)
+
+    def handle_image_select_button(self):
+        last_directory = self.settings().get('last_directory')
+        file_path, _ = QFileDialog.getOpenFileName(dir=last_directory)
+        if file_path:
+            self.image_line_edit().setText(file_path)
+            self.settings().set('last_directory', file_path)
+
+    def handle_image_dir_select_button(self):
+        last_directory = self.settings().get('last_directory')
+        dir_path = QFileDialog.getExistingDirectory(dir=last_directory)
+        if dir_path:
+            self.image_line_edit().setText(dir_path)
+            self.settings().set('last_directory', dir_path)
+
+    def handle_load_image_button(self):
+        self.slice_viewer().set_nifti_file_or_dicom_dir(self.image_line_edit().text())
+        # self.slice_viewer().set_view_orientation('axial')
+        self.slice_viewer().load_image()
+
+    def save_inputs_and_parameters(self):
+        self.settings().set(f'{PANEL_NAME}/image', self.image_line_edit().text())

mosamatic2-2.0.6/src/mosamatic2/ui/widgets/panels/visualizations/visualization.py

@@ -0,0 +1,6 @@
+from mosamatic2.ui.widgets.panels.defaultpanel import DefaultPanel
+
+
+class Visualization(DefaultPanel):
+    def __init__(self):
+        super(Visualization, self).__init__()

mosamatic2-2.0.4/src/mosamatic2/ui/resources/VERSION

@@ -1 +0,0 @@
-2.0.4