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

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/base_viewer.py

@@ -6,6 +6,7 @@ from PyQt5.QtWidgets import QHBoxLayout, QAction, QLabel, QComboBox
 from fonticon_mdi6 import MDI6
 from superqt import QLabeledDoubleRangeSlider, QLabeledSlider
 from superqt.fonticon import icon
+import matplotlib.gridspec as gridspec
 
 from celldetective.gui.base.components import CelldetectiveWidget
 from celldetective.gui.base.utils import center_window
@@ -102,8 +103,7 @@ class StackLoader(QThread):
                     self.mutex.unlock()
 
                 except Exception as e:
-                    pass
-                    # logger.error(f"Error loading frame {frame_to_load}: {e}")
+                    logger.debug(f"Error loading frame {frame_to_load}: {e}")
                     # Prepare to wait to avoid spin loop on error
                     self.msleep(100)
 
@@ -169,10 +169,14 @@ class StackVisualizer(CelldetectiveWidget):
         window_title="View",
         PxToUm=None,
         background_color="transparent",
-        imshow_kwargs={},
+        imshow_kwargs=None,
     ):
         super().__init__()
 
+        # Default mutable argument handling
+        if imshow_kwargs is None:
+            imshow_kwargs = {}
+
         # self.setWindowTitle(window_title)
         self.window_title = window_title
 
@@ -265,7 +269,6 @@ class StackVisualizer(CelldetectiveWidget):
                 self.canvas.toolbar.insertAction(insert_before, self.lock_y_action)
             else:
                 if len(actions) > 5:
-                    self.canvas.toolbar.insertAction(actions[5], self.line_action)
                     self.canvas.toolbar.insertAction(actions[5], self.line_action)
                     self.canvas.toolbar.insertAction(actions[5], self.lock_y_action)
                 else:
@@ -313,8 +316,6 @@ class StackVisualizer(CelldetectiveWidget):
             # Use GridSpec for robust layout
             # 2 rows: Main Image (top, ~75%), Profile (bottom, ~25%)
             # Add margins to ensure axis labels and text are visible
-            import matplotlib.gridspec as gridspec
-
             gs = gridspec.GridSpec(
                 2,
                 1,
@@ -406,10 +407,6 @@ class StackVisualizer(CelldetectiveWidget):
                 self.ax_profile = None
 
             # Restore original layout
-            # if hasattr(self, "ax_original_pos"):
-            # standard 1x1 GridSpec or manual restore
-            import matplotlib.gridspec as gridspec
-
             gs = gridspec.GridSpec(1, 1)
             self.ax.set_subplotspec(gs[0])
             # self.ax.set_position(gs[0].get_position(self.fig))
@@ -505,9 +502,8 @@ class StackVisualizer(CelldetectiveWidget):
             profile = np.zeros_like(profile)
             profile[:] = np.nan
 
-        # Distance in microns if available
+        # Distance in pixels
         dist_axis = np.arange(num_points)
-        x_label = "Distance (px)"
 
         # Only show pixel length, rounded to integer
         title_str = f"{round(length_px,2)} [px]"
@@ -525,11 +521,8 @@ class StackVisualizer(CelldetectiveWidget):
         if hasattr(self, "profile_line") and self.profile_line:
             try:
                 self.profile_line.remove()
-            except:
-                pass
-
-        # Distance in microns if available
-        dist_axis = np.arange(num_points)
+            except ValueError:
+                pass  # Already removed
 
         (self.profile_line,) = self.ax_profile.plot(
             dist_axis, profile, color="black", linestyle="-"
@@ -850,12 +843,16 @@ class StackVisualizer(CelldetectiveWidget):
 
         if curr_min < self._min:
             self._min = curr_min
-            rescale_constrast = True
+            rescale_contrast = True
         if curr_max > self._max:
             self._max = curr_max
             rescale_contrast = True
 
-        if rescale_contrast:
+        if (
+            rescale_contrast
+            and self.create_contrast_slider
+            and hasattr(self, "contrast_slider")
+        ):
             self.contrast_slider.setRange(self._min, self._max)
         self.canvas.canvas.draw_idle()
         self.update_profile()
@@ -888,5 +885,5 @@ class StackVisualizer(CelldetectiveWidget):
         try:
             if hasattr(self, "loader_thread") and self.loader_thread:
                 self.loader_thread.stop()
-        except:
+        except Exception:
             pass

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:

celldetective/processes/train_signal_model.py

@@ -7,7 +7,7 @@ import numpy as np
 from art import tprint
 from tensorflow.python.keras.callbacks import Callback
 
-from celldetective.signals import SignalDetectionModel
+from celldetective.event_detection_models import SignalDetectionModel
 from celldetective.log_manager import get_logger
 from celldetective.utils.model_loaders import locate_signal_model
 

celldetective/scripts/train_signal_model.py

@@ -8,7 +8,7 @@ import json
 from glob import glob
 import numpy as np
 from art import tprint
-from celldetective.signals import SignalDetectionModel
+from celldetective.event_detection_models import SignalDetectionModel
 from celldetective.utils.model_loaders import locate_signal_model
 
 tprint("Train")