celldetective 1.5.0b1__py3-none-any.whl → 1.5.0b3__py3-none-any.whl

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,6 +326,7 @@ class RunnerSignal(QObject):
     update_image = pyqtSignal(object)
     update_plot = pyqtSignal(dict)
     training_result = pyqtSignal(dict)
+    result = pyqtSignal(object)
     update_status = pyqtSignal(str)
 
     finished = pyqtSignal()

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

celldetective/napari/utils.py

@@ -27,6 +27,7 @@ from celldetective.utils.experiment import (
 )
 from celldetective.utils.parsing import config_section_to_dict
 from celldetective import get_logger
+from celldetective.gui.base.styles import Styles
 
 logger = get_logger()
 
@@ -87,10 +88,16 @@ def control_tracks(
         position += os.sep
 
     position = position.replace("\\", "/")
+    if progress_callback:
+        progress_callback(0)
+
     stack, labels = locate_stack_and_labels(
         position, prefix=prefix, population=population
     )
 
+    if progress_callback:
+        progress_callback(25)
+
     return view_tracks_in_napari(
         position,
         population,
@@ -130,7 +137,13 @@ def view_tracks_in_napari(
     Updated
     """
 
+    print(f"DEBUG: view_tracks_in_napari called with pos={position}, pop={population}")
     df, df_path = get_position_table(position, population=population, return_path=True)
+    print(f"DEBUG: get_position_table returned df={df is not None}")
+
+    if progress_callback:
+        progress_callback(50)
+
     if df is None:
         print("Please compute trajectories first... Abort...")
         return None
@@ -144,12 +157,18 @@ def view_tracks_in_napari(
 
     if (labels is not None) * relabel:
         print("Replacing the cell mask labels with the track ID...")
+
+        def wrapped_callback(p):
+            if progress_callback:
+                return progress_callback(50 + int(p * 0.5))
+            return True
+
         labels = relabel_segmentation(
             labels,
             df,
             exclude_nans=True,
             threads=threads,
-            progress_callback=progress_callback,
+            progress_callback=wrapped_callback,
         )
         if labels is None:
             return None
@@ -186,9 +205,12 @@ def launch_napari_viewer(
     shared_data,
     contrast_limits,
     flush_memory=True,
+    block=True,
+    progress_callback=None,
 ):
 
     viewer = napari.Viewer()
+
     if stack is not None:
         viewer.add_image(
             stack,
@@ -196,6 +218,7 @@ def launch_napari_viewer(
             colormap=["gray"] * stack.shape[-1],
             contrast_limits=contrast_limits,
         )
+
     if labels is not None:
         labels_layer = viewer.add_labels(
             labels.astype(int), name="segmentation", opacity=0.4
@@ -274,8 +297,6 @@ def launch_napari_viewer(
     def export_table_widget():
         return export_modifications()
 
-    from celldetective.gui.base.styles import Styles
-
     export_table_widget.native.setStyleSheet(Styles().button_style_sheet)
 
     def label_changed(event):
@@ -426,9 +447,9 @@ def launch_napari_viewer(
 
         shared_data["df"] = df
 
-    viewer.show(block=True)
+    viewer.show(block=block)
 
-    if flush_memory:
+    if flush_memory and block:
 
         # temporary fix for slight napari memory leak
         for i in range(10000):
@@ -781,8 +802,6 @@ def control_segmentation_napari(
     def export_widget():
         return export_annotation()
 
-    from celldetective.gui.base.styles import Styles
-
     stack, labels = locate_stack_and_labels(
         position, prefix=prefix, population=population
     )
@@ -889,22 +908,13 @@ def correct_annotation(filename):
         stack,
         channel_axis=-1,
         colormap=["gray"] * stack.shape[-1],
-        constrast_limits=contrast_limits,
+        contrast_limits=contrast_limits,
     )
     viewer.add_labels(labels, name="segmentation", opacity=0.4)
     viewer.window.add_dock_widget(save_widget, area="right")
-    viewer.show(block=True)
+    save_widget.native.setStyleSheet(Styles().button_style_sheet)
 
-    # temporary fix for slight napari memory leak
-    for i in range(100):
-        try:
-            viewer.layers.pop()
-        except:
-            pass
-    del viewer
-    del stack
-    del labels
-    gc.collect()
+    viewer.show(block=False)
 
 
 def _view_on_napari(tracks=None, stack=None, labels=None):

celldetective/processes/load_table.py

@@ -0,0 +1,55 @@
+import time
+from multiprocessing import Process
+from celldetective.utils.data_loaders import load_experiment_tables
+from celldetective import get_logger
+
+logger = get_logger()
+
+
+class TableLoaderProcess(Process):
+
+    def __init__(self, queue=None, process_args=None, *args, **kwargs):
+
+        super().__init__(*args, **kwargs)
+
+        if process_args is not None:
+            for key, value in process_args.items():
+                setattr(self, key, value)
+
+        self.queue = queue
+
+    def run(self):
+
+        def progress(well_progress, pos_progress):
+            # Check for cancellation if needed?
+            # The runner checks queue for instructions? No, runner closes queue.
+            # But here we can just push updates.
+            self.queue.put(
+                {
+                    "well_progress": well_progress,
+                    "pos_progress": pos_progress,
+                    "status": f"Loading tables... Well {well_progress}%, Position {pos_progress}%",
+                }
+            )
+            return True  # continue
+
+        try:
+            self.queue.put({"status": "Started loading..."})
+
+            df = load_experiment_tables(
+                experiment=self.experiment,
+                population=self.population,
+                well_option=self.well_option,
+                position_option=self.position_option,
+                return_pos_info=False,
+                progress_callback=progress,
+            )
+
+            self.queue.put({"status": "finished", "result": df})
+
+        except Exception as e:
+            logger.error(f"Table loading failed: {e}")
+            self.queue.put({"status": "error", "message": str(e)})
+
+    def end_process(self):
+        self.terminate()