celldetective 1.5.0b0__py3-none-any.whl → 1.5.0b2__py3-none-any.whl

celldetective/gui/process_block.py

@@ -9,6 +9,7 @@ from PyQt5.QtWidgets import (
     QHBoxLayout,
     QCheckBox,
     QMessageBox,
+    QApplication,
 )
 from PyQt5.QtCore import Qt, QSize, QTimer, QThread, pyqtSignal
 from superqt.fonticon import icon
@@ -30,13 +31,14 @@ from celldetective.gui.base.components import (
     CelldetectiveWidget,
     CelldetectiveProgressDialog,
     QHSeperationLine,
+    HoverButton,
 )
 
 import numpy as np
 from glob import glob
 from celldetective import get_logger
 
-logger = get_logger()
+logger = get_logger("celldetective")
 
 
 class NapariLoaderThread(QThread):
@@ -345,11 +347,12 @@ class ProcessPanel(QFrame, Styles):
         self.refresh_signal_models()
         # self.to_disable.append(self.cell_models_list)
 
-        self.train_signal_model_btn = QPushButton("TRAIN")
+        self.train_signal_model_btn = HoverButton(
+            "TRAIN", MDI6.redo_variant, "black", "white"
+        )
         self.train_signal_model_btn.setToolTip(
             "Train or retrain an event detection model\non newly annotated data."
         )
-        self.train_signal_model_btn.setIcon(icon(MDI6.redo_variant, color="black"))
         self.train_signal_model_btn.setIconSize(QSize(20, 20))
         self.train_signal_model_btn.setStyleSheet(self.button_style_sheet_3)
         model_zoo_layout.addWidget(self.train_signal_model_btn, 5)
@@ -557,8 +560,7 @@ class ProcessPanel(QFrame, Styles):
         self.seg_model_list.setGeometry(50, 50, 200, 30)
         self.init_seg_model_list()
 
-        self.upload_model_btn = QPushButton("UPLOAD")
-        self.upload_model_btn.setIcon(icon(MDI6.upload, color="black"))
+        self.upload_model_btn = HoverButton("UPLOAD", MDI6.upload, "black", "white")
         self.upload_model_btn.setIconSize(QSize(20, 20))
         self.upload_model_btn.setStyleSheet(self.button_style_sheet_3)
         self.upload_model_btn.setToolTip(
@@ -568,11 +570,10 @@ class ProcessPanel(QFrame, Styles):
         self.upload_model_btn.clicked.connect(self.upload_segmentation_model)
         # self.to_disable.append(self.upload_tc_model)
 
-        self.train_btn = QPushButton("TRAIN")
+        self.train_btn = HoverButton("TRAIN", MDI6.redo_variant, "black", "white")
         self.train_btn.setToolTip(
             "Train or retrain a segmentation model\non newly annotated data."
         )
-        self.train_btn.setIcon(icon(MDI6.redo_variant, color="black"))
         self.train_btn.setIconSize(QSize(20, 20))
         self.train_btn.setStyleSheet(self.button_style_sheet_3)
         self.train_btn.clicked.connect(self.open_segmentation_model_config_ui)
@@ -865,7 +866,7 @@ class ProcessPanel(QFrame, Styles):
             self.signal_loader.start()
 
     def check_measurements(self):
-        from celldetective.gui.event_annotator import MeasureAnnotator
+        from celldetective.gui.measure_annotator import MeasureAnnotator
 
         test = self.parent_window.locate_selected_position()
         if test:
@@ -1493,6 +1494,9 @@ class ProcessPanel(QFrame, Styles):
             window_title="Preparing the napari viewer...",
         )
 
+        self.napari_progress.setAutoClose(False)
+        self.napari_progress.setAutoReset(False)
+
         self.napari_progress.setValue(0)
         self.napari_loader.progress.connect(self.napari_progress.setValue)
         self.napari_loader.status.connect(self.napari_progress.setLabelText)
@@ -1502,13 +1506,15 @@ class ProcessPanel(QFrame, Styles):
             from celldetective.napari.utils import launch_napari_viewer
 
             self.napari_progress.blockSignals(True)
-            self.napari_progress.close()
+            # self.napari_progress.close()
             if self.napari_loader._is_cancelled:
                 logger.info("Task was cancelled...")
+                self.napari_progress.close()
                 return
 
             if isinstance(result, Exception):
                 logger.error(f"napari loading error: {result}")
+                self.napari_progress.close()
                 msgBox = QMessageBox()
                 msgBox.setIcon(QMessageBox.Warning)
                 msgBox.setText(str(result))
@@ -1519,13 +1525,33 @@ class ProcessPanel(QFrame, Styles):
 
             if result:
                 logger.info("Launching the napari viewer with tracks...")
+                self.napari_progress.setLabelText("Initializing Napari viewer...")
+                self.napari_progress.setRange(0, 0)
+                QApplication.processEvents()
+
+                def progress_cb(msg):
+                    if isinstance(msg, str):
+                        self.napari_progress.setLabelText(msg)
+                    QApplication.processEvents()
+
+                if "flush_memory" in result:
+                    result.pop("flush_memory")
+
                 try:
-                    launch_napari_viewer(**result)
+                    launch_napari_viewer(
+                        **result,
+                        block=False,
+                        flush_memory=False,
+                        progress_callback=progress_cb,
+                    )
                     logger.info("napari viewer was closed...")
                 except Exception as e:
                     logger.error(f"Failed to launch Napari: {e}")
                     QMessageBox.warning(self, "Error", f"Failed to launch Napari: {e}")
+                finally:
+                    self.napari_progress.close()
             else:
+                self.napari_progress.close()
                 logger.warning(
                     "napari loading returned None (likely no trajectories found)."
                 )
@@ -1540,33 +1566,61 @@ class ProcessPanel(QFrame, Styles):
 
     def view_table_ui(self):
         from celldetective.gui.tableUI import TableUI
+        from celldetective.gui.workers import ProgressWindow
+        from celldetective.processes.load_table import TableLoaderProcess
 
         logger.info("Load table...")
-        self.load_available_tables()
 
-        if self.df is not None:
-            plot_mode = "plot_track_signals"
-            if "TRACK_ID" not in list(self.df.columns):
-                plot_mode = "static"
-            self.tab_ui = TableUI(
-                self.df,
-                f"{self.parent_window.well_list.currentText()}; Position {self.parent_window.position_list.currentText()}",
-                population=self.mode,
-                plot_mode=plot_mode,
-                save_inplace_option=True,
-            )
-            self.tab_ui.show()
-            center_window(self.tab_ui)
-        else:
-            logger.info("Table could not be loaded...")
-            msgBox = QMessageBox()
-            msgBox.setIcon(QMessageBox.Warning)
-            msgBox.setText("No table could be loaded...")
-            msgBox.setWindowTitle("Info")
-            msgBox.setStandardButtons(QMessageBox.Ok)
-            returnValue = msgBox.exec()
-            if returnValue == QMessageBox.Ok:
-                return None
+        # Prepare args for the process
+        self.well_option = self.parent_window.well_list.getSelectedIndices()
+        self.position_option = self.parent_window.position_list.getSelectedIndices()
+
+        process_args = {
+            "experiment": self.exp_dir,
+            "population": self.mode,
+            "well_option": self.well_option,
+            "position_option": self.position_option,
+            "show_frame_progress": False,
+        }
+
+        self.df = None
+
+        def on_table_loaded(df):
+            self.df = df
+            if self.df is not None:
+                plot_mode = "plot_track_signals"
+                if "TRACK_ID" not in list(self.df.columns):
+                    plot_mode = "static"
+                self.tab_ui = TableUI(
+                    self.df,
+                    f"{self.parent_window.well_list.currentText()}; Position {self.parent_window.position_list.currentText()}",
+                    population=self.mode,
+                    plot_mode=plot_mode,
+                    save_inplace_option=True,
+                )
+                self.tab_ui.show()
+                center_window(self.tab_ui)
+            else:
+                logger.info("Table could not be loaded...")
+                msgBox = QMessageBox()
+                msgBox.setIcon(QMessageBox.Warning)
+                msgBox.setText("No table could be loaded...")
+                msgBox.setWindowTitle("Info")
+                msgBox.setStandardButtons(QMessageBox.Ok)
+                returnValue = msgBox.exec()
+
+        self.job = ProgressWindow(
+            TableLoaderProcess,
+            parent_window=self,
+            title="Loading tables...",
+            process_args=process_args,
+            position_info=False,
+            well_label="Wells loaded:",
+            pos_label="Positions loaded:",
+        )
+        self.job._ProgressWindow__runner.signals.result.connect(on_table_loaded)
+
+        result = self.job.exec_()
 
     def load_available_tables(self):
         """

celldetective/gui/viewers/base_viewer.py

@@ -1,7 +1,7 @@
 from collections import OrderedDict
 
 import numpy as np
-from PyQt5.QtCore import Qt
+from PyQt5.QtCore import Qt, QThread, pyqtSignal, QMutex, QWaitCondition
 from PyQt5.QtWidgets import QHBoxLayout, QAction, QLabel, QComboBox
 from fonticon_mdi6 import MDI6
 from superqt import QLabeledDoubleRangeSlider, QLabeledSlider
@@ -9,11 +9,111 @@ from superqt.fonticon import icon
 
 from celldetective.gui.base.components import CelldetectiveWidget
 from celldetective.gui.base.utils import center_window
-from celldetective.utils.image_loaders import auto_load_number_of_frames, _get_img_num_per_channel, load_frames
+from celldetective.utils.image_loaders import (
+    auto_load_number_of_frames,
+    _get_img_num_per_channel,
+    load_frames,
+)
 from celldetective import get_logger
 
 logger = get_logger(__name__)
 
+
+class StackLoader(QThread):
+    frame_loaded = pyqtSignal(int, int, np.ndarray)  # channel, frame_idx, image
+
+    def __init__(self, stack_path, img_num_per_channel, n_channels):
+        super().__init__()
+        self.stack_path = stack_path
+        self.img_num_per_channel = img_num_per_channel
+        self.n_channels = n_channels
+        self.target_channel = 0
+        self.priority_frame = 0
+        self.cache_keys = set()
+        self.running = True
+        self.mutex = QMutex()
+        self.condition = QWaitCondition()
+
+    def update_priority(self, channel, frame, current_cache_keys):
+        self.mutex.lock()
+        self.target_channel = channel
+        self.priority_frame = frame
+        self.cache_keys = set(current_cache_keys)
+        self.condition.wakeAll()
+        self.mutex.unlock()
+
+    def stop(self):
+        self.running = False
+        self.condition.wakeAll()
+        self.wait()
+
+    def run(self):
+        while self.running:
+            self.mutex.lock()
+            if not self.running:
+                self.mutex.unlock()
+                break
+
+            t_ch = self.target_channel
+            p_frame = self.priority_frame
+            keys_snapshot = list(self.cache_keys)
+            self.mutex.unlock()
+
+            # Determine next frame to load
+            # Strategy: look around priority frame
+            frame_to_load = -1
+
+            # Search radius
+            radius = 10
+            found = False
+
+            # Check immediate neighbors first
+            check_order = [p_frame]
+            for r in range(1, radius + 1):
+                check_order.append(p_frame + r)
+                check_order.append(p_frame - r)
+
+            # Determine max frames
+            max_frames = self.img_num_per_channel.shape[1]
+
+            for f in check_order:
+                if 0 <= f < max_frames:
+                    if (t_ch, f) not in keys_snapshot:
+                        frame_to_load = f
+                        found = True
+                        break
+
+            if found:
+                try:
+                    # Load the frame
+                    from celldetective.utils.image_loaders import load_frames
+
+                    img = load_frames(
+                        self.img_num_per_channel[t_ch, frame_to_load],
+                        self.stack_path,
+                        normalize_input=False,
+                    )[:, :, 0]
+
+                    self.frame_loaded.emit(t_ch, frame_to_load, img)
+
+                    # Update snapshot locally to avoid reloading immediately in next loop
+                    self.mutex.lock()
+                    self.cache_keys.add((t_ch, frame_to_load))
+                    self.mutex.unlock()
+
+                except Exception as e:
+                    pass
+                    # logger.error(f"Error loading frame {frame_to_load}: {e}")
+                    # Prepare to wait to avoid spin loop on error
+                    self.msleep(100)
+
+            else:
+                # If nothing to load, wait
+                self.mutex.lock()
+                self.condition.wait(self.mutex, 500)  # Wait 500ms or until new priority
+                self.mutex.unlock()
+
+
 class StackVisualizer(CelldetectiveWidget):
     """
     A widget for visualizing image stacks with interactive sliders and channel selection.
@@ -96,6 +196,7 @@ class StackVisualizer(CelldetectiveWidget):
         self._min = 0
         self._max = 0
 
+        self.loader_thread = None
         self.load_stack()
         self.generate_figure_canvas()
         if self.create_channel_cb:
@@ -113,7 +214,7 @@ class StackVisualizer(CelldetectiveWidget):
         self.is_drawing_line = False
         self.generate_custom_tools()
 
-        self.canvas.layout.setContentsMargins(15, 15, 15, 30)
+        self.canvas.layout.setContentsMargins(15, 15, 15, 15)
 
         center_window(self)
 
@@ -464,6 +565,13 @@ class StackVisualizer(CelldetectiveWidget):
             np.arange(self.n_channels), self.stack_length, self.n_channels
         )
 
+        # Initialize background loader
+        self.loader_thread = StackLoader(
+            self.stack_path, self.img_num_per_channel, self.n_channels
+        )
+        self.loader_thread.frame_loaded.connect(self.on_frame_loaded)
+        self.loader_thread.start()
+
         self.init_frame = load_frames(
             self.img_num_per_channel[self.target_channel, self.mid_time],
             self.stack_path,
@@ -647,6 +755,12 @@ class StackVisualizer(CelldetectiveWidget):
 
         self.current_time_index = value
 
+        # Update loader priority
+        if self.mode == "virtual" and self.loader_thread:
+            self.loader_thread.update_priority(
+                self.target_channel, value, self.frame_cache.keys()
+            )
+
         if self.mode == "direct":
             self.init_frame = self.stack[value, :, :, self.target_channel]
 
@@ -693,8 +807,25 @@ class StackVisualizer(CelldetectiveWidget):
         self.canvas.canvas.draw_idle()
         self.update_profile()
 
+    def on_frame_loaded(self, channel, frame, image):
+        """Callback from loader thread"""
+        # Store in cache
+        cache_key = (channel, frame)
+        if cache_key not in self.frame_cache:
+            self.frame_cache[cache_key] = image
+            if len(self.frame_cache) > self.max_cache_size:
+                self.frame_cache.popitem(last=False)
+
+        # If this is the current frame (user might have scrolled while loading), update display?
+        # Usually change_frame handles display. If we are waiting for this frame, we might want to refresh.
+        if channel == self.target_channel and frame == self.current_time_index:
+            # Refresh
+            self.change_frame(self.current_time_index)
+
     def closeEvent(self, event):
         # Event handler for closing the widget
+        if self.loader_thread:
+            self.loader_thread.stop()
         if hasattr(self, "frame_cache") and isinstance(self.frame_cache, OrderedDict):
             self.frame_cache.clear()
         self.canvas.close()

celldetective/gui/viewers/contour_viewer.py

@@ -118,10 +118,10 @@ class CellEdgeVisualizer(StackVisualizer):
             ), "Wrong dimensions for the provided labels, expect TXY"
             assert len(self.labels) == self.stack_length
 
-            self.mode = "direct"
+            self.label_mode = "direct"
             self.init_label = self.labels[self.mid_time, :, :]
         else:
-            self.mode = "virtual"
+            self.label_mode = "virtual"
             assert isinstance(self.stack_path, str)
             assert self.stack_path.endswith(".tif")
             self.locate_labels_virtual()
@@ -292,7 +292,7 @@ class CellEdgeVisualizer(StackVisualizer):
             self.sdf_cache.move_to_end(value)
         else:
             # Cache Miss: Load Label
-            if self.mode == "virtual":
+            if self.label_mode == "virtual":
                 if hasattr(self, "label_map") and value in self.label_map:
                     try:
                         self.init_label = imread(self.label_map[value])
@@ -300,7 +300,7 @@ class CellEdgeVisualizer(StackVisualizer):
                         self.init_label = np.zeros_like(self.init_frame)
                 else:
                     self.init_label = np.zeros_like(self.init_frame)
-            elif self.mode == "direct":
+            elif self.label_mode == "direct":
                 if value < len(self.labels):
                     self.init_label = self.labels[value, :, :]
                 else:

celldetective/gui/workers.py

@@ -21,6 +21,8 @@ class ProgressWindow(CelldetectiveDialog):
         title="",
         position_info=True,
         process_args=None,
+        well_label="Well progress:",
+        pos_label="Position progress:",
     ):
 
         super().__init__()
@@ -41,20 +43,26 @@ class ProgressWindow(CelldetectiveDialog):
         self.__label = QLabel("Idle")
         self.time_left_lbl = QLabel("")
 
-        self.well_time_lbl = QLabel("Well progress:")
+        self.well_time_lbl = QLabel(well_label)
         self.well_progress_bar = QProgressBar()
         self.well_progress_bar.setValue(0)
         self.well_progress_bar.setFormat("Total (Wells): %p%")
 
-        self.pos_time_lbl = QLabel("Position progress:")
+        self.pos_time_lbl = QLabel(pos_label)
         self.pos_progress_bar = QProgressBar()
         self.pos_progress_bar.setValue(0)
         self.pos_progress_bar.setFormat("Current Well (Positions): %p%")
 
-        self.frame_time_lbl = QLabel("Frame progress:")
-        self.frame_progress_bar = QProgressBar()
-        self.frame_progress_bar.setValue(0)
-        self.frame_progress_bar.setFormat("Current Position (Frames): %p%")
+        if "show_frame_progress" in process_args:
+            self.show_frame_progress = process_args["show_frame_progress"]
+        else:
+            self.show_frame_progress = True
+
+        if self.show_frame_progress:
+            self.frame_time_lbl = QLabel("Frame progress:")
+            self.frame_progress_bar = QProgressBar()
+            self.frame_progress_bar.setValue(0)
+            self.frame_progress_bar.setFormat("Current Position (Frames): %p%")
 
         self.__runner = Runner(
             process=self.__process,
@@ -73,8 +81,10 @@ class ProgressWindow(CelldetectiveDialog):
         self.__runner.signals.update_pos.connect(self.pos_progress_bar.setValue)
         self.__runner.signals.update_pos_time.connect(self.pos_time_lbl.setText)
 
-        self.__runner.signals.update_frame.connect(self.frame_progress_bar.setValue)
-        self.__runner.signals.update_frame_time.connect(self.frame_time_lbl.setText)
+        if self.show_frame_progress:
+            self.__runner.signals.update_frame.connect(self.frame_progress_bar.setValue)
+            self.__runner.signals.update_frame_time.connect(self.frame_time_lbl.setText)
+
         self.__runner.signals.update_status.connect(self.__label.setText)
         self.__runner.signals.update_image.connect(self.update_image)
 
@@ -96,8 +106,9 @@ class ProgressWindow(CelldetectiveDialog):
         self.progress_layout.addWidget(self.pos_time_lbl)
         self.progress_layout.addWidget(self.pos_progress_bar)
 
-        self.progress_layout.addWidget(self.frame_time_lbl)
-        self.progress_layout.addWidget(self.frame_progress_bar)
+        if self.show_frame_progress:
+            self.progress_layout.addWidget(self.frame_time_lbl)
+            self.progress_layout.addWidget(self.frame_progress_bar)
 
         self.btn_layout = QHBoxLayout()
         self.btn_layout.addWidget(self.__btn_stp)
@@ -266,6 +277,9 @@ class Runner(QRunnable):
                     if "training_result" in data:
                         self.signals.training_result.emit(data["training_result"])
 
+                    if "result" in data:
+                        self.signals.result.emit(data["result"])
+
                     if "status" in data:  # Moved this block out of frame_time check
                         logger.info(
                             f"Runner received status: {data['status']}"
@@ -312,7 +326,107 @@ class RunnerSignal(QObject):
     update_image = pyqtSignal(object)
     update_plot = pyqtSignal(dict)
     training_result = pyqtSignal(dict)
+    result = pyqtSignal(object)
     update_status = pyqtSignal(str)
 
     finished = pyqtSignal()
     error = pyqtSignal(str)
+
+
+class GenericProgressWindow(CelldetectiveDialog):
+
+    def __init__(
+        self,
+        process=None,
+        parent_window=None,
+        title="",
+        process_args=None,
+        label_text="Progress:",
+    ):
+
+        super().__init__()
+
+        self.setWindowTitle(f"{title}")
+        self.__process = process
+        self.parent_window = parent_window
+
+        self.__btn_stp = QPushButton("Cancel")
+        self.__label = QLabel("Idle")
+        self.progress_label = QLabel(label_text)
+
+        self.progress_bar = QProgressBar()
+        self.progress_bar.setValue(0)
+        self.progress_bar.setFormat("%p%")
+
+        self.__runner = Runner(
+            process=self.__process,
+            process_args=process_args,
+        )
+        logger.info("Runner initialized...")
+        self.pool = QThreadPool.globalInstance()
+
+        self.__btn_stp.clicked.connect(self.__stp_net)
+        self.__runner.signals.finished.connect(self.__on_finished)
+        self.__runner.signals.error.connect(self.__on_error)
+        self.__runner.signals.update_status.connect(self.__label.setText)
+
+        # Connect update_pos for generic progress (Runner maps generic list progress to update_pos)
+        self.__runner.signals.update_pos.connect(self.progress_bar.setValue)
+
+        self.__btn_stp.setDisabled(True)
+
+        self.layout = QVBoxLayout()
+        self.layout.addWidget(self.progress_label)
+        self.layout.addWidget(self.progress_bar)
+
+        self.btn_layout = QHBoxLayout()
+        self.btn_layout.addWidget(self.__btn_stp)
+        self.btn_layout.addWidget(self.__label)
+
+        self.layout.addLayout(self.btn_layout)
+
+        self.setLayout(self.layout)
+        self.setFixedSize(QSize(400, 150))
+        self.show()
+        self.raise_()
+        self.activateWindow()
+        logger.info("GenericProgressWindow initialized and shown.")
+        self.__run_net()
+        self.setModal(True)
+
+    def closeEvent(self, evnt):
+        evnt.ignore()
+        self.setWindowState(Qt.WindowMinimized)
+
+    def __run_net(self):
+        self.__btn_stp.setEnabled(True)
+        self.__label.setText("Running...")
+        self.pool.start(self.__runner)
+
+    def __stp_net(self):
+        self.__runner.close()
+        logger.info("\n Job cancelled... Abort.")
+        self.reject()
+
+    def __on_finished(self):
+        self.__btn_stp.setDisabled(True)
+        self.__label.setText("\nFinished!")
+        self.__runner.close()
+        self.accept()
+
+    def __on_error(self, message="Error"):
+        self.__btn_stp.setDisabled(True)
+        self.__label.setText("\nError")
+        self.__runner.close()
+
+        # Show error in a message box to ensure it's seen
+        from PyQt5.QtWidgets import QMessageBox
+
+        msg = QMessageBox()
+        msg.setIcon(QMessageBox.Critical)
+        msg.setText("Process failed")
+        msg.setInformativeText(str(message))
+        msg.setWindowTitle("Error")
+        msg.exec_()
+
+        self.reject()

celldetective/measure.py

@@ -5,6 +5,7 @@ import subprocess
 from math import ceil
 from functools import reduce
 from inspect import getmembers, isfunction
+from celldetective.gui.base.utils import pretty_table
 
 from celldetective.exceptions import EmptyQueryError, MissingColumnsError, QueryError
 from celldetective.utils.masks import (
@@ -1894,6 +1895,8 @@ def measure_radial_distance_to_center(
 ):
 
     try:
+        df[column_labels["x"]] = df[column_labels["x"]].astype(float)
+        df[column_labels["y"]] = df[column_labels["y"]].astype(float)
         df["radial_distance"] = np.sqrt(
             (df[column_labels["x"]] - volume[0] / 2) ** 2
             + (df[column_labels["y"]] - volume[1] / 2) ** 2