mosamatic2 2.0.10__tar.gz → 2.0.12__tar.gz

{mosamatic2-2.0.10 → mosamatic2-2.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mosamatic2
-Version: 2.0.10
+Version: 2.0.12
 Summary: 
 Author: Ralph Brecheisen
 Author-email: r.brecheisen@maastrichtuniversity.nl

{mosamatic2-2.0.10 → mosamatic2-2.0.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mosamatic2"
-version = "2.0.10"
+version = "2.0.12"
 description = ""
 authors = [
     {name = "Ralph Brecheisen", email = "r.brecheisen@maastrichtuniversity.nl"}

{mosamatic2-2.0.10 → mosamatic2-2.0.12}/src/mosamatic2/commands/dicom2nifti.py

@@ -3,12 +3,12 @@ import click
 from mosamatic2.core.tasks import Dicom2NiftiTask
 
 
-@click.command(help='Converts DICOM series to NIFTI')
+@click.command(help='Converts root directory with DICOM series to NIFTI format')
 @click.option(
-    '--images', 
+    '--scans', 
     required=True, 
     type=click.Path(exists=True), 
-    help='Directory with images',
+    help='Root directory with DICOM scans (one for each patient)',
 )
 @click.option(
     '--output', 
@@ -22,14 +22,14 @@ from mosamatic2.core.tasks import Dicom2NiftiTask
     default=False, 
     help='Overwrite [true|false]'
 )
-def dicom2nifti(images, output, overwrite):
+def dicom2nifti(scans, output, overwrite):
     """
-    Converts single DICOM series (scan) to NIFTI
+    Converts DICOM scans to NIFTI format.
     
     Parameters
     ----------
-    --images : str
-        Directory with DICOM images of a single series
+    --scans : str
+        Root directory with DICOM scans (one subdirectory for each patient)
 
     --output : str
         Path to output directory
@@ -38,7 +38,7 @@ def dicom2nifti(images, output, overwrite):
         Overwrite contents output directory [true|false]
     """
     task = Dicom2NiftiTask(
-        inputs={'images': images},
+        inputs={'scans': scans},
         params=None,
         output=output,
         overwrite=overwrite,

mosamatic2-2.0.12/src/mosamatic2/core/data/multiniftiimage.py

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

{mosamatic2-2.0.10 → mosamatic2-2.0.12}/src/mosamatic2/core/data/multinumpyimage.py

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

mosamatic2-2.0.12/src/mosamatic2/core/data/niftiimage.py

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

{mosamatic2-2.0.10 → mosamatic2-2.0.12}/src/mosamatic2/core/data/numpyimage.py

@@ -4,7 +4,7 @@ from mosamatic2.core.utils import (
     load_numpy_array,
 )
 
-class NumPyImage(FileData):
+class NumpyImage(FileData):
     def load(self):
         if self.path():
             if is_numpy(self.path()):

mosamatic2-2.0.12/src/mosamatic2/core/pipelines/__init__.py

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

mosamatic2-2.0.12/src/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-2.0.10 → mosamatic2-2.0.12}/src/mosamatic2/core/tasks/calculatescorestask/calculatescorestask.py

@@ -4,7 +4,7 @@ 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.data.numpyimage import NumpyImage
 from mosamatic2.core.utils import (
     get_pixels_from_dicom_object,
     calculate_area,
@@ -74,7 +74,7 @@ class CalculateScoresTask(Task):
 
     def load_segmentation(self, f, file_type='npy'):
         if file_type == 'npy':
-            segmentation = NumPyImage()
+            segmentation = NumpyImage()
             segmentation.set_path(f)
             if segmentation.load():
                 return segmentation.object()

mosamatic2-2.0.12/src/mosamatic2/core/tasks/dicom2niftitask/dicom2niftitask.py

@@ -0,0 +1,38 @@
+import os
+import dicom2nifti
+from mosamatic2.core.tasks.task import Task
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.core.utils import is_dicom
+
+LOG = LogManager()
+
+
+class Dicom2NiftiTask(Task):
+    INPUTS = ['scans']
+    PARAMS = []
+
+    def __init__(self, inputs, params, output, overwrite):
+        super(Dicom2NiftiTask, 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 run(self):
+        scan_dirs = self.load_scan_dirs()
+        nr_steps = len(scan_dirs)
+        for step in range(nr_steps):
+            scan_dir = scan_dirs[step]
+            scan_name = os.path.split(scan_dir)[1]
+            nifti_file_name = scan_name + '.nii.gz'
+            LOG.info(f'Converting DICOM series in {scan_dir} to {nifti_file_name}')
+            dicom2nifti.dicom_series_to_nifti(
+                scan_dir,
+                os.path.join(self.output(), nifti_file_name),
+                reorient_nifti=True,
+            )
+            self.set_progress(step, nr_steps)

{mosamatic2-2.0.10 → mosamatic2-2.0.12}/src/mosamatic2/core/tasks/segmentmusclefatl3tensorflowtask/segmentmusclefatl3tensorflowtask.py

@@ -9,6 +9,7 @@ from mosamatic2.core.tasks.task import Task
 from mosamatic2.core.tasks.segmentmusclefatl3tensorflowtask.paramloader import ParamLoader
 from mosamatic2.core.data.multidicomimage import MultiDicomImage
 from mosamatic2.core.data.dicomimage import DicomImage
+from mosamatic2.core.managers.logmanager import LogManager
 from mosamatic2.core.utils import (
     normalize_between,
     get_pixels_from_dicom_object,
@@ -16,6 +17,8 @@ from mosamatic2.core.utils import (
 )
 
 DEVICE = 'cpu'
+L3_INDEX = 167
+LOG = LogManager()
 
 
 class SegmentMuscleFatL3TensorFlowTask(Task):

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

@@ -0,0 +1,162 @@
+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)
+        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\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 = []
+        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)
+        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):
+        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:
+            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)
+            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')
+        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))
+        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:
+            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
+        if closest_file is None:
+            self.write_error(f"{scan_dir}: No matching slice found.")
+        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]
+            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-2.0.10 → mosamatic2-2.0.12}/src/mosamatic2/core/utils.py

@@ -5,6 +5,7 @@ import textwrap
 import math
 import pendulum
 import numpy as np
+import nibabel as nb
 import struct
 import binascii
 import pydicom
@@ -134,6 +135,16 @@ def is_jpeg2000_compressed(p):
     return False
 
 
+def is_nifti(f):
+    return f.endswith('.nii') or f.endswith('.nii.gz')
+
+
+def load_nifti(f):
+    if is_nifti(f):
+        return nb.load(f)
+    return None
+
+
 def is_numpy_array(value):
     return isinstance(value, np.array)
 
@@ -149,8 +160,7 @@ def is_numpy(f):
 def load_numpy_array(f):
     if is_numpy(f):
         return np.load(f)
-    else:
-        return None
+    return None
 
 
 def get_pixels_from_tag_file(tag_file_path):

{mosamatic2-2.0.10 → mosamatic2-2.0.12}/src/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-2.0.12/src/mosamatic2/ui/resources/VERSION

@@ -0,0 +1 @@
+2.0.12