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

celldetective/_version.py

@@ -1 +1 @@
-__version__ = "1.5.0b3"
+__version__ = "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/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/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/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/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/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/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.dist-info → celldetective-1.5.0b5.dist-info}/METADATA

@@ -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.dist-info → celldetective-1.5.0b5.dist-info}/RECORD

@@ -1,6 +1,6 @@
 celldetective/__init__.py,sha256=LfnOyfUnYPGDc8xcsF_PfYEL7-CqAb7BMBPBIWGv84o,666
 celldetective/__main__.py,sha256=Rzzu9ArxZSgfBVjV-lyn-3oanQB2MumQR6itK5ZaRpA,2597
-celldetective/_version.py,sha256=xyBMhGEXnWbOInuedgW565vK5NILuhG2r2EYCw9E9eU,24
+celldetective/_version.py,sha256=WqWa8H3XCjzmFMLQoflfXoLyQGm-ej1fcgZfMqTF--U,24
 celldetective/events.py,sha256=n15R53c7QZ2wT8gjb0oeNikQbuRBrVVbyNsRCqXjzXA,8166
 celldetective/exceptions.py,sha256=f3VmIYOthWTiqMEV5xQCox2rw5c5e7yog88h-CcV4oI,356
 celldetective/extra_properties.py,sha256=s_2R4_El2p-gQNZ_EpgDxgrN3UnRitN7KDKHhyLuoHc,21681
@@ -30,7 +30,7 @@ celldetective/gui/gui_utils.py,sha256=t6SjEfjcaRH9a0TlbTGEiVRpCgocaCh4lgkIvRgRRw
 celldetective/gui/interactions_block.py,sha256=34VaHFrdKsq1hYuXrosmpP15JU26dSfbyx4lyt1jxNg,28440
 celldetective/gui/interactive_timeseries_viewer.py,sha256=u_amAhLdEHRpYSRwPDtVm5v-JZIz0ANTcG4YGksX1Vo,16079
 celldetective/gui/json_readers.py,sha256=t5rhtIxACj0pdwLrnPs-QjyhQo3P25UGWGgOCIBhQxs,4572
-celldetective/gui/measure_annotator.py,sha256=HdhrU3N207evB9s-pqZNfzJC2Jswx3yHdPPLR8CRILc,38354
+celldetective/gui/measure_annotator.py,sha256=ljNbsKmFXQk0R9zEfBZ6XfBHzFmlL7Gt6QyPHyqh08g,38357
 celldetective/gui/pair_event_annotator.py,sha256=QJHaM-z0K2I36sLf6XCMFMymfw-nFhzfGJ8oxrMfZco,124091
 celldetective/gui/plot_measurements.py,sha256=a_Mks-5XUTn2QEYih0PlXGp2lX3C34zuhK9ozzE1guM,56593
 celldetective/gui/plot_signals_ui.py,sha256=9VmA1yaTcNf1jY7drtK41R1q87dhEk7bXBCq_cQ94fs,28133
@@ -45,7 +45,7 @@ celldetective/gui/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 celldetective/gui/base/channel_norm_generator.py,sha256=JqNAo87zA3nMKzkGjvoeV-SHI89eIATwQj4jHv3-LpI,13973
 celldetective/gui/base/components.py,sha256=jNUsCU_QE7QUFR0_xEvEPFEBYolMJt7YXGUKMjF7uOE,8155
 celldetective/gui/base/feature_choice.py,sha256=n1T2fPoNLiTDS_6fa_GuGReDhBW11HdUrKy2RywotF8,2800
-celldetective/gui/base/figure_canvas.py,sha256=dQlmLfB3PUttFmyHZIvSc_9GQ5JRy7jH9w7lyKAGElk,1523
+celldetective/gui/base/figure_canvas.py,sha256=DAAGQAcoR6yubFSsRNRZcpxgdYOWgEHtJqWhv_G7lj0,2195
 celldetective/gui/base/list_widget.py,sha256=_WU3ZRU7UcJZIxm8qx_5HF7IK7dUu8IU1FY2AaW_qgo,4694
 celldetective/gui/base/styles.py,sha256=3Kz1eXw6OLr90wtErhK0KPJyJbyhAlqkniqm0JNGwFc,7407
 celldetective/gui/base/utils.py,sha256=KojauRKGM9XKNhaWn211p6mJNZWIHLH75yeLpDd7pvA,1103
@@ -76,7 +76,7 @@ celldetective/gui/settings/_settings_event_model_training.py,sha256=TVPnnYPmdAF6
 celldetective/gui/settings/_settings_measurements.py,sha256=nrVR1dG3B7iyJayRql1yierhKvgXZiu6qVtfkxI1ABA,47947
 celldetective/gui/settings/_settings_neighborhood.py,sha256=ws6H99bKU4NYd2IYyaJj7g9-MScr5W6UB2raP88ytfE,23767
 celldetective/gui/settings/_settings_segmentation.py,sha256=6DihD1mk-dN4Sstdth1iJ-0HR34rTVlTHP-pXUh_rY0,1901
-celldetective/gui/settings/_settings_segmentation_model_training.py,sha256=XxqSCxLHOvn1w8V8ZEEfPAvdwfS0IKz107ox4yll7AA,30229
+celldetective/gui/settings/_settings_segmentation_model_training.py,sha256=6Ftih-_1VaICHBFLs6BPO8kf5ZDohwvDF4dEnhYC19M,30440
 celldetective/gui/settings/_settings_signal_annotator.py,sha256=Mvvre-yHJvRoR-slbkLNwEemuGgiMCQQ4H1BHjFk3r4,12412
 celldetective/gui/settings/_settings_tracking.py,sha256=5ZxJp3o3stD2NKdhqZofIgsUNp73oAN_pIi_bDFAd0Y,53293
 celldetective/gui/settings/_stardist_model_params.py,sha256=dEKhaLcJ4r8VxgBU2DI-hcTaTk5S181O-_CN0j7JSgE,4020
@@ -87,12 +87,12 @@ celldetective/gui/table_ops/_merge_one_hot.py,sha256=gKRgem-u_-JENkVkbjRobsH4TkS
 celldetective/gui/table_ops/_query_table.py,sha256=K-XHSZ1I4v2wwqWjyQAgyFRZJbem3CmTfHmO0vijh9g,1345
 celldetective/gui/table_ops/_rename_col.py,sha256=UAgDSpXJo_h4pLJpHaNc2w2VhbaW4D2JZTgJ3cYC4-g,1457
 celldetective/gui/viewers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-celldetective/gui/viewers/base_viewer.py,sha256=1U936rVnRqevXtyqlZnu_1o_VbWx3BJVofKh_oKG1jM,29857
-celldetective/gui/viewers/channel_offset_viewer.py,sha256=aQpxrJX9qM_xX848XnFrxrhTqE22DIshtD-uKL8e4gU,12423
+celldetective/gui/viewers/base_viewer.py,sha256=ir3J8QyLDAijOMu0Np56lUR0fSeWhz_1xdb_bX6rdRk,31939
+celldetective/gui/viewers/channel_offset_viewer.py,sha256=cywBkxyMPyKIuwZTGA03DBSS4a-H1SAohMJYOPISLEE,16289
 celldetective/gui/viewers/contour_viewer.py,sha256=riHj03LKXLoa-Ys2o2EhCE5nULfcHMohx9LFoXbI6zU,14720
 celldetective/gui/viewers/size_viewer.py,sha256=uXITjaxg5dhQ09Q6TNUxwLxi-ZglyGFcxEH1RtGIZWw,6020
 celldetective/gui/viewers/spot_detection_viewer.py,sha256=JO7kcqATHXR91lLvo8aQ5xVYdtxkMxV-xx36s01VlNQ,12545
-celldetective/gui/viewers/threshold_viewer.py,sha256=CBc6Y7cGK5U3ptAMMkmRLBvm5yl7pjGEUJjB4PKWjfM,11627
+celldetective/gui/viewers/threshold_viewer.py,sha256=F-13JF2wFhyvvKfUvgRcSjWL3leAliOXy5yUergndnE,12000
 celldetective/icons/logo-large.png,sha256=FXSwV3u6zEKcfpuSn4unnqB0oUnN9cHqQ9BCKWytrpg,36631
 celldetective/icons/logo.png,sha256=wV2OS8_dU5Td5cgdPbCOU3JpMpTwNuYLnfVcnQX0tJA,2437
 celldetective/icons/signals_icon.png,sha256=vEiKoqWTtN0-uJgVqtAlwCuP-f4QeWYOlO3sdp2tg2w,3969
@@ -161,13 +161,14 @@ celldetective/utils/parsing.py,sha256=1zpIH9tyULCRmO5Kwzy6yA01fqm5uE_mZKYtondy-V
 celldetective/utils/resources.py,sha256=3Fz_W0NYWl_Ixc2AjEmkOv5f7ejXerCLJ2z1iWhGWUI,1153
 celldetective/utils/stats.py,sha256=4TVHRqi38Y0sed-izaMI51sMP0fd5tC5M68EYyfJjkE,3636
 celldetective/utils/types.py,sha256=lRfWSMVzTkxgoctGGp0NqD551akuxu0ygna7zVGonTg,397
-celldetective/utils/cellpose_utils/__init__.py,sha256=grsglxR29vj42tlgsBoXnVnjrIJWsBXqbtkjFjzqH7A,4898
+celldetective/utils/cellpose_utils/__init__.py,sha256=MeRDojrAkBSXe-wlLu5KIih5wXP9B2aPdP39JLYpoGE,5417
 celldetective/utils/event_detection/__init__.py,sha256=KX20PwPTevdbZ-25otDy_QTmealcDx5xNCfH2SOVIZM,323
 celldetective/utils/plots/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 celldetective/utils/plots/regression.py,sha256=oUCn29-hp7PxMqC-R0yoL60KMw5ZWpZAIoCDh2ErlcY,1764
 celldetective/utils/stardist_utils/__init__.py,sha256=e9s3DEaTKCUOGZb5k_DgShBTl4B0U-Jmg3Ioo8D5PyE,3978
-celldetective-1.5.0b3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+celldetective-1.5.0b5.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_cellpose_fallback.py,sha256=BJZTDFF8sFR1x7rDbvZQ2RQOB1OP6wuFBRfc8zbl5zw,3513
 tests/test_events.py,sha256=eLFwwEEJfQAdwhews3-fn1HSvzozcNNFN_Qn0gOvQkE,685
 tests/test_filters.py,sha256=uj4NVyUnKXa18EpTSiWCetGKI1VFopDyNSJSUxX44wA,1689
 tests/test_io.py,sha256=gk5FmoI7ANEczUtNXYRxc48KzkfYzemwS_eYaLq4_NI,2093
@@ -181,10 +182,11 @@ tests/test_tracking.py,sha256=_YLjwQ3EChQssoHDfEnUJ7fI1yC5KEcJsFnAVR64L70,18909
 tests/test_utils.py,sha256=aSB_eMw9fzTsnxxdYoNmdQQRrXkWqBXB7Uv4TGU6kYE,4778
 tests/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/gui/test_enhancements.py,sha256=3x9au_rkQtMZ94DRj3OaEHKPr511RrWqBAUAcNQn1ys,13453
+tests/gui/test_measure_annotator_bugfix.py,sha256=tPfgWNKC0UkvrVssSrUcVDC1qgpzx6l2yCqvKtKYkM4,4544
 tests/gui/test_new_project.py,sha256=wRjW2vEaZb0LWT-f8G8-Ptk8CW9z8-FDPLpV5uqj6ck,8778
 tests/gui/test_project.py,sha256=KzAnodIc0Ovta0ARL5Kr5PkOR5euA6qczT_GhEZpyE4,4710
-celldetective-1.5.0b3.dist-info/METADATA,sha256=D4LkOtPQrdeuX4zW5_OKXlN1dxkxaZx_zqdILC36-Hk,10947
-celldetective-1.5.0b3.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-celldetective-1.5.0b3.dist-info/entry_points.txt,sha256=2NU6_EOByvPxqBbCvjwxlVlvnQreqZ3BKRCVIKEv3dg,62
-celldetective-1.5.0b3.dist-info/top_level.txt,sha256=6rsIKKfGMKgud7HPuATcpq6EhdXwcg_yknBVWn9x4C4,20
-celldetective-1.5.0b3.dist-info/RECORD,,
+celldetective-1.5.0b5.dist-info/METADATA,sha256=HXfAb1NZp3md807sossVoljx3m1O4VYRaJrgjaq8T0c,10947
+celldetective-1.5.0b5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+celldetective-1.5.0b5.dist-info/entry_points.txt,sha256=2NU6_EOByvPxqBbCvjwxlVlvnQreqZ3BKRCVIKEv3dg,62
+celldetective-1.5.0b5.dist-info/top_level.txt,sha256=6rsIKKfGMKgud7HPuATcpq6EhdXwcg_yknBVWn9x4C4,20
+celldetective-1.5.0b5.dist-info/RECORD,,

{celldetective-1.5.0b3.dist-info → celldetective-1.5.0b5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/gui/test_measure_annotator_bugfix.py

@@ -0,0 +1,130 @@
+import pytest
+import os
+import pandas as pd
+import numpy as np
+import logging
+from PyQt5 import QtCore
+from celldetective.gui.InitWindow import AppInitWindow
+from celldetective.gui.measure_annotator import MeasureAnnotator
+from celldetective import get_software_location
+from unittest.mock import patch
+import shutil
+import tifffile
+
+software_location = get_software_location()
+
+
+@pytest.fixture(autouse=True)
+def disable_logging():
+    """Disable all logging to avoid Windows OSError with pytest capture."""
+    logger = logging.getLogger()
+    try:
+        logging.disable(logging.CRITICAL)
+        yield
+    finally:
+        logging.disable(logging.NOTSET)
+
+
+@pytest.fixture
+def app(qtbot):
+    test_app = AppInitWindow(software_location=software_location)
+    qtbot.addWidget(test_app)
+    return test_app
+
+
+def create_dummy_movie(exp_dir, well="W1", pos="100", prefix="sample", frames=5):
+    movie_dir = os.path.join(exp_dir, well, pos, "movie")
+    os.makedirs(movie_dir, exist_ok=True)
+    # Use a single multi-page TIF as expected by locate_stack
+    movie_path = os.path.join(movie_dir, f"{prefix}.tif")
+    img = np.zeros((frames, 100, 100), dtype=np.uint16)
+    tifffile.imwrite(movie_path, img)
+
+
+def test_measure_annotator_colors_writable(app, qtbot, tmp_path):
+    """
+    Test that self.colors in MeasureAnnotator contains writable arrays.
+    This verifies the fix for 'ValueError: assignment destination is read-only'.
+    """
+    exp_dir = str(tmp_path / "ExperimentColors")
+    os.makedirs(os.path.join(exp_dir, "W1", "100", "output", "tables"), exist_ok=True)
+    os.makedirs(os.path.join(exp_dir, "configs"), exist_ok=True)
+
+    with open(os.path.join(exp_dir, "config.ini"), "w") as f:
+        f.write(
+            "[MovieSettings]\nmovie_prefix = sample\nlen_movie = 10\nshape_x = 100\nshape_y = 100\npxtoum = 1.0\nframetomin = 1.0\n"
+        )
+        f.write(
+            "[Labels]\nconcentrations = 0\ncell_types = dummy\nantibodies = none\npharmaceutical_agents = none\n[Channels]\nChannel1 = 0\n"
+        )
+
+    create_dummy_movie(exp_dir, well="W1", pos="100", prefix="sample", frames=10)
+
+    # DataFrame with tracks
+    df = pd.DataFrame(
+        {
+            "TRACK_ID": [1, 1],
+            "FRAME": [0, 1],
+            "group_experimental": ["A", "A"],
+            "area": [100.0, 110.0],
+            "POSITION_X": [10, 12],
+            "POSITION_Y": [10, 12],
+            "status": [0, 0],  # Ensure status column exists
+        }
+    )
+    # The 'group_color' column is usually generated inside MeasureAnnotator,
+    # but let's see if we need to let it generate it.
+    # MeasureAnnotator calls 'color_from_state', then assigns 'group_color'.
+
+    traj_path = os.path.join(
+        exp_dir, "W1", "100", "output", "tables", "trajectories_effectors.csv"
+    )
+    df.to_csv(traj_path, index=False)
+
+    app.experiment_path_selection.setText(exp_dir)
+    qtbot.mouseClick(app.validate_button, QtCore.Qt.LeftButton)
+    qtbot.waitUntil(lambda: hasattr(app, "control_panel"), timeout=30000)
+
+    cp = app.control_panel
+    p0 = cp.ProcessPopulations[0]
+
+    qtbot.waitUntil(lambda: cp.well_list.count() > 0, timeout=30000)
+
+    with patch.object(cp.well_list, "getSelectedIndices", return_value=[0]):
+        with patch.object(cp.position_list, "getSelectedIndices", return_value=[0]):
+
+            cp.update_position_options()
+            qtbot.wait(500)
+
+            qtbot.mouseClick(p0.check_measurements_btn, QtCore.Qt.LeftButton)
+
+            try:
+                qtbot.waitUntil(lambda: hasattr(p0, "measure_annotator"), timeout=15000)
+            except Exception:
+                print("DEBUG: measure_annotator not found on p0.")
+                raise
+
+            annotator = p0.measure_annotator
+            qtbot.wait(1000)
+            assert annotator is not None
+
+            # Verify that self.colors arrays are writable
+            # extract_scatter_from_trajectories should have been called during init
+            assert hasattr(annotator, "colors")
+            assert len(annotator.colors) > 0
+
+            # Check the first frame's colors
+            colors_frame_0 = annotator.colors[0]
+
+            # Check flags
+            assert colors_frame_0.flags[
+                "WRITEABLE"
+            ], "self.colors arrays must be writable"
+
+            # Try to modify (should not raise ValueError)
+            try:
+                colors_frame_0[0] = "lime"
+            except ValueError as e:
+                pytest.fail(f"Could not modify colors array: {e}")
+
+            annotator.close()

tests/test_cellpose_fallback.py

@@ -0,0 +1,101 @@
+import unittest
+from unittest.mock import MagicMock, patch
+import sys
+
+# Do not import torch here to avoid WinError 1114 if environment is broken.
+# We will mock it in setUp.
+
+
+class TestCellposeFallback(unittest.TestCase):
+
+    def setUp(self):
+        # Create a mock for torch
+        self.mock_torch = MagicMock()
+        self.mock_torch.device = MagicMock(return_value="cpu")
+        self.mock_torch.cuda = MagicMock()
+        self.mock_torch.cuda.is_available.return_value = (
+            False  # Default to CPU environment simulation
+        )
+
+        # Patch modules so that 'import torch' and 'import cellpose' work with our mocks
+        # We need to patch 'torch' in sys.modules BEFORE importing code that uses it.
+        self.modules_patcher = patch.dict(
+            sys.modules,
+            {
+                "torch": self.mock_torch,
+                "cellpose": MagicMock(),
+                "cellpose.models": MagicMock(),
+            },
+        )
+        self.modules_patcher.start()
+
+        # Define a mock CellposeModel that we can control
+        self.MockCellposeModel = MagicMock()
+        sys.modules["cellpose.models"].CellposeModel = self.MockCellposeModel
+
+    def tearDown(self):
+        self.modules_patcher.stop()
+
+    def test_gpu_fallback_on_assertion_error(self):
+        """
+        Test that _prep_cellpose_model falls back to CPU if GPU init fails with AssertionError.
+        """
+        # Lazy import inside the test method/patch context
+        from celldetective.utils.cellpose_utils import _prep_cellpose_model
+
+        # Side effect for CellposeModel constructor
+        def side_effect(gpu=False, **kwargs):
+            if gpu:
+                raise AssertionError("Torch not compiled with CUDA enabled")
+
+            # Return a mock model object
+            model = MagicMock()
+            model.diam_mean = 30.0
+            model.diam_labels = 30.0
+            return model
+
+        self.MockCellposeModel.side_effect = side_effect
+
+        # Call the function with use_gpu=True
+        # We expect it to try with gpu=True, fail, print warning, and retry with gpu=False
+        model, scale = _prep_cellpose_model(
+            model_name="fake_model", path="fake_path/", use_gpu=True, n_channels=2
+        )
+
+        # Check call history
+        self.assertEqual(self.MockCellposeModel.call_count, 2)
+
+        args1, kwargs1 = self.MockCellposeModel.call_args_list[0]
+        self.assertTrue(kwargs1.get("gpu"), "First call should try gpu=True")
+
+        args2, kwargs2 = self.MockCellposeModel.call_args_list[1]
+        self.assertFalse(kwargs2.get("gpu"), "Second call should retry with gpu=False")
+
+        self.assertIsNotNone(model)
+
+    def test_gpu_success(self):
+        """
+        Test that _prep_cellpose_model works normally if GPU init succeeds.
+        """
+        from celldetective.utils.cellpose_utils import _prep_cellpose_model
+
+        # Side effect for success
+        def side_effect(gpu=False, **kwargs):
+            model = MagicMock()
+            model.diam_mean = 30.0
+            model.diam_labels = 30.0
+            return model
+
+        self.MockCellposeModel.side_effect = side_effect
+
+        model, scale = _prep_cellpose_model(
+            model_name="fake_model", path="fake_path/", use_gpu=True, n_channels=2
+        )
+
+        self.assertEqual(self.MockCellposeModel.call_count, 1)
+        args, kwargs = self.MockCellposeModel.call_args
+        self.assertTrue(kwargs.get("gpu"))
+
+
+if __name__ == "__main__":
+    unittest.main()