celldetective 1.5.0b8__py3-none-any.whl → 1.5.0b9__py3-none-any.whl

celldetective/gui/tableUI.py

@@ -21,8 +21,13 @@ from celldetective.gui.gui_utils import (
 )
 from celldetective.gui.base.figure_canvas import FigureCanvas
 from celldetective.gui.base.utils import center_window
-from celldetective.gui.table_ops._maths import DifferentiateColWidget, OperationOnColsWidget, CalibrateColWidget, \
-    AbsColWidget, LogColWidget
+from celldetective.gui.table_ops._maths import (
+    DifferentiateColWidget,
+    OperationOnColsWidget,
+    CalibrateColWidget,
+    AbsColWidget,
+    LogColWidget,
+)
 from celldetective.gui.table_ops._merge_one_hot import MergeOneHotWidget
 from celldetective.gui.table_ops._query_table import QueryWidget
 from celldetective.gui.table_ops._rename_col import RenameColWidget
@@ -55,7 +60,7 @@ class PivotTableUI(CelldetectiveWidget):
         self.mode = mode
 
         self.setWindowTitle(title)
-        print("tab to show: ", self.data)
+        logger.debug(f"Pivot table to show: {self.data.shape}")
 
         self.table = QTableView(self)
 
@@ -219,9 +224,35 @@ class TableUI(CelldetectiveMainWindow):
 
         try:
             self.fig.tight_layout()
-        except:
+        except AttributeError:
+            # fig not yet created
             pass
 
+    def _get_selected_columns(self, max_cols=None):
+        """
+        Get selected column names from the table view.
+
+        Parameters
+        ----------
+        max_cols : int, optional
+            Maximum number of columns to return. Returns all if None.
+
+        Returns
+        -------
+        list
+            List of selected column names.
+        """
+        x = self.table_view.selectedIndexes()
+        col_idx = np.unique(np.array([l.column() for l in x]))
+        cols = np.array(list(self.data.columns))
+        result = []
+        if len(col_idx) > 0:
+            for i in col_idx:
+                result.append(str(cols[i]))
+        if max_cols is not None:
+            return result[:max_cols]
+        return result
+
     def _create_actions(self):
 
         self.save_as = QAction("&Save as...", self)
@@ -540,8 +571,8 @@ class TableUI(CelldetectiveMainWindow):
         self.renameWidget.show()
 
     def save_as_csv_inplace_per_pos(self):
-
-        print("Saving each table in its respective position folder...")
+        """Save each position's table in its respective folder."""
+        logger.info("Saving each table in its respective position folder...")
         for pos, pos_group in self.data.groupby(["position"]):
             invalid_cols = [
                 c for c in list(pos_group.columns) if c.startswith("Unnamed")
@@ -555,26 +586,12 @@ class TableUI(CelldetectiveMainWindow):
                 ),
                 index=False,
             )
-        print("Done...")
+        logger.info("Done saving tables.")
 
     def divide_signals(self):
-
-        x = self.table_view.selectedIndexes()
-        col_idx = np.unique(np.array([l.column() for l in x]))
-        if isinstance(col_idx, (list, np.ndarray)):
-            cols = np.array(list(self.data.columns))
-            if len(col_idx) > 0:
-                selected_col1 = str(cols[col_idx[0]])
-                if len(col_idx) > 1:
-                    selected_col2 = str(cols[col_idx[1]])
-                else:
-                    selected_col2 = None
-            else:
-                selected_col1 = None
-                selected_col2 = None
-        else:
-            selected_col1 = None
-            selected_col2 = None
+        selected = self._get_selected_columns(max_cols=2)
+        selected_col1 = selected[0] if len(selected) > 0 else None
+        selected_col2 = selected[1] if len(selected) > 1 else None
 
         self.divWidget = OperationOnColsWidget(
             self, column1=selected_col1, column2=selected_col2, operation="divide"
@@ -582,23 +599,9 @@ class TableUI(CelldetectiveMainWindow):
         self.divWidget.show()
 
     def multiply_signals(self):
-
-        x = self.table_view.selectedIndexes()
-        col_idx = np.unique(np.array([l.column() for l in x]))
-        if isinstance(col_idx, (list, np.ndarray)):
-            cols = np.array(list(self.data.columns))
-            if len(col_idx) > 0:
-                selected_col1 = str(cols[col_idx[0]])
-                if len(col_idx) > 1:
-                    selected_col2 = str(cols[col_idx[1]])
-                else:
-                    selected_col2 = None
-            else:
-                selected_col1 = None
-                selected_col2 = None
-        else:
-            selected_col1 = None
-            selected_col2 = None
+        selected = self._get_selected_columns(max_cols=2)
+        selected_col1 = selected[0] if len(selected) > 0 else None
+        selected_col2 = selected[1] if len(selected) > 1 else None
 
         self.mulWidget = OperationOnColsWidget(
             self, column1=selected_col1, column2=selected_col2, operation="multiply"
@@ -606,23 +609,9 @@ class TableUI(CelldetectiveMainWindow):
         self.mulWidget.show()
 
     def add_signals(self):
-
-        x = self.table_view.selectedIndexes()
-        col_idx = np.unique(np.array([l.column() for l in x]))
-        if isinstance(col_idx, (list, np.ndarray)):
-            cols = np.array(list(self.data.columns))
-            if len(col_idx) > 0:
-                selected_col1 = str(cols[col_idx[0]])
-                if len(col_idx) > 1:
-                    selected_col2 = str(cols[col_idx[1]])
-                else:
-                    selected_col2 = None
-            else:
-                selected_col1 = None
-                selected_col2 = None
-        else:
-            selected_col1 = None
-            selected_col2 = None
+        selected = self._get_selected_columns(max_cols=2)
+        selected_col1 = selected[0] if len(selected) > 0 else None
+        selected_col2 = selected[1] if len(selected) > 1 else None
 
         self.addiWidget = OperationOnColsWidget(
             self, column1=selected_col1, column2=selected_col2, operation="add"
@@ -630,23 +619,9 @@ class TableUI(CelldetectiveMainWindow):
         self.addiWidget.show()
 
     def subtract_signals(self):
-
-        x = self.table_view.selectedIndexes()
-        col_idx = np.unique(np.array([l.column() for l in x]))
-        if isinstance(col_idx, (list, np.ndarray)):
-            cols = np.array(list(self.data.columns))
-            if len(col_idx) > 0:
-                selected_col1 = str(cols[col_idx[0]])
-                if len(col_idx) > 1:
-                    selected_col2 = str(cols[col_idx[1]])
-                else:
-                    selected_col2 = None
-            else:
-                selected_col1 = None
-                selected_col2 = None
-        else:
-            selected_col1 = None
-            selected_col2 = None
+        selected = self._get_selected_columns(max_cols=2)
+        selected_col1 = selected[0] if len(selected) > 0 else None
+        selected_col2 = selected[1] if len(selected) > 1 else None
 
         self.subWidget = OperationOnColsWidget(
             self, column1=selected_col1, column2=selected_col2, operation="subtract"
@@ -654,56 +629,22 @@ class TableUI(CelldetectiveMainWindow):
         self.subWidget.show()
 
     def differenciate_selected_feature(self):
-
-        # check only one col selected and assert is numerical
-        # open widget to select window parameters, directionality
-        # create new col
-
-        x = self.table_view.selectedIndexes()
-        col_idx = np.unique(np.array([l.column() for l in x]))
-        if isinstance(col_idx, (list, np.ndarray)):
-            cols = np.array(list(self.data.columns))
-            if len(col_idx) > 0:
-                selected_col = str(cols[col_idx[0]])
-            else:
-                selected_col = None
-        else:
-            selected_col = None
-
+        """Open widget to differentiate the selected column."""
+        selected = self._get_selected_columns(max_cols=1)
+        selected_col = selected[0] if selected else None
         self.diffWidget = DifferentiateColWidget(self, selected_col)
         self.diffWidget.show()
 
     def take_log_of_selected_feature(self):
-
-        # check only one col selected and assert is numerical
-        # open widget to select window parameters, directionality
-        # create new col
-
-        x = self.table_view.selectedIndexes()
-        col_idx = np.unique(np.array([l.column() for l in x]))
-        if isinstance(col_idx, (list, np.ndarray)):
-            cols = np.array(list(self.data.columns))
-            if len(col_idx) > 0:
-                selected_col = str(cols[col_idx[0]])
-            else:
-                selected_col = None
-        else:
-            selected_col = None
-
+        """Open widget to take log of the selected column."""
+        selected = self._get_selected_columns(max_cols=1)
+        selected_col = selected[0] if selected else None
         self.LogWidget = LogColWidget(self, selected_col)
         self.LogWidget.show()
 
     def merge_classification_features(self):
-
-        x = self.table_view.selectedIndexes()
-        col_idx = np.unique(np.array([l.column() for l in x]))
-
-        col_selection = []
-        if isinstance(col_idx, (list, np.ndarray)):
-            cols = np.array(list(self.data.columns))
-            if len(col_idx) > 0:
-                selected_cols = cols[col_idx]
-                col_selection.extend(selected_cols)
+        """Open widget to merge selected classification columns."""
+        col_selection = self._get_selected_columns()
 
         # Lazy load MergeGroupWidget
         from celldetective.gui.table_ops._merge_groups import MergeGroupWidget
@@ -712,38 +653,16 @@ class TableUI(CelldetectiveMainWindow):
         self.merge_classification_widget.show()
 
     def calibrate_selected_feature(self):
-
-        x = self.table_view.selectedIndexes()
-        col_idx = np.unique(np.array([l.column() for l in x]))
-        if isinstance(col_idx, (list, np.ndarray)):
-            cols = np.array(list(self.data.columns))
-            if len(col_idx) > 0:
-                selected_col = str(cols[col_idx[0]])
-            else:
-                selected_col = None
-        else:
-            selected_col = None
-
+        """Open widget to calibrate the selected column."""
+        selected = self._get_selected_columns(max_cols=1)
+        selected_col = selected[0] if selected else None
         self.calWidget = CalibrateColWidget(self, selected_col)
         self.calWidget.show()
 
     def take_abs_of_selected_feature(self):
-
-        # check only one col selected and assert is numerical
-        # open widget to select window parameters, directionality
-        # create new col
-
-        x = self.table_view.selectedIndexes()
-        col_idx = np.unique(np.array([l.column() for l in x]))
-        if isinstance(col_idx, (list, np.ndarray)):
-            cols = np.array(list(self.data.columns))
-            if len(col_idx) > 0:
-                selected_col = str(cols[col_idx[0]])
-            else:
-                selected_col = None
-        else:
-            selected_col = None
-
+        """Open widget to take absolute value of the selected column."""
+        selected = self._get_selected_columns(max_cols=1)
+        selected_col = selected[0] if selected else None
         self.absWidget = AbsColWidget(self, selected_col)
         self.absWidget.show()
 
@@ -991,7 +910,8 @@ class TableUI(CelldetectiveMainWindow):
             y = column_names[unique_cols]
             idx = self.y_cb.findText(y)
             self.y_cb.setCurrentIndex(idx)
-        except:
+        except (IndexError, KeyError):
+            # No column selected or invalid selection
             pass
 
         hbox = QHBoxLayout()
@@ -1018,7 +938,8 @@ class TableUI(CelldetectiveMainWindow):
             if hasattr(matplotlib.cm, str(cm).lower()):
                 try:
                     self.cmap_cb.addColormap(cm.lower())
-                except:
+                except Exception:
+                    # Some colormaps may fail to add
                     pass
 
         hbox = QHBoxLayout()
@@ -1057,7 +978,7 @@ class TableUI(CelldetectiveMainWindow):
                 cmap(i / len(self.data[self.hue_variable].unique()))
                 for i in range(len(self.data[self.hue_variable].unique()))
             ]
-        except:
+        except (KeyError, ZeroDivisionError):
             colors = None
 
         if self.hue_cb.currentText() == "--":

celldetective/gui/thresholds_gui.py

@@ -74,6 +74,7 @@ class ThresholdConfigWizard(CelldetectiveMainWindow):
 
         super().__init__()
         self.parent_window = parent_window
+        # Navigate explicit parent chain: SegModelLoader -> ControlPanel -> ProcessPanel -> MainWindow
         self.screen_height = (
             self.parent_window.parent_window.parent_window.parent_window.screen_height
         )
@@ -124,6 +125,17 @@ class ThresholdConfigWizard(CelldetectiveMainWindow):
         self.bg_loader = BackgroundLoader()
         self.bg_loader.start()
 
+    def closeEvent(self, event):
+        """Clean up resources on close."""
+        if hasattr(self, "bg_loader") and self.bg_loader.isRunning():
+            self.bg_loader.quit()
+            self.bg_loader.wait()
+        # Clear large arrays
+        for attr in ["img", "labels", "edt_map", "props", "coords"]:
+            if hasattr(self, attr):
+                delattr(self, attr)
+        super().closeEvent(event)
+
     def _create_menu_bar(self):
         menu_bar = self.menuBar()
         # Creating menus using a QMenu object
@@ -810,7 +822,8 @@ class ThresholdConfigWizard(CelldetectiveMainWindow):
         for i in range(2):
             try:
                 self.features_cb[i].disconnect()
-            except Exception as _:
+            except TypeError:
+                # No connections to disconnect
                 pass
             self.features_cb[i].clear()
 
@@ -879,12 +892,39 @@ class ThresholdConfigWizard(CelldetectiveMainWindow):
             self.exp_dir + f"configs/threshold_config_{self.mode}.json",
             "JSON (*.json)",
         )[0]
-        with open(self.previous_instruction_file, "r") as f:
-            threshold_instructions = json.load(f)
+
+        if not self.previous_instruction_file:
+            return  # User cancelled
+
+        try:
+            with open(self.previous_instruction_file, "r") as f:
+                threshold_instructions = json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError) as e:
+            generic_message(f"Could not load config: {e}")
+            return
+
+        # Validate required keys
+        required_keys = [
+            "target_channel",
+            "filters",
+            "thresholds",
+            "marker_footprint_size",
+            "marker_min_distance",
+            "feature_queries",
+        ]
+        missing_keys = [k for k in required_keys if k not in threshold_instructions]
+        if missing_keys:
+            generic_message(f"Config file is missing required keys: {missing_keys}")
+            return
 
         target_channel = threshold_instructions["target_channel"]
-        index = self.viewer.channels_cb.findText(target_channel)
-        self.viewer.channels_cb.setCurrentIndex(index)
+        index = self.viewer.channel_cb.findText(target_channel)
+        if index >= 0:
+            self.viewer.channel_cb.setCurrentIndex(index)
+        else:
+            logger.warning(
+                f"Channel '{target_channel}' not found in available channels"
+            )
 
         filters = threshold_instructions["filters"]
         items_to_add = [f[0] + "_filter" for f in filters]

celldetective/gui/viewers/spot_detection_viewer.py

@@ -5,18 +5,34 @@ from pathlib import Path
 import numpy as np
 from PyQt5.QtCore import QSize
 from PyQt5.QtGui import QDoubleValidator
-from PyQt5.QtWidgets import QMessageBox, QHBoxLayout, QLabel, QComboBox, QLineEdit, QPushButton
+from PyQt5.QtWidgets import (
+    QMessageBox,
+    QHBoxLayout,
+    QLabel,
+    QComboBox,
+    QLineEdit,
+    QPushButton,
+    QCheckBox,
+    QSizePolicy,
+    QWidget,
+)
+from PyQt5.QtCore import Qt
+from celldetective.gui.base.utils import center_window
 from fonticon_mdi6 import MDI6
 from natsort import natsorted
 from superqt.fonticon import icon
 
-from celldetective.gui.gui_utils import PreprocessingLayout2
 from celldetective.gui.viewers.base_viewer import StackVisualizer
+from celldetective.gui.gui_utils import PreprocessingLayout2
 from celldetective.utils.image_loaders import load_frames
+from celldetective.measure import extract_blobs_in_image
+from celldetective.filters import filter_image
 from celldetective import get_logger
+from tifffile import imread
 
 logger = get_logger(__name__)
 
+
 class SpotDetectionVisualizer(StackVisualizer):
 
     def __init__(
@@ -37,6 +53,7 @@ class SpotDetectionVisualizer(StackVisualizer):
         self.labels = labels
         self.detection_channel = self.target_channel
         self.switch_from_channel = False
+        self.preview_preprocessing = False
 
         self.parent_channel_cb = parent_channel_cb
         self.parent_diameter_le = parent_diameter_le
@@ -47,6 +64,35 @@ class SpotDetectionVisualizer(StackVisualizer):
         self.floatValidator = QDoubleValidator()
         self.init_scatter()
 
+        self.setWindowTitle(self.window_title)
+        self.resize(1200, 800)
+
+        # Main Layout (Horizontal split)
+        self.main_layout = QHBoxLayout(self)
+        self.main_layout.setContentsMargins(10, 10, 10, 10)
+
+        # Left Panel (Settings) - Scrollable
+        from PyQt5.QtWidgets import QScrollArea, QWidget, QVBoxLayout
+
+        self.scroll_area = QScrollArea()
+        self.scroll_area.setWidgetResizable(True)
+        self.settings_widget = QWidget()
+        self.settings_layout = QVBoxLayout(self.settings_widget)
+        self.settings_layout.setContentsMargins(10, 10, 10, 10)
+        self.settings_layout.setSpacing(15)
+        self.settings_layout.setAlignment(Qt.AlignTop)
+        self.scroll_area.setWidget(self.settings_widget)
+        self.scroll_area.setFixedWidth(350)  # Set a reasonable width for settings
+
+        # Add Left Panel
+        self.main_layout.addWidget(self.scroll_area)
+
+        # Right Panel (Image Canvas)
+        # self.canvas is created by super().__init__
+        # We allow it to expand
+        self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        self.main_layout.addWidget(self.canvas)
+
         self.generate_detection_channel()
         self.detection_channel = self.detection_channel_cb.currentIndex()
 
@@ -57,12 +103,29 @@ class SpotDetectionVisualizer(StackVisualizer):
 
         self.ax.callbacks.connect("xlim_changed", self.update_marker_sizes)
         self.ax.callbacks.connect("ylim_changed", self.update_marker_sizes)
+        self._axis_callbacks_connected = True
 
         self.apply_diam_btn.clicked.connect(self.detect_and_display_spots)
         self.apply_thresh_btn.clicked.connect(self.detect_and_display_spots)
 
-        self.channel_cb.setCurrentIndex(self.target_channel)
-        self.detection_channel_cb.setCurrentIndex(self.target_channel)
+        self.channel_cb.setCurrentIndex(min(self.target_channel, self.n_channels - 1))
+        self.detection_channel_cb.setCurrentIndex(
+            min(self.target_channel, self.n_channels - 1)
+        )
+
+    def closeEvent(self, event):
+        """Clean up resources on close."""
+        # Clear large arrays
+        self.target_img = None
+        self.init_label = None
+        self.spot_sizes = []
+
+        # Remove scatter
+        if hasattr(self, "spot_scat") and self.spot_scat is not None:
+            self.spot_scat.remove()
+            self.spot_scat = None
+
+        super().closeEvent(event)
 
     def update_marker_sizes(self, event=None):
 
@@ -105,9 +168,7 @@ class SpotDetectionVisualizer(StackVisualizer):
         if not self.switch_from_channel:
             self.reset_detection()
 
-        if self.mode == "virtual":
-            from tifffile import imread
-
+        if self.mode == "virtual" and hasattr(self, "mask_paths"):
             self.init_label = imread(self.mask_paths[value])
             self.target_img = load_frames(
                 self.img_num_per_channel[self.detection_channel, value],
@@ -122,15 +183,11 @@ class SpotDetectionVisualizer(StackVisualizer):
 
         self.reset_detection()
         self.control_valid_parameters()  # set current diam and threshold
-        # self.change_frame(self.frame_slider.value())
-        # self.set_detection_channel_index(self.detection_channel_cb.currentIndex())
 
         image_preprocessing = self.preprocessing.list.items
         if image_preprocessing == []:
             image_preprocessing = None
 
-        from celldetective.measure import extract_blobs_in_image
-
         blobs_filtered = extract_blobs_in_image(
             self.target_img,
             self.init_label,
@@ -157,8 +214,7 @@ class SpotDetectionVisualizer(StackVisualizer):
             self.canvas.canvas.draw()
 
     def reset_detection(self):
-
-        self.ax.scatter([], []).get_offsets()
+        """Clear spot detection display."""
         empty_offset = np.ma.masked_array([0, 0], mask=True)
         self.spot_scat.set_offsets(empty_offset)
         self.canvas.canvas.draw()
@@ -205,8 +261,6 @@ class SpotDetectionVisualizer(StackVisualizer):
             returnValue = msgBox.exec()
             self.close()
 
-        from tifffile import imread
-
         self.init_label = imread(self.mask_paths[self.frame_slider.value()])
 
     def generate_detection_channel(self):
@@ -215,7 +269,7 @@ class SpotDetectionVisualizer(StackVisualizer):
         assert len(self.channel_names) == self.n_channels
 
         channel_layout = QHBoxLayout()
-        channel_layout.setContentsMargins(15, 0, 15, 0)
+        channel_layout.setContentsMargins(0, 0, 0, 0)
         channel_layout.addWidget(QLabel("Detection\nchannel: "), 25)
 
         self.detection_channel_cb = QComboBox()
@@ -231,11 +285,22 @@ class SpotDetectionVisualizer(StackVisualizer):
         # self.invert_check.toggled.connect(self.set_invert)
         # channel_layout.addWidget(self.invert_check, 10)
 
-        self.canvas.layout.addLayout(channel_layout)
+        self.settings_layout.addLayout(channel_layout)
 
-        self.preprocessing = PreprocessingLayout2(fraction=25, parent_window=self)
-        self.preprocessing.setContentsMargins(15, 0, 15, 0)
-        self.canvas.layout.addLayout(self.preprocessing)
+        self.preview_cb = QCheckBox("Preview")
+        self.preview_cb.toggled.connect(self.toggle_preprocessing_preview)
+
+        self.preprocessing = PreprocessingLayout2(
+            fraction=25, parent_window=self, extra_widget=self.preview_cb
+        )
+        self.preprocessing.setContentsMargins(0, 10, 0, 10)
+        self.preprocessing.list.list_widget.model().rowsInserted.connect(
+            self.update_preview_if_active
+        )
+        self.preprocessing.list.list_widget.model().rowsRemoved.connect(
+            self.update_preview_if_active
+        )
+        self.settings_layout.addLayout(self.preprocessing)
 
     # def set_invert(self):
     # 	if self.invert_check.isChecked():
@@ -272,19 +337,22 @@ class SpotDetectionVisualizer(StackVisualizer):
         self.spot_diam_le.textChanged.connect(self.control_valid_parameters)
         self.spot_thresh_le.textChanged.connect(self.control_valid_parameters)
 
+        self.apply_diam_btn.clicked.connect(self.detect_and_display_spots)
+        self.apply_thresh_btn.clicked.connect(self.detect_and_display_spots)
+
         spot_diam_layout = QHBoxLayout()
-        spot_diam_layout.setContentsMargins(15, 0, 15, 0)
+        spot_diam_layout.setContentsMargins(0, 0, 0, 0)
         spot_diam_layout.addWidget(QLabel("Spot diameter: "), 25)
         spot_diam_layout.addWidget(self.spot_diam_le, 65)
         spot_diam_layout.addWidget(self.apply_diam_btn, 10)
-        self.canvas.layout.addLayout(spot_diam_layout)
+        self.settings_layout.addLayout(spot_diam_layout)
 
         spot_thresh_layout = QHBoxLayout()
-        spot_thresh_layout.setContentsMargins(15, 0, 15, 0)
+        spot_thresh_layout.setContentsMargins(0, 0, 0, 0)
         spot_thresh_layout.addWidget(QLabel("Detection\nthreshold: "), 25)
         spot_thresh_layout.addWidget(self.spot_thresh_le, 65)
         spot_thresh_layout.addWidget(self.apply_thresh_btn, 10)
-        self.canvas.layout.addLayout(spot_thresh_layout)
+        self.settings_layout.addLayout(spot_thresh_layout)
 
     def generate_add_measurement_btn(self):
 
@@ -297,7 +365,48 @@ class SpotDetectionVisualizer(StackVisualizer):
         add_hbox.addWidget(QLabel(""), 33)
         add_hbox.addWidget(self.add_measurement_btn, 33)
         add_hbox.addWidget(QLabel(""), 33)
-        self.canvas.layout.addLayout(add_hbox)
+        self.settings_layout.addLayout(add_hbox)
+
+    def show(self):
+        QWidget.show(self)
+        center_window(self)
+
+    def update_preview_if_active(self):
+        if self.preview_cb.isChecked():
+            self.toggle_preprocessing_preview()
+
+    def toggle_preprocessing_preview(self):
+
+        image_preprocessing = self.preprocessing.list.items
+        if image_preprocessing == []:
+            image_preprocessing = None
+
+        if self.preview_cb.isChecked() and image_preprocessing is not None:
+            # Apply preprocessing
+            try:
+                preprocessed_img = filter_image(
+                    self.target_img.copy(), filters=image_preprocessing
+                )
+                self.im.set_data(preprocessed_img)
+
+                # Update contrast to match new range
+                p01 = np.nanpercentile(preprocessed_img, 0.1)
+                p99 = np.nanpercentile(preprocessed_img, 99.9)
+                self.im.set_clim(vmin=p01, vmax=p99)
+                if hasattr(self, "contrast_slider"):
+                    self.contrast_slider.setValue((p01, p99))
+                self.canvas.draw()
+            except Exception as e:
+                logger.error(f"Preprocessing preview failed: {e}")
+        else:
+            # Restore original
+            self.im.set_data(self.target_img)
+            p01 = np.nanpercentile(self.target_img, 0.1)
+            p99 = np.nanpercentile(self.target_img, 99.9)
+            self.im.set_clim(vmin=p01, vmax=p99)
+            if hasattr(self, "contrast_slider"):
+                self.contrast_slider.setValue((p01, p99))
+            self.canvas.draw()
 
     def control_valid_parameters(self):
 
@@ -305,14 +414,14 @@ class SpotDetectionVisualizer(StackVisualizer):
         try:
             self.diameter = float(self.spot_diam_le.text().replace(",", "."))
             valid_diam = True
-        except:
+        except ValueError:
             valid_diam = False
 
         valid_thresh = False
         try:
             self.thresh = float(self.spot_thresh_le.text().replace(",", "."))
             valid_thresh = True
-        except:
+        except ValueError:
             valid_thresh = False
 
         if valid_diam and valid_thresh: