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

celldetective/gui/base/channel_norm_generator.py

@@ -36,6 +36,22 @@ class ChannelNormGenerator(QVBoxLayout, Styles):
         self.generate_widgets()
         self.add_to_layout()
 
+    def add_items_truncated(self, combo, items):
+        """
+        Add items to a combobox with truncated text and full text in tooltip/data.
+        """
+        combo.clear()
+        for item in items:
+            item_text = str(item)
+            if len(item_text) > 25:
+                display_text = item_text[:25] + "..."
+            else:
+                display_text = item_text
+            combo.addItem(display_text, item_text)
+            # Find the index of the added item
+            idx = combo.count() - 1
+            combo.setItemData(idx, item_text, Qt.ToolTipRole)
+
     def generate_widgets(self):
 
         self.channel_cbs = [QSearchableComboBox() for i in range(self.init_n_channels)]
@@ -178,7 +194,7 @@ class ChannelNormGenerator(QVBoxLayout, Styles):
 
         self.channel_cbs.append(QSearchableComboBox())
         self.channel_labels.append(QLabel())
-        self.channel_cbs[-1].addItems(self.channel_items)
+        self.add_items_truncated(self.channel_cbs[-1], self.channel_items)
         self.channel_cbs[-1].currentIndexChanged.connect(self.check_valid_channels)
         self.channel_labels[-1].setText(f"channel {len(self.channel_cbs)-1}: ")
 
@@ -239,7 +255,7 @@ class ChannelNormGenerator(QVBoxLayout, Styles):
             ch_layout = QHBoxLayout()
             self.channel_labels[i].setText(f"channel {i}: ")
             ch_layout.addWidget(self.channel_labels[i], 30)
-            self.channel_cbs[i].addItems(self.channel_items)
+            self.add_items_truncated(self.channel_cbs[i], self.channel_items)
             self.channel_cbs[i].currentIndexChanged.connect(self.check_valid_channels)
             ch_layout.addWidget(self.channel_cbs[i], 70)
             self.channels_vb.addLayout(ch_layout)
@@ -323,7 +339,7 @@ class ChannelNormGenerator(QVBoxLayout, Styles):
     def check_valid_channels(self):
 
         if hasattr(self.parent_window, "submit_btn"):
-            if np.all([cb.currentText() == "--" for cb in self.channel_cbs]):
+            if np.all([cb.currentData() == "--" for cb in self.channel_cbs]):
                 self.parent_window.submit_btn.setEnabled(False)
 
         if hasattr(self.parent_window, "spatial_calib_le") and hasattr(

celldetective/gui/base/figure_canvas.py

@@ -23,7 +23,7 @@ class FigureCanvas(CelldetectiveWidget):
 
             self.toolbar = NavigationToolbar2QT(self.canvas)
             self.toolbar.setStyleSheet(
-                "QToolButton:hover {background-color: lightgray;} QToolButton {background-color: transparent; border: none;}"
+                "QToolButton:checked {background-color: darkgray;} QToolButton:hover {background-color: lightgray;} QToolButton {background-color: transparent; border: none;}"
             )
         self.layout = QVBoxLayout(self)
         self.layout.addWidget(self.canvas, 90)

celldetective/gui/base/list_widget.py

@@ -128,6 +128,6 @@ class ListWidget(CelldetectiveWidget):
             return
         for item in listItems:
             idx = self.list_widget.row(item)
-            self.list_widget.takeItem(idx)
             if self.items:
                 del self.items[idx]
+            self.list_widget.takeItem(idx)

celldetective/gui/base_annotator.py

@@ -431,10 +431,7 @@ class BaseAnnotator(CelldetectiveMainWindow, Styles):
                 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"]
@@ -446,7 +443,7 @@ class BaseAnnotator(CelldetectiveMainWindow, Styles):
             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 locate_stack(self):
         """

celldetective/gui/event_annotator.py

@@ -20,7 +20,12 @@ from PyQt5.QtGui import QKeySequence, QIntValidator
 
 from celldetective.gui.gui_utils import color_from_state
 from celldetective.gui.base.utils import center_window, pretty_table
-from superqt import QLabeledDoubleSlider, QLabeledDoubleRangeSlider, QSearchableComboBox
+from superqt import (
+    QLabeledDoubleSlider,
+    QLabeledDoubleRangeSlider,
+    QSearchableComboBox,
+    QLabeledSlider,
+)
 from celldetective.utils.image_loaders import (
     locate_labels,
     load_frames,
@@ -96,14 +101,58 @@ class EventAnnotator(BaseAnnotator):
         self.class_name = "class"
         self.time_name = "t0"
         self.status_name = "status"
+        self._loader_thread = None
 
         # self.locate_stack()
         if not self.proceed:
             self.close()
         else:
             if not lazy_load:
-                self.prepare_stack()
-                self.finalize_init()
+                self._start_threaded_loading()
+
+    def _start_threaded_loading(self):
+        """Start loading the stack in a background thread with progress dialog."""
+        from celldetective.gui.base.components import CelldetectiveProgressDialog
+
+        self._progress_dialog = CelldetectiveProgressDialog(
+            "Loading stack...", "Cancel", 0, 100, self
+        )
+        self._progress_dialog.setWindowTitle("Loading")
+        self._progress_dialog.setMinimumDuration(0)
+        self._progress_dialog.setValue(0)
+
+        self._loader_thread = StackLoaderThread(self)
+        self._loader_thread.progress.connect(self._on_load_progress)
+        self._loader_thread.status_update.connect(self._on_load_status)
+        self._loader_thread.finished.connect(self._on_load_finished)
+        self._progress_dialog.canceled.connect(self._on_load_canceled)
+
+        self._loader_thread.start()
+
+    def _on_load_progress(self, value):
+        """Update progress dialog."""
+        if hasattr(self, "_progress_dialog") and self._progress_dialog:
+            self._progress_dialog.setValue(value)
+
+    def _on_load_status(self, status):
+        """Update progress dialog label."""
+        if hasattr(self, "_progress_dialog") and self._progress_dialog:
+            self._progress_dialog.setLabelText(status)
+
+    def _on_load_canceled(self):
+        """Handle cancel button click."""
+        if self._loader_thread:
+            self._loader_thread.stop()
+            self._loader_thread.wait()
+        self.close()
+
+    def _on_load_finished(self):
+        """Called when loading completes."""
+        if hasattr(self, "_progress_dialog") and self._progress_dialog:
+            self._progress_dialog.close()
+            self._progress_dialog = None
+        self._loader_thread = None
+        self.finalize_init()
 
     def finalize_init(self):
         self.frame_lbl = QLabel("frame: ")
@@ -200,7 +249,8 @@ class EventAnnotator(BaseAnnotator):
 
         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))
@@ -208,7 +258,8 @@ class EventAnnotator(BaseAnnotator):
 
         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))
@@ -229,11 +280,56 @@ class EventAnnotator(BaseAnnotator):
         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.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.addLayout(speed_layout, 20)
+
         animation_buttons_box.addWidget(
             self.first_frame_btn, 5, alignment=Qt.AlignRight
         )
+
+        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
+        )  # Disabled by default (assuming auto-start or initial state)
+        # Actually start is hidden initially, and stop shown?
+        # In populate_window: start_btn.hide() (line 235), stop_btn defaults?
+        # stop_btn is created.
+        # So assumed state is Playing? No, usually it starts, looped_animation matches.
+        # But if it starts playing, buttons should be disabled.
+        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)
+
+        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.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)
@@ -246,15 +342,13 @@ class EventAnnotator(BaseAnnotator):
             self.contrast_slider.setSingleStep(0.001)
             self.contrast_slider.setTickInterval(0.001)
             self.contrast_slider.setOrientation(Qt.Horizontal)
-            self.contrast_slider.setRange(
-                *[
-                    np.nanpercentile(self.stack, 0.001),
-                    np.nanpercentile(self.stack, 99.999),
-                ]
-            )
-            self.contrast_slider.setValue(
-                [np.nanpercentile(self.stack, 1), np.nanpercentile(self.stack, 99.99)]
-            )
+            # Cache percentile values to avoid recomputing on the full stack
+            self._stack_p_low = np.nanpercentile(self.stack, 0.001)
+            self._stack_p_high = np.nanpercentile(self.stack, 99.999)
+            self._stack_p1 = np.nanpercentile(self.stack, 1)
+            self._stack_p99 = np.nanpercentile(self.stack, 99.99)
+            self.contrast_slider.setRange(self._stack_p_low, self._stack_p_high)
+            self.contrast_slider.setValue([self._stack_p1, self._stack_p99])
             self.contrast_slider.valueChanged.connect(self.contrast_slider_action)
             contrast_hbox.addWidget(QLabel("contrast: "))
             contrast_hbox.addWidget(self.contrast_slider, 90)
@@ -263,10 +357,6 @@ class EventAnnotator(BaseAnnotator):
         if self.class_choice_cb.currentText() != "":
             self.compute_status_and_colors(0)
 
-        self.no_event_shortcut = QShortcut(QKeySequence("n"), self)  # QKeySequence("s")
-        self.no_event_shortcut.activated.connect(self.shortcut_no_event)
-        self.no_event_shortcut.setEnabled(False)
-
         QApplication.processEvents()
 
         # Add Menu for Interactive Plotter
@@ -429,7 +519,10 @@ class EventAnnotator(BaseAnnotator):
         self.enable_time_of_interest()
         self.correct_btn.setText("submit")
 
-        self.correct_btn.disconnect()
+        try:
+            self.correct_btn.clicked.disconnect()
+        except TypeError:
+            pass  # No connections to disconnect
         self.correct_btn.clicked.connect(self.apply_modification)
 
     def apply_modification(self):
@@ -441,8 +534,8 @@ class EventAnnotator(BaseAnnotator):
                 t0 = float(self.time_of_interest_le.text().replace(",", "."))
                 self.line_dt.set_xdata([t0, t0])
                 self.cell_fcanvas.canvas.draw_idle()
-            except Exception as e:
-                print(f"L 598 {e=}")
+            except ValueError:
+                # Invalid time value entered
                 t0 = -1
                 cclass = 2
         elif self.no_event_btn.isChecked():
@@ -489,9 +582,11 @@ class EventAnnotator(BaseAnnotator):
         self.extract_scatter_from_trajectories()
         self.give_cell_information()
 
-        self.correct_btn.disconnect()
+        try:
+            self.correct_btn.clicked.disconnect()
+        except TypeError:
+            pass  # No connections to disconnect
         self.correct_btn.clicked.connect(self.show_annotation_buttons)
-        # self.cancel_btn.click()
 
         self.hide_annotation_buttons()
         self.correct_btn.setEnabled(False)
@@ -652,73 +747,25 @@ class EventAnnotator(BaseAnnotator):
                     self.cell_ax.set_ylim(self.value_magnitude, self.non_log_ymax)
 
     def extract_scatter_from_trajectories(self):
-
+        """Extract scatter data from trajectories using efficient groupby."""
         self.positions = []
         self.colors = []
         self.tracks = []
 
-        for t in np.arange(self.len_movie):
-            self.positions.append(
-                self.df_tracks.loc[
-                    self.df_tracks["FRAME"] == t, ["x_anim", "y_anim"]
-                ].to_numpy()
-            )
-            self.colors.append(
-                self.df_tracks.loc[
-                    self.df_tracks["FRAME"] == t, ["class_color", "status_color"]
-                ].to_numpy()
-            )
-            self.tracks.append(
-                self.df_tracks.loc[self.df_tracks["FRAME"] == t, "TRACK_ID"].to_numpy()
-            )
-
-    # def load_annotator_config(self):
-    #
-    # 	"""
-    # 	Load settings from config or set default values.
-    # 	"""
-    #
-    # 	if os.path.exists(self.instructions_path):
-    # 		with open(self.instructions_path, 'r') as f:
-    #
-    # 			instructions = json.load(f)
-    #
-    # 			if 'rgb_mode' in instructions:
-    # 				self.rgb_mode = instructions['rgb_mode']
-    # 			else:
-    # 				self.rgb_mode = False
-    #
-    # 			if 'percentile_mode' in instructions:
-    # 				self.percentile_mode = instructions['percentile_mode']
-    # 			else:
-    # 				self.percentile_mode = True
-    #
-    # 			if 'channels' in instructions:
-    # 				self.target_channels = instructions['channels']
-    # 			else:
-    # 				self.target_channels = [[self.channel_names[0], 0.01, 99.99]]
-    #
-    # 			if 'fraction' in instructions:
-    # 				self.fraction = float(instructions['fraction'])
-    # 			else:
-    # 				self.fraction = 0.25
-    #
-    # 			if 'interval' in instructions:
-    # 				self.anim_interval = int(instructions['interval'])
-    # 			else:
-    # 				self.anim_interval = 1
-    #
-    # 			if 'log' in instructions:
-    # 				self.log_option = instructions['log']
-    # 			else:
-    # 				self.log_option = False
-    # 	else:
-    # 		self.rgb_mode = False
-    # 		self.log_option = False
-    # 		self.percentile_mode = True
-    # 		self.target_channels = [[self.channel_names[0], 0.01, 99.99]]
-    # 		self.fraction = 0.25
-    # 		self.anim_interval = 1
+        # Pre-allocate with empty arrays for all frames
+        for _ in range(self.len_movie):
+            self.positions.append(np.empty((0, 2)))
+            self.colors.append(np.empty((0, 2), dtype=object))
+            self.tracks.append(np.empty(0))
+
+        # Use groupby for efficient extraction
+        grouped = self.df_tracks.groupby("FRAME")
+        for frame, group in grouped:
+            frame = int(frame)
+            if 0 <= frame < self.len_movie:
+                self.positions[frame] = group[["x_anim", "y_anim"]].to_numpy()
+                self.colors[frame] = group[["class_color", "status_color"]].to_numpy()
+                self.tracks[frame] = group["TRACK_ID"].to_numpy()
 
     def prepare_stack(self, progress_callback=None):
 
@@ -808,6 +855,18 @@ class EventAnnotator(BaseAnnotator):
         except:
             pass
 
+    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.
@@ -849,12 +908,13 @@ class EventAnnotator(BaseAnnotator):
         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,  # Use generator to allow seamless restarts
             interval=self.anim_interval,  # in ms
             blit=True,
+            cache_frame_data=False,
         )
 
-        self.fig.canvas.mpl_connect("pick_event", self.on_scatter_pick)
+        self._pick_cid = self.fig.canvas.mpl_connect("pick_event", self.on_scatter_pick)
         self.fcanvas.canvas.draw()
 
     def select_single_cell(self, index, timepoint):
@@ -957,8 +1017,92 @@ class EventAnnotator(BaseAnnotator):
         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.
+        """
+        self.start_btn.hide()
+        self.stop_btn.show()
+
+        self.prev_frame_btn.setEnabled(False)
+        self.next_frame_btn.setEnabled(False)
+
+        self.anim.resume()
+        self.stop_btn.clicked.connect(self.stop)
+
+    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 toggle_animation(self):
+        if self.stop_btn.isVisible():
+            self.stop()
+        else:
+            self.start()
+
+    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:
+            # Disconnect the old pick event to avoid accumulating connections
+            if hasattr(self, "_pick_cid"):
+                try:
+                    self.fig.canvas.mpl_disconnect(self._pick_cid)
+                except Exception:
+                    pass
+
+            self.anim = FuncAnimation(
+                self.fig,
+                self.draw_frame,
+                frames=self.animation_generator,
+                interval=self.anim_interval,
+                blit=True,
+                cache_frame_data=False,
+            )
+
+            # Reconnect pick event and store cid
+            self._pick_cid = self.fig.canvas.mpl_connect(
+                "pick_event", self.on_scatter_pick
+            )
+
+            # 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 give_cell_information(self):
 
         cell_selected = f"cell: {self.track_of_interest}\n"
@@ -982,56 +1126,22 @@ class EventAnnotator(BaseAnnotator):
             self.compute_status_and_colors(0)
         self.extract_scatter_from_trajectories()
 
-    def set_last_frame(self):
-
-        self.last_frame_btn.setEnabled(False)
-        self.last_frame_btn.disconnect()
-
-        self.last_key = len(self.stack) - 1
-        while len(np.where(self.stack[self.last_key].flatten() == 0)[0]) > 0.99 * len(
-            self.stack[self.last_key].flatten()
-        ):
-            self.last_key -= 1
-        self.anim._drawn_artists = self.draw_frame(self.last_key)
-        self.anim._drawn_artists = sorted(
-            self.anim._drawn_artists, key=lambda x: x.get_zorder()
-        )
-        for a in self.anim._drawn_artists:
-            a.set_visible(True)
-
-        self.fig.canvas.draw()
-        self.anim.event_source.stop()
-
-        # self.cell_plot.draw()
-        self.stop_btn.hide()
-        self.start_btn.show()
-        self.stop_btn.clicked.connect(self.start)
-        self.start_btn.setShortcut(QKeySequence("l"))
-
     def set_first_frame(self):
+        self.stop()
+        self.framedata = 0
+        self.draw_frame(self.framedata)
+        self.fcanvas.canvas.draw()
 
-        self.first_frame_btn.setEnabled(False)
-        self.first_frame_btn.disconnect()
-
-        self.first_key = 0
-        self.anim._drawn_artists = self.draw_frame(0)
-        self.vmin = self.contrast_slider.value()[0]
-        self.vmax = self.contrast_slider.value()[1]
-        self.im.set_clim(vmin=self.vmin, vmax=self.vmax)
-
-        self.anim._drawn_artists = sorted(
-            self.anim._drawn_artists, key=lambda x: x.get_zorder()
-        )
-        for a in self.anim._drawn_artists:
-            a.set_visible(True)
-
-        self.fig.canvas.draw()
-        self.anim.event_source.stop()
-
-        # self.cell_plot.draw()
-        self.stop_btn.hide()
-        self.start_btn.show()
-        self.stop_btn.clicked.connect(self.start)
-        self.start_btn.setShortcut(QKeySequence("f"))
-
+    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()