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

celldetective/gui/pair_event_annotator.py

@@ -21,7 +21,7 @@ from celldetective.gui.base.components import (
     CelldetectiveWidget,
 )
 from celldetective.gui.base.utils import center_window
-from superqt import QLabeledDoubleRangeSlider, QSearchableComboBox
+from superqt import QLabeledDoubleRangeSlider, QSearchableComboBox, QLabeledSlider
 from celldetective import (
     get_software_location,
 )
@@ -466,11 +466,26 @@ class PairEventAnnotator(CelldetectiveMainWindow):
         # Animation
         animation_buttons_box = QHBoxLayout()
 
+        self.speed_slider = QLabeledSlider(Qt.Horizontal)
+        self.speed_slider.setRange(1, 60)
+        # Convert initial interval (ms) to FPS
+        initial_fps = int(1000 / max(1, self.anim_interval))
+        self.speed_slider.setValue(initial_fps)
+        self.speed_slider.valueChanged.connect(self.update_speed)
+        self.speed_slider.setFixedWidth(200)
+        self.speed_slider.setToolTip("Adjust animation framerate (FPS)")
+
+        speed_layout = QHBoxLayout()
+        speed_layout.addWidget(QLabel("Framerate: "))
+        speed_layout.addWidget(self.speed_slider)
+
         animation_buttons_box.addWidget(self.frame_lbl, 20, alignment=Qt.AlignLeft)
+        animation_buttons_box.addLayout(speed_layout, 20)
 
         self.first_frame_btn = QPushButton()
         self.first_frame_btn.clicked.connect(self.set_first_frame)
-        self.first_frame_btn.setShortcut(QKeySequence("f"))
+        self.first_short = QShortcut(QKeySequence("f"), self)
+        self.first_short.activated.connect(self.set_first_frame)
         self.first_frame_btn.setIcon(icon(MDI6.page_first, color="black"))
         self.first_frame_btn.setStyleSheet(self.button_select_all)
         self.first_frame_btn.setFixedSize(QSize(60, 60))
@@ -478,7 +493,8 @@ class PairEventAnnotator(CelldetectiveMainWindow):
 
         self.last_frame_btn = QPushButton()
         self.last_frame_btn.clicked.connect(self.set_last_frame)
-        self.last_frame_btn.setShortcut(QKeySequence("l"))
+        self.last_short = QShortcut(QKeySequence("l"), self)
+        self.last_short.activated.connect(self.set_last_frame)
         self.last_frame_btn.setIcon(icon(MDI6.page_last, color="black"))
         self.last_frame_btn.setStyleSheet(self.button_select_all)
         self.last_frame_btn.setFixedSize(QSize(60, 60))
@@ -499,11 +515,32 @@ class PairEventAnnotator(CelldetectiveMainWindow):
         self.start_btn.setIconSize(QSize(30, 30))
         self.start_btn.hide()
 
+        self.toggle_short = QShortcut(Qt.Key_Space, self)
+        self.toggle_short.activated.connect(self.toggle_animation)
+
+        self.prev_frame_btn = QPushButton()
+        self.prev_frame_btn.clicked.connect(self.prev_frame)
+        self.prev_frame_btn.setIcon(icon(MDI6.chevron_left, color="black"))
+        self.prev_frame_btn.setStyleSheet(self.button_select_all)
+        self.prev_frame_btn.setFixedSize(QSize(60, 60))
+        self.prev_frame_btn.setIconSize(QSize(30, 30))
+        self.prev_frame_btn.setEnabled(False)
+
+        self.next_frame_btn = QPushButton()
+        self.next_frame_btn.clicked.connect(self.next_frame)
+        self.next_frame_btn.setIcon(icon(MDI6.chevron_right, color="black"))
+        self.next_frame_btn.setStyleSheet(self.button_select_all)
+        self.next_frame_btn.setFixedSize(QSize(60, 60))
+        self.next_frame_btn.setIconSize(QSize(30, 30))
+        self.next_frame_btn.setEnabled(False)
+
         animation_buttons_box.addWidget(
             self.first_frame_btn, 5, alignment=Qt.AlignRight
         )
+        animation_buttons_box.addWidget(self.prev_frame_btn, 5, alignment=Qt.AlignRight)
         animation_buttons_box.addWidget(self.stop_btn, 5, alignment=Qt.AlignRight)
         animation_buttons_box.addWidget(self.start_btn, 5, alignment=Qt.AlignRight)
+        animation_buttons_box.addWidget(self.next_frame_btn, 5, alignment=Qt.AlignRight)
         animation_buttons_box.addWidget(self.last_frame_btn, 5, alignment=Qt.AlignRight)
 
         self.right_panel.addLayout(animation_buttons_box, 5)
@@ -1968,10 +2005,7 @@ class PairEventAnnotator(CelldetectiveMainWindow):
                 else:
                     self.fraction = 0.25
 
-                if "interval" in instructions:
-                    self.anim_interval = int(instructions["interval"])
-                else:
-                    self.anim_interval = 1
+                self.anim_interval = 33
 
                 if "log" in instructions:
                     self.log_option = instructions["log"]
@@ -1983,7 +2017,7 @@ class PairEventAnnotator(CelldetectiveMainWindow):
             self.percentile_mode = True
             self.target_channels = [[self.channel_names[0], 0.01, 99.99]]
             self.fraction = 0.25
-            self.anim_interval = 1
+            self.anim_interval = 33
 
     def prepare_stack(self):
 
@@ -2104,6 +2138,49 @@ class PairEventAnnotator(CelldetectiveMainWindow):
             idx = self.relative_class_choice_cb.findText(self.relative_class)
             self.relative_class_choice_cb.setCurrentIndex(idx)
 
+    def update_speed(self):
+        fps = self.speed_slider.value()
+        # Convert FPS to interval in ms
+        # FPS = 1000 / interval_ms => interval_ms = 1000 / FPS
+        val = int(1000 / max(1, fps))
+
+        self.anim_interval = val
+        print(
+            f"DEBUG: Speed slider moved. FPS: {fps} -> Interval: {val} ms. Recreating animation object."
+        )
+
+        # Check if animation is allowed to run (Pause button is visible means we are Playing)
+        should_play = self.stop_btn.isVisible()
+
+        if hasattr(self, "anim") and self.anim:
+            try:
+                self.anim.event_source.stop()
+            except Exception as e:
+                print(f"DEBUG: Error stopping animation: {e}")
+
+        # Recreate animation with new interval
+        try:
+            # We must disconnect the old pick event to avoid accumulating connections
+            # although mpl_connect returns a cid, we didn't store it properly before.
+            # However, the canvas clears usually handle this if we cleared axes, but we aren't clearing axes here.
+            # Ideally we should clean up, but for now let's focus on the animation object replacement.
+
+            self.anim = FuncAnimation(
+                self.fig,
+                self.draw_frame,
+                frames=self.animation_generator,
+                interval=self.anim_interval,
+                blit=True,
+                cache_frame_data=False,
+            )
+
+            # If we were NOT playing (i.e. Paused), pause the new animation immediately
+            if not should_play:
+                self.anim.event_source.stop()
+
+        except Exception as e:
+            print(f"DEBUG: Error recreating animation: {e}")
+
     def closeEvent(self, event):
 
         self.stop()
@@ -2119,6 +2196,18 @@ class PairEventAnnotator(CelldetectiveMainWindow):
 
         gc.collect()
 
+    def animation_generator(self):
+        """
+        Generator yielding frame indices for the animation,
+        starting from the current self.framedata.
+        """
+        i = self.framedata
+        while True:
+            yield i
+            i += 1
+            if i >= self.len_movie:
+                i = 0
+
     def looped_animation(self):
         """
         Load an image.
@@ -2195,9 +2284,10 @@ class PairEventAnnotator(CelldetectiveMainWindow):
         self.anim = FuncAnimation(
             self.fig,
             self.draw_frame,
-            frames=self.len_movie,  # better would be to cast np.arange(len(movie)) in case frame column is incomplete
+            frames=self.animation_generator,
             interval=self.anim_interval,  # in ms
             blit=True,
+            cache_frame_data=False,
         )
 
         self.fig.canvas.mpl_connect("pick_event", self.on_scatter_pick)
@@ -2855,27 +2945,63 @@ class PairEventAnnotator(CelldetectiveMainWindow):
         self.stop_btn.hide()
         self.start_btn.show()
         self.anim.pause()
+        self.prev_frame_btn.setEnabled(True)
+        self.next_frame_btn.setEnabled(True)
         self.stop_btn.clicked.connect(self.start)
 
     def start(self):
         """
-        Starts interactive animation. Adds the draw frame command to the GUI
-        handler, calls show to start the event loop.
+        Starts interactive animation.
         """
-        self.start_btn.setShortcut(QKeySequence(""))
-
-        self.last_frame_btn.setEnabled(True)
-        self.last_frame_btn.clicked.connect(self.set_last_frame)
-
-        self.first_frame_btn.setEnabled(True)
-        self.first_frame_btn.clicked.connect(self.set_first_frame)
-
         self.start_btn.hide()
         self.stop_btn.show()
 
-        self.anim.event_source.start()
+        self.prev_frame_btn.setEnabled(False)
+        self.next_frame_btn.setEnabled(False)
+
+        self.anim.resume()
         self.stop_btn.clicked.connect(self.stop)
 
+    def toggle_animation(self):
+        if self.stop_btn.isVisible():
+            self.stop()
+        else:
+            self.start()
+
+    def next_frame(self):
+        self.framedata += 1
+        if self.framedata >= self.len_movie:
+            self.framedata = 0
+        self.draw_frame(self.framedata)
+        self.fcanvas.canvas.draw()
+
+    def prev_frame(self):
+        self.framedata -= 1
+        if self.framedata < 0:
+            self.framedata = self.len_movie - 1
+        self.draw_frame(self.framedata)
+        self.fcanvas.canvas.draw()
+
+    def set_first_frame(self):
+        self.stop()
+        self.framedata = 0
+        self.draw_frame(self.framedata)
+        self.fcanvas.canvas.draw()
+
+    def set_last_frame(self):
+        self.stop()
+        self.framedata = len(self.stack) - 1
+        while len(np.where(self.stack[self.framedata].flatten() == 0)[0]) > 0.99 * len(
+            self.stack[self.framedata].flatten()
+        ):
+            self.framedata -= 1
+            if self.framedata < 0:
+                self.framedata = 0
+                break
+
+        self.draw_frame(self.framedata)
+        self.fcanvas.canvas.draw()
+
     def give_reference_cell_information(self):
 
         df_reference = self.dataframes[self.reference_population]

celldetective/gui/process_block.py

@@ -1361,12 +1361,12 @@ class ProcessPanel(QFrame, Styles):
                     msgBox = QMessageBox()
                     msgBox.setIcon(QMessageBox.Question)
                     msgBox.setText(
-                        "A measurement table already exists. Previously annotated data for\nthis position will be lost. Do you want to proceed?"
+                        "A measurement table already exists. Previously annotated data for this position will be lost. Do you want to proceed?"
                     )
                     msgBox.setWindowTitle("Info")
                     msgBox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
                     if msgBox.exec() == QMessageBox.No:
-                        run_tracking = False
+                        return None
 
             if run_tracking:
                 track_args = {"mode": self.mode, "n_threads": self.n_threads}

celldetective/gui/seg_model_loader.py

@@ -129,14 +129,14 @@ class SegmentationModelLoader(CelldetectiveWidget):
     def unlock_upload(self):
         if self.stardist_button.isChecked():
             if np.any(
-                [c.currentText() != "--" for c in self.channel_layout.channel_cbs]
+                [c.currentData() != "--" for c in self.channel_layout.channel_cbs]
             ):
                 self.upload_button.setEnabled(True)
             else:
                 self.upload_button.setEnabled(False)
         elif self.cellpose_button.isChecked():
             if np.any(
-                [c.currentText() != "--" for c in self.channel_layout.channel_cbs]
+                [c.currentData() != "--" for c in self.channel_layout.channel_cbs]
             ):
                 self.upload_button.setEnabled(True)
             else:
@@ -373,7 +373,7 @@ class SegmentationModelLoader(CelldetectiveWidget):
 
         channels = []
         for i in range(len(self.channel_layout.channel_cbs)):
-            channels.append(self.channel_layout.channel_cbs[i].currentText())
+            channels.append(self.channel_layout.channel_cbs[i].currentData())
 
         if self.file_label.text() == "No file chosen":
             generic_message("Please select a model first...")
@@ -450,7 +450,7 @@ class SegmentationModelLoader(CelldetectiveWidget):
 
         channels = []
         for i in range(len(self.channel_layout.channel_cbs)):
-            channels.append(self.channel_layout.channel_cbs[i].currentText())
+            channels.append(self.channel_layout.channel_cbs[i].currentData())
 
         slots_to_keep = np.where(np.array(channels) != "--")[0]
         while "--" in channels:

celldetective/gui/settings/_settings_event_model_training.py

@@ -417,8 +417,7 @@ class SettingsEventDetectionModelTraining(CelldetectiveSettingsPanel):
         self.signals = ["--"] + num_cols_pairs + num_cols_reference + num_cols_neighbor
 
         for cb in self.ch_norm.channel_cbs:
-            cb.clear()
-            cb.addItems(self.signals)
+            self.ch_norm.add_items_truncated(cb, self.signals)
 
     def fill_available_neighborhoods(self):
 
@@ -541,15 +540,36 @@ class SettingsEventDetectionModelTraining(CelldetectiveSettingsPanel):
         self.model_length_slider.setValue(int(signal_length))
         self.model_length_slider.setEnabled(False)
 
-        for c, cb in zip(channels, self.ch_norm.channel_cbs):
-            index = cb.findText(c)
+        try:
+            norm_perc = data["normalization_percentile"]
+            if isinstance(norm_perc, bool):
+                norm_perc = [norm_perc] * len(channels)
+            norm_val = data["normalization_values"]
+            if len(norm_val) == 2 and isinstance(norm_val[0], float):
+                norm_val = [norm_val] * len(channels)
+            norm_clip = data["normalization_clip"]
+            if isinstance(norm_clip, bool):
+                norm_clip = [norm_clip] * len(channels)
+        except Exception:
+            norm_perc = [True] * len(channels)
+            norm_val = [[0.1, 99.99]] * len(channels)
+            norm_clip = [False] * len(channels)
+
+        for k, (c, cb) in enumerate(zip(channels, self.ch_norm.channel_cbs)):
+            index = cb.findData(c)
             cb.setCurrentIndex(index)
 
-        if len(channels) < len(self.ch_norm.channel_cbs):
-            for k in range(len(self.ch_norm.channel_cbs) - len(channels)):
-                self.ch_norm.channel_cbs[len(channels) + k].setCurrentIndex(0)
-                self.ch_norm.channel_cbs[len(channels) + k].setEnabled(False)
-        self.ch_norm.add_col_btn.setEnabled(False)
+            # Set normalization mode
+            if self.ch_norm.normalization_mode[k] != norm_perc[k]:
+                self.ch_norm.switch_normalization_mode(k)
+
+            # Set clipping mode
+            if self.ch_norm.clip_option[k] != norm_clip[k]:
+                self.ch_norm.switch_clipping_mode(k)
+
+            # Set normalization values
+            self.ch_norm.normalization_min_value_le[k].setText(str(norm_val[k][0]))
+            self.ch_norm.normalization_max_value_le[k].setText(str(norm_val[k][1]))
 
     def adjust_scroll_area(self):
         """
@@ -581,7 +601,7 @@ class SettingsEventDetectionModelTraining(CelldetectiveSettingsPanel):
 
         channels = []
         for i in range(len(self.ch_norm.channel_cbs)):
-            channels.append(self.ch_norm.channel_cbs[i].currentText())
+            channels.append(self.ch_norm.channel_cbs[i].currentData())
 
         slots_to_keep = np.where(np.array(channels) != "--")[0]
         while "--" in channels:
@@ -750,10 +770,8 @@ class SettingsEventDetectionModelTraining(CelldetectiveSettingsPanel):
 
             # Assuming signal/event models directory. Verifying path would be better but this fits pattern.
             # If exact attribute unknown, use os.path.dirname logic or config methods.
-            # Safe bet: self.parent_window.signal_models_dir based on refresh call.
-            model_path = os.path.join(
-                self.parent_window.signal_models_dir, self.modelname_le.text()
-            )
+            # Safe bet: self.signal_models_dir based on init.
+            model_path = os.path.join(self.signal_models_dir, self.modelname_le.text())
             if os.path.exists(model_path):
                 time.sleep(0.5)
                 shutil.rmtree(model_path)

celldetective/gui/settings/_settings_segmentation_model_training.py

@@ -355,7 +355,7 @@ class SettingsSegmentationModelTraining(CelldetectiveSettingsPanel):
             not current_name in models
             and not self.spatial_calib_le.text() == ""
             and not np.all(
-                [cb.currentText() == "--" for cb in self.ch_norm.channel_cbs]
+                [cb.currentData() == "--" for cb in self.ch_norm.channel_cbs]
             )
         ):
             self.submit_btn.setEnabled(True)
@@ -370,7 +370,7 @@ class SettingsSegmentationModelTraining(CelldetectiveSettingsPanel):
                 self.submit_warning.setText(
                     "Please provide a valid spatial calibration..."
                 )
-            elif np.all([cb.currentText() == "--" for cb in self.ch_norm.channel_cbs]):
+            elif np.all([cb.currentData() == "--" for cb in self.ch_norm.channel_cbs]):
                 self.submit_warning.setText("Please provide valid channels...")
 
     def rescale_slider(self):
@@ -459,7 +459,7 @@ class SettingsSegmentationModelTraining(CelldetectiveSettingsPanel):
 
         for k in range(len(self.diamWidget.cellpose_channel_cb)):
             ch = self.diamWidget.cellpose_channel_cb[k].currentText()
-            idx = self.ch_norm.channel_cbs[k].findText(ch)
+            idx = self.ch_norm.channel_cbs[k].findData(ch)
             self.ch_norm.channel_cbs[k].setCurrentIndex(idx)
 
         self.diamWidget.close()
@@ -561,7 +561,7 @@ class SettingsSegmentationModelTraining(CelldetectiveSettingsPanel):
             self.cellpose_model.setChecked(True)
 
         for c, cb in zip(channels, self.ch_norm.channel_cbs):
-            index = cb.findText(c)
+            index = cb.findData(c)
             cb.setCurrentIndex(index)
 
         for i in range(len(channels)):
@@ -622,7 +622,7 @@ class SettingsSegmentationModelTraining(CelldetectiveSettingsPanel):
 
         channels = []
         for i in range(len(self.ch_norm.channel_cbs)):
-            channels.append(self.ch_norm.channel_cbs[i].currentText())
+            channels.append(self.ch_norm.channel_cbs[i].currentData())
 
         slots_to_keep = np.where(np.array(channels) != "--")[0]
         while "--" in channels:

celldetective/gui/settings/_settings_signal_annotator.py

@@ -100,11 +100,6 @@ class SettingsSignalAnnotator(CelldetectiveSettingsPanel):
         hbox_frac.addWidget(self.fraction_slider, 80)
         sub_layout.addLayout(hbox_frac)
 
-        hbox_interval = QHBoxLayout()
-        hbox_interval.addWidget(self._interval_lbl, 20)
-        hbox_interval.addWidget(self.interval_slider, 80)
-        sub_layout.addLayout(hbox_interval)
-
         self._layout.addLayout(sub_layout)
 
         self._layout.addWidget(self.submit_btn)
@@ -118,7 +113,6 @@ class SettingsSignalAnnotator(CelldetectiveSettingsPanel):
 
         self._modality_lbl = QLabel("Modality: ")
         self._fraction_lbl = QLabel("fraction: ")
-        self._interval_lbl = QLabel("interval [ms]: ")
 
         self.gs_btn = QRadioButton("grayscale")
         self.gs_btn.setChecked(True)
@@ -173,14 +167,6 @@ class SettingsSignalAnnotator(CelldetectiveSettingsPanel):
         self.fraction_slider.setRange(0.1, 1)
         self.fraction_slider.setValue(0.25)
 
-        self.interval_slider = QLabeledSlider()
-        self.interval_slider.setSingleStep(1)
-        self.interval_slider.setTickInterval(1)
-        self.interval_slider.setSingleStep(1)
-        self.interval_slider.setOrientation(Qt.Horizontal)
-        self.interval_slider.setRange(1, 1000)
-        self.interval_slider.setValue(1)
-
     def enable_channels(self):
         """
         Enable three channels when RGB mode is checked.
@@ -255,7 +241,6 @@ class SettingsSignalAnnotator(CelldetectiveSettingsPanel):
             "rgb_mode": self.rgb_btn.isChecked(),
             "percentile_mode": self.percentile_mode,
             "fraction": float(self.fraction_slider.value()),
-            "interval": int(self.interval_slider.value()),
             "log": self.log_option,
         }
         max_i = 3 if self.rgb_btn.isChecked() else 1
@@ -322,10 +307,6 @@ class SettingsSignalAnnotator(CelldetectiveSettingsPanel):
                     fraction = instructions["fraction"]
                     self.fraction_slider.setValue(fraction)
 
-                if "interval" in instructions:
-                    interval = instructions["interval"]
-                    self.interval_slider.setValue(interval)
-
                 if "log" in instructions:
                     self.log_option = not instructions["log"]
                     self.switch_to_log()

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/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")