mosamatic2 2.0.24__py3-none-any.whl

mosamatic2/ui/widgets/panels/visualizations/liversegmentvisualization/liversegmentvisualization.py

@@ -0,0 +1,120 @@
+import os
+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.liversegmentvisualization.liversegmentviewer import LiverSegmentViewer
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.ui.settings import Settings
+from mosamatic2.ui.utils import is_macos
+
+LOG = LogManager()
+PANEL_TITLE = 'LiverSegmentVisualization'
+PANEL_NAME = 'liversegmentvisualization'
+
+
+class LiverSegmentVisualization(Visualization):
+    def __init__(self):
+        super(LiverSegmentVisualization, self).__init__()
+        self.set_title(PANEL_TITLE)
+        self._liver_segment_actors = {}
+        self._liver_volumes = {}
+        self._liver_segments_dir_line_edit = None
+        self._liver_segments_dir_select_button = None
+        self._liver_volumes_file_line_edit = None
+        self._liver_volumes_file_select_button = None
+        self._load_liver_data_button = None
+        self._liver_segment_viewer = None
+        self._form_layout = None
+        self._settings = None
+        self.init_layout()
+
+    def liver_segments_dir_line_edit(self):
+        if not self._liver_segments_dir_line_edit:
+            self._liver_segments_dir_line_edit = QLineEdit(self.settings().get(f'{PANEL_NAME}/liver_segments_dir'))
+        return self._liver_segments_dir_line_edit
+    
+    def liver_segments_dir_select_button(self):
+        if not self._liver_segments_dir_select_button:
+            self._liver_segments_dir_select_button = QPushButton('Select directory')
+            self._liver_segments_dir_select_button.clicked.connect(self.handle_liver_segments_dir_select_button)
+        return self._liver_segments_dir_select_button
+    
+    def liver_volumes_file_line_edit(self):
+        if not self._liver_volumes_file_line_edit:
+            self._liver_volumes_file_line_edit = QLineEdit(self.settings().get(f'{PANEL_NAME}/liver_volumes_file'))
+        return self._liver_volumes_file_line_edit
+    
+    def liver_volumes_file_select_button(self):
+        if not self._liver_volumes_file_select_button:
+            self._liver_volumes_file_select_button = QPushButton('Select file')
+            self._liver_volumes_file_select_button.clicked.connect(self.handle_liver_volumes_file_select_button)
+        return self._liver_volumes_file_select_button
+    
+    def load_liver_data_button(self):
+        if not self._load_liver_data_button:
+            self._load_liver_data_button = QPushButton('Load')
+            self._load_liver_data_button.clicked.connect(self.handle_load_liver_data_button)
+        return self._load_liver_data_button    
+    
+    def liver_segment_viewer(self):
+        if not self._liver_segment_viewer:
+            self._liver_segment_viewer = LiverSegmentViewer()
+        return self._liver_segment_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):
+        liver_segments_layout = QHBoxLayout()
+        liver_segments_layout.addWidget(self.liver_segments_dir_line_edit())
+        liver_segments_layout.addWidget(self.liver_segments_dir_select_button())
+        self.form_layout().addRow('Liver segments directory', liver_segments_layout)
+        liver_volumes_layout = QHBoxLayout()
+        liver_volumes_layout.addWidget(self.liver_volumes_file_line_edit())
+        liver_volumes_layout.addWidget(self.liver_volumes_file_select_button())
+        self.form_layout().addRow('Liver volumes file', liver_volumes_layout)
+        layout = QVBoxLayout()
+        layout.addLayout(self.form_layout())
+        layout.addWidget(self.load_liver_data_button())
+        layout.addWidget(self.liver_segment_viewer())
+        self.setLayout(layout)
+        self.setObjectName(PANEL_NAME)
+
+    def handle_liver_segments_dir_select_button(self):
+        last_directory = self.settings().get('last_directory')
+        dir_path = QFileDialog.getExistingDirectory(dir=last_directory)
+        if dir_path:
+            self.liver_segments_dir_line_edit().setText(dir_path)
+            self.settings().set('last_directory', dir_path)
+
+    def handle_liver_volumes_file_select_button(self):
+        last_directory = self.settings().get('last_directory')
+        file_path, _ = QFileDialog.getOpenFileName(dir=last_directory)
+        if file_path:
+            self.liver_volumes_file_line_edit().setText(file_path)
+            self.settings().set('last_directory', os.path.dirname(file_path))
+
+    def handle_load_liver_data_button(self):
+        self.liver_segment_viewer().load_segments_and_volumes(
+            liver_segments_dir=self.liver_segments_dir_line_edit().text(),
+            liver_volumes_file=self.liver_volumes_file_line_edit().text(),
+        )
+
+    def save_inputs_and_parameters(self):
+        self.settings().set(f'{PANEL_NAME}/liver_segments_dir', self.liver_segments_dir_line_edit().text())
+        self.settings().set(f'{PANEL_NAME}/liver_volumes_file', self.liver_volumes_file_line_edit().text())

mosamatic2/ui/widgets/panels/visualizations/sliceselectionvisualization/sliceselectionviewer.py

@@ -0,0 +1,61 @@
+import os
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QMessageBox, QScrollArea, QGridLayout
+from PySide6.QtCore import Qt, Signal, QSize
+from mosamatic2.ui.widgets.panels.visualizations.sliceselectionvisualization.slicetile import SliceTile
+from mosamatic2.ui.widgets.panels.visualizations.sliceselectionvisualization.slicetile import SliceItem
+
+# https://chatgpt.com/c/69494292-b8fc-8327-863f-438838247bd4
+
+
+class SliceSelectionViewer(QWidget):
+    selection_changed = Signal()
+
+    def __init__(self, columns: int = 4, tile_size: QSize = QSize(220, 220), parent=None):
+        super(SliceSelectionViewer, self).__init__()
+        self._columns = columns
+        self._tile_size = tile_size
+        self._tiles: list[SliceTile] = []
+        self._scroll_area = QScrollArea()
+        self._scroll_area.setWidgetResizable(True)
+        self._container = QWidget()
+        self._grid = QGridLayout(self._container)
+        self._grid.setContentsMargins(10, 10, 10, 10)
+        self._grid.setSpacing(10)
+        self._scroll_area.setWidget(self._container)
+        self._root = QVBoxLayout(self)
+        self._root.addWidget(self._scroll_area)
+
+    def clear(self):
+        # remove widgets from layout
+        while self._grid.count():
+            item = self._grid.takeAt(0)
+            w = item.widget()
+            if w:
+                w.setParent(None)
+        self._tiles.clear()
+
+    def load_images(self, images_dir):
+        images = []
+        for f in os.listdir(images_dir):
+            if f.endswith('_sagittal.png'):
+                f_path = os.path.join(images_dir, f)
+                images.append(f_path)
+        self.clear()
+        for i, p in enumerate(images):
+            tile = SliceTile(SliceItem(p), self._tile_size)
+            tile.toggled.connect(self._on_tile_toggled)
+            self._tiles.append(tile)
+            r, c = divmod(i, self._columns)
+            self._grid.addWidget(tile, r, c)
+        # Optional: keep grid left-aligned by adding stretch
+        self._grid.setColumnStretch(self._columns, 1)
+
+    def selected_paths(self) -> list[str]:
+        return [t.item.path for t in self._tiles if t.is_checked()]
+    
+    def set_all_checked(self, checked: bool):
+        for t in self._tiles:
+            t.set_checked(checked)
+
+    def _on_tile_toggled(self, _path: str, _checked: bool):
+        self.selection_changed.emit()

mosamatic2/ui/widgets/panels/visualizations/sliceselectionvisualization/sliceselectionvisualization.py

@@ -0,0 +1,133 @@
+import shutil
+from PySide6.QtWidgets import (
+    QLineEdit,
+    QLabel,
+    QSpinBox,
+    QHBoxLayout,
+    QVBoxLayout,
+    QFormLayout,
+    QPushButton,
+    QFileDialog,
+)
+from mosamatic2.ui.widgets.panels.visualizations.visualization import Visualization
+from mosamatic2.ui.widgets.panels.visualizations.sliceselectionvisualization.sliceselectionviewer import SliceSelectionViewer
+from mosamatic2.core.managers.logmanager import LogManager
+from mosamatic2.ui.settings import Settings
+from mosamatic2.ui.utils import is_macos
+
+LOG = LogManager()
+PANEL_TITLE = 'SliceSelectionVisualization'
+PANEL_NAME = 'sliceselectionvisualization'
+
+
+class SliceSelectionVisualization(Visualization):
+    def __init__(self):
+        super(SliceSelectionVisualization, self).__init__()
+        self.set_title(PANEL_TITLE)
+        self._images_line_edit = None
+        self._images_dir_select_button = None
+        self._output_dir_line_edit = None
+        self._output_dir_select_button = None
+        self._load_images_button = None
+        self._copy_selected_images_button = None
+        self._slice_selection_viewer = None
+        self._form_layout = None
+        self._settings = None
+        self.init_layout()
+
+    def images_line_edit(self):
+        if not self._images_line_edit:
+            self._images_line_edit = QLineEdit(self.settings().get(f'{PANEL_NAME}/images'))
+        return self._images_line_edit
+    
+    def images_dir_select_button(self):
+        if not self._images_dir_select_button:
+            self._images_dir_select_button = QPushButton('Select directory')
+            self._images_dir_select_button.clicked.connect(self.handle_images_dir_select_button)
+        return self._images_dir_select_button
+    
+    def output_dir_line_edit(self):
+        if not self._output_dir_line_edit:
+            self._output_dir_line_edit = QLineEdit(self.settings().get(f'{PANEL_NAME}/output_dir'))
+        return self._output_dir_line_edit
+    
+    def output_dir_select_button(self):
+        if not self._output_dir_select_button:
+            self._output_dir_select_button = QPushButton('Select directory')
+            self._output_dir_select_button.clicked.connect(self.handle_output_dir_select_button)
+        return self._output_dir_select_button
+    
+    def copy_selected_images_button(self):
+        if not self._copy_selected_images_button:
+            self._copy_selected_images_button = QPushButton("Copy selected images to output directory")
+            self._copy_selected_images_button.clicked.connect(self.handle_copy_selected_images_button)
+        return self._copy_selected_images_button
+    
+    def load_images_button(self):
+        if not self._load_images_button:
+            self._load_images_button = QPushButton('Load')
+            self._load_images_button.clicked.connect(self.handle_load_images_button)
+        return self._load_images_button
+    
+    def slice_selection_viewer(self):
+        if not self._slice_selection_viewer:
+            self._slice_selection_viewer = SliceSelectionViewer()
+        return self._slice_selection_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.images_line_edit())
+        image_layout.addWidget(self.images_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('PNG images directory', image_layout)
+        self.form_layout().addRow('Output directory', output_dir_layout)
+        layout = QVBoxLayout()
+        layout.addLayout(self.form_layout())
+        layout.addWidget(self.load_images_button())
+        layout.addWidget(self.copy_selected_images_button())
+        layout.addWidget(self.slice_selection_viewer())
+        self.setLayout(layout)
+        self.setObjectName(PANEL_NAME)
+
+    def handle_images_dir_select_button(self):
+        last_directory = self.settings().get('last_directory')
+        dir_path = QFileDialog.getExistingDirectory(dir=last_directory)
+        if dir_path:
+            self.images_line_edit().setText(dir_path)
+            self.settings().set('last_directory', dir_path)
+
+    def handle_output_dir_select_button(self):
+        last_directory = self.settings().get('last_directory')
+        dir_path = QFileDialog.getExistingDirectory(dir=last_directory)
+        if dir_path:
+            self.output_dir_line_edit().setText(dir_path)
+            self.settings().set('last_directory', dir_path)
+
+    def handle_load_images_button(self):
+        self.slice_selection_viewer().load_images(self.images_line_edit().text())
+
+    def handle_copy_selected_images_button(self):
+        selected_paths = self.slice_selection_viewer().selected_paths()
+        for p in selected_paths:
+            p_dcm = p[:-13] + '.dcm'
+            target_dir = self.output_dir_line_edit().text()
+            LOG.info(f'Copying {p_dcm} to {target_dir}')
+            shutil.copy(p_dcm, target_dir)
+
+    def save_inputs_and_parameters(self):
+        self.settings().set(f'{PANEL_NAME}/images', self.images_line_edit().text())
+        self.settings().set(f'{PANEL_NAME}/output_dir', self.output_dir_line_edit().text())

mosamatic2/ui/widgets/panels/visualizations/sliceselectionvisualization/slicetile.py

@@ -0,0 +1,63 @@
+import os
+from dataclasses import dataclass
+
+from PySide6.QtCore import Qt, Signal, QSize
+from PySide6.QtGui import QPixmap
+from PySide6.QtWidgets import (
+    QApplication, QWidget, QLabel, QCheckBox, QVBoxLayout, QGridLayout,
+    QScrollArea, QMainWindow, QFileDialog, QPushButton, QHBoxLayout
+)
+
+
+@dataclass(frozen=True)
+class SliceItem:
+    path: str
+
+
+class SliceTile(QWidget):
+    toggled = Signal(str, bool)  # path, checked
+
+    def __init__(self, item: SliceItem, display_size: QSize, parent=None):
+        super().__init__(parent)
+        self.item = item
+        self.display_size = display_size
+
+        self.image_label = QLabel()
+        self.image_label.setAlignment(Qt.AlignCenter)
+        self.image_label.setFixedSize(display_size)
+        self.image_label.setStyleSheet("QLabel { background: #222; border: 1px solid #444; }")
+
+        dcm_name = os.path.basename(item.path)[:-13] + '.dcm'
+        self.checkbox = QCheckBox(dcm_name)
+        self.checkbox.setChecked(True)
+        self.checkbox.toggled.connect(self._on_toggled)
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(6, 6, 6, 6)
+        layout.setSpacing(6)
+        layout.addWidget(self.image_label)
+        layout.addWidget(self.checkbox)
+
+        self._load_and_scale()
+
+    def _load_and_scale(self):
+        pix = QPixmap(self.item.path)
+        if pix.isNull():
+            self.image_label.setText("Failed to load")
+            return
+
+        scaled = pix.scaled(
+            self.display_size,
+            Qt.KeepAspectRatio,
+            Qt.SmoothTransformation
+        )
+        self.image_label.setPixmap(scaled)
+
+    def _on_toggled(self, checked: bool):
+        self.toggled.emit(self.item.path, checked)
+
+    def is_checked(self) -> bool:
+        return self.checkbox.isChecked()
+
+    def set_checked(self, checked: bool):
+        self.checkbox.setChecked(checked)

mosamatic2/ui/widgets/panels/visualizations/slicevisualization/custominteractorstyle.py

@@ -0,0 +1,80 @@
+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
+        self._color_window = 0
+        self._color_level = 0
+
+        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 color_window(self):
+        return self._color_window
+
+    def set_color_window(self, color_window):
+        self._color_window = color_window
+        self.slice_obj.GetProperty().SetColorWindow(self._color_window)
+        self.GetInteractor().GetRenderWindow().Render()
+
+    def color_level(self):
+        return self._color_level
+
+    def set_color_level(self, color_level):
+        self._color_level = color_level
+        self.slice_obj.GetProperty().SetColorLevel(self._color_level)
+        self.GetInteractor().GetRenderWindow().Render()
+
+    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/ui/widgets/panels/visualizations/slicevisualization/sliceviewer.py

@@ -0,0 +1,116 @@
+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, color_window=COLOR_WINDOW, color_level=COLOR_LEVEL):
+        super(SliceViewer, self).__init__()
+        self._nifti_file_or_dicom_dir = None
+        self._view_orientation = 'axial'
+        self._color_window = color_window
+        self._color_level = color_level
+        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 color_window(self):
+        return self._color_window
+
+    def set_color_window(self, color_window):
+        self._color_window = color_window
+        if self._interactor_style:
+            self._interactor_style.set_color_window(self._color_window)
+
+    def color_level(self):
+        return self._color_level
+
+    def set_color_level(self, color_level):
+        self._color_level = color_level
+        if self._interactor_style:
+            self._interactor_style.set_color_level(self._color_level)
+
+    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(self.color_window())
+        slice.GetProperty().SetColorLevel(self.color_level())
+        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 keys (first click inside viewer)\n"
+            "- Zoom with pressed right mouse button while dragging\n"
+            "- Pan with Shift key and left 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()