celldetective 1.5.0b3__tar.gz → 1.5.0b5__tar.gz

{celldetective-1.5.0b3 → celldetective-1.5.0b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celldetective
-Version: 1.5.0b3
+Version: 1.5.0b5
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro

celldetective-1.5.0b5/celldetective/_version.py

@@ -0,0 +1 @@
+__version__ = "1.5.0b5"

{celldetective-1.5.0b3 → celldetective-1.5.0b5}/celldetective/gui/base/figure_canvas.py

@@ -22,19 +22,33 @@ class FigureCanvas(CelldetectiveWidget):
             from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT
 
             self.toolbar = NavigationToolbar2QT(self.canvas)
+            self.toolbar.setStyleSheet(
+                "QToolButton:hover {background-color: lightgray;} QToolButton {background-color: transparent; border: none;}"
+            )
         self.layout = QVBoxLayout(self)
         self.layout.addWidget(self.canvas, 90)
         if interactive:
             self.layout.addWidget(self.toolbar)
 
-        #center_window(self)
+        self.manual_layout = False
+        # center_window(self)
         self.setAttribute(Qt.WA_DeleteOnClose)
 
     def resizeEvent(self, event):
-
+        print("DEBUG: resizeEvent called")
         super().resizeEvent(event)
         try:
-            self.fig.tight_layout()
+            manual_layout = getattr(self, "manual_layout", False)
+
+            # Double check for profile axes manually (robust fallback)
+            if not manual_layout and hasattr(self.fig, "axes"):
+                for ax in self.fig.axes:
+                    if ax.get_label() == "profile_axes":
+                        manual_layout = True
+                        break
+
+            if not manual_layout:
+                self.fig.tight_layout()
         except:
             pass
 

{celldetective-1.5.0b3 → celldetective-1.5.0b5}/celldetective/gui/measure_annotator.py

@@ -950,9 +950,9 @@ class MeasureAnnotator(BaseAnnotator):
                 ].to_numpy()
             )
             self.colors.append(
-                self.df_tracks.loc[
-                    self.df_tracks["FRAME"] == t, ["group_color"]
-                ].to_numpy()
+                self.df_tracks.loc[self.df_tracks["FRAME"] == t, ["group_color"]]
+                .to_numpy()
+                .copy()
             )
             if "TRACK_ID" in self.df_tracks.columns:
                 self.tracks.append(

{celldetective-1.5.0b3 → celldetective-1.5.0b5}/celldetective/gui/settings/_settings_segmentation_model_training.py

@@ -84,6 +84,12 @@ class SettingsSegmentationModelTraining(CelldetectiveSettingsPanel):
         self.bg_loader = BackgroundLoader()
         self.bg_loader.start()
 
+    def closeEvent(self, event):
+        if self.bg_loader.isRunning():
+            logger.info("Waiting for background loader to finish...")
+            self.bg_loader.wait()
+        super().closeEvent(event)
+
     def _add_to_layout(self):
 
         self._layout.addWidget(self.model_frame)

{celldetective-1.5.0b3 → celldetective-1.5.0b5}/celldetective/gui/viewers/base_viewer.py

@@ -111,6 +111,11 @@ class StackLoader(QThread):
                 # If nothing to load, wait
                 self.mutex.lock()
                 self.condition.wait(self.mutex, 500)  # Wait 500ms or until new priority
+
+                if not self.running:
+                    self.mutex.unlock()
+                    break
+
                 self.mutex.unlock()
 
 
@@ -280,6 +285,10 @@ class StackVisualizer(CelldetectiveWidget):
             self.lock_y_action.setEnabled(True)
             self.canvas.toolbar.mode = ""
 
+            # Enable manual layout control to prevent tight_layout interference
+            if hasattr(self.canvas, "manual_layout"):
+                self.canvas.manual_layout = True
+
             # Connect events
             self.cid_press = self.fig.canvas.mpl_connect(
                 "button_press_event", self.on_line_press
@@ -292,8 +301,8 @@ class StackVisualizer(CelldetectiveWidget):
             )
 
             # Save original position if not saved
-            if not hasattr(self, "ax_original_pos"):
-                self.ax_original_pos = self.ax.get_position()
+            # if not hasattr(self, "ax_original_pos"):
+            #     self.ax_original_pos = self.ax.get_position()
 
             # Disable tight_layout/layout engine to prevent fighting manual positioning
             if hasattr(self.fig, "set_layout_engine"):
@@ -329,6 +338,7 @@ class StackVisualizer(CelldetectiveWidget):
                 self.ax_profile.set_position(gs[1].get_position(self.fig))
 
             self.ax_profile.set_visible(True)
+            self.ax_profile.set_label("profile_axes")
             self.ax_profile.set_facecolor("none")
             self.ax_profile.tick_params(axis="y", which="major", labelsize=8)
             self.ax_profile.set_xticks([])
@@ -341,11 +351,40 @@ class StackVisualizer(CelldetectiveWidget):
             self.ax_profile.spines["bottom"].set_color("black")
             self.ax_profile.spines["left"].set_color("black")
 
+            # Update Toolbar Home State to match new layout BUT with full field of view
+            # 1. Save current zoom
+            current_xlim = self.ax.get_xlim()
+            current_ylim = self.ax.get_ylim()
+
+            # 2. Set limits to full extent (Home State)
+            if hasattr(self, "im"):
+                extent = self.im.get_extent()  # (left, right, bottom, top) or similar
+                self.ax.set_xlim(extent[0], extent[1])
+                self.ax.set_ylim(extent[2], extent[3])
+
+            # 3. Reset Stack and save Home
+            self.canvas.toolbar._nav_stack.clear()
+            self.canvas.toolbar.push_current()
+
+            # 4. Restore User Zoom
+            self.ax.set_xlim(current_xlim)
+            self.ax.set_ylim(current_ylim)
+
+            # 5. Push restored zoom state so "Back"/"Forward" logic works from here?
+            # Actually, if we just restore, we are "live" at a new state.
+            # If we don't push, "Home" works. "Back" might not exist yet. That's fine.
+            self.canvas.toolbar.push_current()
+
             self.canvas.draw()
         else:
             self.line_mode = False
             self.lock_y_action.setChecked(False)
             self.lock_y_action.setEnabled(False)
+
+            # Disable manual layout control
+            if hasattr(self.canvas, "manual_layout"):
+                self.canvas.manual_layout = False
+
             # Disconnect events
             if hasattr(self, "cid_press"):
                 self.fig.canvas.mpl_disconnect(self.cid_press)
@@ -367,17 +406,24 @@ 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))
-                self.fig.subplots_adjust(
-                    top=1, bottom=0, right=1, left=0, hspace=0, wspace=0
-                )
-                # self.ax.set_position(self.ax_original_pos) # tight layout should fix it
+            # 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))
+            self.fig.subplots_adjust(
+                top=1, bottom=0, right=1, left=0, hspace=0, wspace=0
+            )
+            # self.ax.set_position(self.ax_original_pos) # tight layout should fix it
+
+            # Re-enable tight_layout via standard resize event later or explicit call
+            self.fig.tight_layout()
+
+            # Reset Toolbar Stack for Standard View
+            self.canvas.toolbar._nav_stack.clear()
+            self.canvas.toolbar.push_current()
 
             self.canvas.draw()
             self.info_lbl.setText("")
@@ -548,7 +594,10 @@ class StackVisualizer(CelldetectiveWidget):
             self.mode = "direct"
             self.stack_length = len(self.stack)
             self.mid_time = self.stack_length // 2
-            self.init_frame = self.stack[self.mid_time, :, :, self.target_channel]
+            self.current_time_index = 0
+            self.init_frame = self.stack[
+                self.current_time_index, :, :, self.target_channel
+            ]
             self.last_frame = self.stack[-1, :, :, self.target_channel]
         else:
             self.mode = "virtual"
@@ -561,6 +610,7 @@ class StackVisualizer(CelldetectiveWidget):
 
         self.stack_length = auto_load_number_of_frames(self.stack_path)
         self.mid_time = self.stack_length // 2
+        self.current_time_index = 0
         self.img_num_per_channel = _get_img_num_per_channel(
             np.arange(self.n_channels), self.stack_length, self.n_channels
         )
@@ -573,7 +623,7 @@ class StackVisualizer(CelldetectiveWidget):
         self.loader_thread.start()
 
         self.init_frame = load_frames(
-            self.img_num_per_channel[self.target_channel, self.mid_time],
+            self.img_num_per_channel[self.target_channel, self.current_time_index],
             self.stack_path,
             normalize_input=False,
         )[:, :, 0]
@@ -708,7 +758,7 @@ class StackVisualizer(CelldetectiveWidget):
         layout = QHBoxLayout()
         self.frame_slider = QLabeledSlider(Qt.Horizontal)
         self.frame_slider.setRange(0, self.stack_length - 1)
-        self.frame_slider.setValue(self.mid_time)
+        self.frame_slider.setValue(self.current_time_index)
         self.frame_slider.valueChanged.connect(self.change_frame)
         layout.addWidget(QLabel("Time: "), 15)
         layout.addWidget(self.frame_slider, 85)
@@ -716,7 +766,7 @@ class StackVisualizer(CelldetectiveWidget):
 
     def set_target_channel(self, value):
         self.target_channel = value
-        self.init_frame = self.stack[self.mid_time, :, :, self.target_channel]
+        self.init_frame = self.stack[self.current_time_index, :, :, self.target_channel]
         self.im.set_data(self.init_frame)
         self.canvas.draw()
         self.update_profile()
@@ -734,7 +784,9 @@ class StackVisualizer(CelldetectiveWidget):
             self.change_frame_from_channel_switch(self.frame_slider.value())
         else:
             if self.stack is not None and self.stack.ndim == 4:
-                self.init_frame = self.stack[self.mid_time, :, :, self.target_channel]
+                self.init_frame = self.stack[
+                    self.current_time_index, :, :, self.target_channel
+                ]
                 self.im.set_data(self.init_frame)
                 self.canvas.draw()
                 self.update_profile()
@@ -747,7 +799,8 @@ class StackVisualizer(CelldetectiveWidget):
             p01 = np.nanpercentile(self.init_frame, 0.1)
             p99 = np.nanpercentile(self.init_frame, 99.9)
             self.im.set_clim(vmin=p01, vmax=p99)
-            self.contrast_slider.setValue((p01, p99))
+            if self.create_contrast_slider and hasattr(self, "contrast_slider"):
+                self.contrast_slider.setValue((p01, p99))
             self.channel_trigger = False
             self.canvas.draw()
 

{celldetective-1.5.0b3 → celldetective-1.5.0b5}/celldetective/gui/viewers/channel_offset_viewer.py

@@ -9,11 +9,16 @@ from superqt import QLabeledDoubleSlider, QLabeledDoubleRangeSlider
 from celldetective.gui.base.components import QHSeperationLine
 from celldetective.gui.gui_utils import QuickSliderLayout, ThresholdLineEdit
 from celldetective.gui.viewers.base_viewer import StackVisualizer
-from celldetective.utils.image_loaders import load_frames, auto_load_number_of_frames, _get_img_num_per_channel
+from celldetective.utils.image_loaders import (
+    load_frames,
+    auto_load_number_of_frames,
+    _get_img_num_per_channel,
+)
 from celldetective import get_logger
 
 logger = get_logger(__name__)
 
+
 class ChannelOffsetViewer(StackVisualizer):
 
     def __init__(self, parent_window=None, *args, **kwargs):
@@ -22,16 +27,32 @@ class ChannelOffsetViewer(StackVisualizer):
         self.overlay_target_channel = -1
         self.shift_vertical = 0
         self.shift_horizontal = 0
+        self.overlay_init_contrast = False
         super().__init__(*args, **kwargs)
 
         self.load_stack()
+
+        if self.mode == "direct":
+            # Initialize overlay frames for direct mode
+            default_overlay_idx = -1
+            if self.stack.ndim == 4:
+                self.overlay_init_frame = self.stack[
+                    self.current_time_index, :, :, default_overlay_idx
+                ]
+                self.overlay_last_frame = self.stack[-1, :, :, default_overlay_idx]
+            else:
+                # Should rely on 4D stack assumption from StackVisualizer
+                self.overlay_init_frame = self.init_frame
+                self.overlay_last_frame = self.last_frame
+
         self.canvas.layout.addWidget(QHSeperationLine())
 
         self.generate_overlay_channel_cb()
         self.generate_overlay_imshow()
 
         self.generate_overlay_alpha_slider()
-        self.generate_overlay_contrast_slider()
+        if self.create_contrast_slider:
+            self.generate_overlay_contrast_slider()
 
         self.generate_overlay_shift()
         self.generate_add_to_parent_btn()
@@ -190,7 +211,7 @@ class ChannelOffsetViewer(StackVisualizer):
 
         self.im_overlay.set_data(self.overlay_init_frame)
 
-        if self.overlay_init_contrast:
+        if self.overlay_init_contrast and self.create_contrast_slider:
             self.im_overlay.autoscale()
             I_min, I_max = self.im_overlay.get_clim()
             self.overlay_contrast_slider.setRange(
@@ -214,12 +235,13 @@ class ChannelOffsetViewer(StackVisualizer):
             gc.collect()
 
         self.mid_time = self.stack_length // 2
+        self.current_time_index = 0
         self.img_num_per_channel = _get_img_num_per_channel(
             np.arange(self.n_channels), self.stack_length, self.n_channels
         )
 
         self.init_frame = load_frames(
-            self.img_num_per_channel[self.target_channel, self.mid_time],
+            self.img_num_per_channel[self.target_channel, self.current_time_index],
             self.stack_path,
             normalize_input=False,
         ).astype(float)[:, :, 0]
@@ -229,7 +251,9 @@ class ChannelOffsetViewer(StackVisualizer):
             normalize_input=False,
         ).astype(float)[:, :, 0]
         self.overlay_init_frame = load_frames(
-            self.img_num_per_channel[self.overlay_target_channel, self.mid_time],
+            self.img_num_per_channel[
+                self.overlay_target_channel, self.current_time_index
+            ],
             self.stack_path,
             normalize_input=False,
         ).astype(float)[:, :, 0]
@@ -306,6 +330,7 @@ class ChannelOffsetViewer(StackVisualizer):
         )
         self.im_overlay.set_data(self.shifted_frame)
         self.fig.canvas.draw_idle()
+        self.update_profile()
 
     def generate_add_to_parent_btn(self):
 
@@ -318,6 +343,95 @@ class ChannelOffsetViewer(StackVisualizer):
         add_hbox.addWidget(QLabel(""), 33)
         self.canvas.layout.addLayout(add_hbox)
 
+    def update_profile(self):
+        if not self.line_mode or not hasattr(self, "line_x") or not self.line_x:
+            return
+
+        # Calculate profile
+        x0, y0 = self.line_x[0], self.line_y[0]
+        x1, y1 = self.line_x[1], self.line_y[1]
+        length_px = np.hypot(x1 - x0, y1 - y0)
+        if length_px == 0:
+            return
+
+        num_points = int(length_px)
+        if num_points < 2:
+            num_points = 2
+
+        x, y = np.linspace(x0, x1, num_points), np.linspace(y0, y1, num_points)
+
+        # Use self.init_frame and overlay frame
+        profiles = []
+        colors = ["black", "tab:blue"]
+
+        # Main channel profile
+        if hasattr(self, "init_frame") and self.init_frame is not None:
+            from scipy.ndimage import map_coordinates
+
+            profile = map_coordinates(
+                self.init_frame, np.vstack((y, x)), order=1, mode="nearest"
+            )
+            profiles.append(profile)
+        else:
+            profiles.append(None)
+
+        # Overlay channel profile
+        # Use data currently in im_overlay, which accounts for shifts
+        overlay_data = self.im_overlay.get_array()
+        if overlay_data is not None:
+            from scipy.ndimage import map_coordinates
+
+            profile_overlay = map_coordinates(
+                overlay_data, np.vstack((y, x)), order=1, mode="nearest"
+            )
+            profiles.append(profile_overlay)
+        else:
+            profiles.append(None)
+
+        # Basic setup
+        self.ax_profile.clear()
+        self.ax_profile.set_facecolor("none")
+
+        # Distance axis
+        dist_axis = np.arange(num_points)
+        title_str = f"{round(length_px,2)} [px]"
+        if self.PxToUm is not None:
+            title_str += f" | {round(length_px*self.PxToUm,3)} [µm]"
+
+        # Handle Y-Axis Locking
+        current_ylim = None
+        if self.lock_y_action.isChecked():
+            current_ylim = self.ax_profile.get_ylim()
+
+        # Plot profiles
+        for i, (profile, color) in enumerate(zip(profiles, colors)):
+            if profile is not None:
+                if np.all(np.isnan(profile)):
+                    profile = np.zeros_like(profile)
+                    profile[:] = np.nan
+
+                self.ax_profile.plot(
+                    dist_axis, profile, color=color, linestyle="-", label=f"Ch{i}"
+                )
+
+        self.ax_profile.set_xticks([])
+        self.ax_profile.set_ylabel("Intensity", fontsize=8)
+        self.ax_profile.set_xlabel(title_str, fontsize=8)
+        self.ax_profile.tick_params(axis="y", which="major", labelsize=6)
+
+        # Hide spines
+        self.ax_profile.spines["top"].set_visible(False)
+        self.ax_profile.spines["right"].set_visible(False)
+        self.ax_profile.spines["bottom"].set_color("black")
+        self.ax_profile.spines["left"].set_color("black")
+
+        self.fig.set_facecolor("none")
+
+        if current_ylim:
+            self.ax_profile.set_ylim(current_ylim)
+
+        self.fig.canvas.draw_idle()
+
     def set_parent_attributes(self):
 
         idx = self.channels_overlay_cb.currentIndex()

{celldetective-1.5.0b3 → celldetective-1.5.0b5}/celldetective/gui/viewers/threshold_viewer.py

@@ -65,8 +65,6 @@ class ThresholdedStackVisualizer(StackVisualizer):
         self.thresh_min = 0.0
         self.thresh_max = 30.0
 
-        self.thresh_max = 30.0
-
         # Cache for processed images
         self.processed_cache = OrderedDict()
         self.processed_image = None
@@ -74,6 +72,15 @@ class ThresholdedStackVisualizer(StackVisualizer):
 
         self.generate_threshold_slider()
 
+        # Ensure we start at frame 0 for consistent mask caching and UX
+        if self.create_frame_slider and hasattr(self, "frame_slider"):
+            self.frame_slider.blockSignals(True)
+            self.frame_slider.setValue(0)
+            self.frame_slider.blockSignals(False)
+            self.change_frame(0)
+        elif self.stack_length > 0:
+            self.change_frame(0)
+
         if self.thresh is not None:
             self.compute_mask(self.thresh)
 
@@ -138,8 +145,8 @@ class ThresholdedStackVisualizer(StackVisualizer):
             slider_range=(self.thresh_min, np.amax([self.thresh_max, init_value])),
             decimal_option=True,
             precision=4,
+            layout_ratio=(0.15, 0.85),
         )
-        thresh_layout.setContentsMargins(15, 0, 15, 0)
         self.threshold_slider.valueChanged.connect(self.change_threshold)
         if self.show_threshold_slider:
             self.canvas.layout.addLayout(thresh_layout)
@@ -154,8 +161,8 @@ class ThresholdedStackVisualizer(StackVisualizer):
             slider_range=(0, 1),
             decimal_option=True,
             precision=3,
+            layout_ratio=(0.15, 0.85),
         )
-        opacity_layout.setContentsMargins(15, 0, 15, 0)
         self.opacity_slider.valueChanged.connect(self.change_mask_opacity)
         if self.show_opacity_slider:
             self.canvas.layout.addLayout(opacity_layout)
@@ -190,7 +197,8 @@ class ThresholdedStackVisualizer(StackVisualizer):
         if self.thresh is not None:
             self.compute_mask(self.thresh)
             mask = np.ma.masked_where(self.mask == 0, self.mask)
-            self.im_mask.set_data(mask)
+            if hasattr(self, "im_mask"):
+                self.im_mask.set_data(mask)
             self.canvas.canvas.draw_idle()
 
     def change_frame(self, value):
@@ -219,7 +227,7 @@ class ThresholdedStackVisualizer(StackVisualizer):
             threshold_image,
         )
 
-        edge = estimate_unreliable_edge(self.preprocessing)
+        edge = estimate_unreliable_edge(self.preprocessing or [])
 
         if isinstance(threshold_value, (list, np.ndarray, tuple)):
             self.mask = threshold_image(

{celldetective-1.5.0b3 → celldetective-1.5.0b5}/celldetective/utils/cellpose_utils/__init__.py

@@ -113,13 +113,29 @@ def _prep_cellpose_model(
 
     from cellpose.models import CellposeModel
 
-    model = CellposeModel(
-        gpu=use_gpu,
-        device=device,
-        pretrained_model=path + model_name,
-        model_type=None,
-        nchan=n_channels,
-    )  # diam_mean=30.0,
+    try:
+        model = CellposeModel(
+            gpu=use_gpu,
+            device=device,
+            pretrained_model=path + model_name,
+            model_type=None,
+            nchan=n_channels,
+        )  # diam_mean=30.0,
+    except AssertionError as e:
+        if use_gpu:
+            print(
+                f"[WARNING] Could not load Cellpose model with GPU ({e}). Retrying with CPU..."
+            )
+            device = torch.device("cpu")
+            model = CellposeModel(
+                gpu=False,
+                device=device,
+                pretrained_model=path + model_name,
+                model_type=None,
+                nchan=n_channels,
+            )
+        else:
+            raise e
     if scale is None:
         scale_model = model.diam_mean / model.diam_labels
     else:

{celldetective-1.5.0b3 → celldetective-1.5.0b5}/celldetective.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: celldetective
-Version: 1.5.0b3
+Version: 1.5.0b5
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro

{celldetective-1.5.0b3 → celldetective-1.5.0b5}/celldetective.egg-info/SOURCES.txt

@@ -177,6 +177,7 @@ celldetective/utils/plots/__init__.py
 celldetective/utils/plots/regression.py
 celldetective/utils/stardist_utils/__init__.py
 tests/__init__.py
+tests/test_cellpose_fallback.py
 tests/test_events.py
 tests/test_filters.py
 tests/test_io.py
@@ -190,5 +191,6 @@ tests/test_tracking.py
 tests/test_utils.py
 tests/gui/__init__.py
 tests/gui/test_enhancements.py
+tests/gui/test_measure_annotator_bugfix.py
 tests/gui/test_new_project.py
 tests/gui/test_project.py