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

celldetective/gui/process_block.py

@@ -820,58 +820,117 @@ class ProcessPanel(QFrame, Styles):
 
     def check_signals(self):
         from celldetective.gui.event_annotator import EventAnnotator, StackLoaderThread
+        from celldetective.utils.experiment import interpret_wells_and_positions
 
-        test = self.parent_window.locate_selected_position()
-        if test:
-            self.event_annotator = EventAnnotator(self, lazy_load=True)
+        self.well_option = self.parent_window.well_list.getSelectedIndices()
+        self.position_option = self.parent_window.position_list.getSelectedIndices()
 
-            if not getattr(self.event_annotator, "proceed", True):
-                return
+        # Count selected positions
+        well_indices, position_indices = interpret_wells_and_positions(
+            self.exp_dir, self.well_option, self.position_option
+        )
+        total_positions = 0
+        from celldetective.utils.experiment import (
+            get_positions_in_well,
+            get_experiment_wells,
+        )
 
-            self.signal_loader = StackLoaderThread(self.event_annotator)
+        wells = get_experiment_wells(self.exp_dir)
+        for widx in well_indices:
+            positions = get_positions_in_well(wells[widx])
+            if position_indices is not None:
+                total_positions += len(position_indices)
+            else:
+                total_positions += len(positions)
 
-            self.signal_progress = CelldetectiveProgressDialog(
-                "Loading data...", "Cancel", 0, 100, self, window_title="Please wait"
-            )
+        if total_positions == 1:
+            test = self.parent_window.locate_selected_position()
+            if test:
+                self.event_annotator = EventAnnotator(self, lazy_load=True)
 
-            self.signal_progress.setValue(0)
+                if not getattr(self.event_annotator, "proceed", True):
+                    return
 
-            self.signal_loader.progress.connect(self.signal_progress.setValue)
-            self.signal_loader.status_update.connect(self.signal_progress.setLabelText)
-            self.signal_progress.canceled.connect(self.signal_loader.stop)
+                self.signal_loader = StackLoaderThread(self.event_annotator)
 
-            def on_finished():
-                self.signal_progress.blockSignals(True)
-                self.signal_progress.close()
-                if not self.signal_loader._is_cancelled:
-                    try:
-                        self.event_annotator.finalize_init()
-                        self.event_annotator.show()
+                self.signal_progress = CelldetectiveProgressDialog(
+                    "Loading data...",
+                    "Cancel",
+                    0,
+                    100,
+                    self,
+                    window_title="Please wait",
+                )
+
+                self.signal_progress.setValue(0)
+
+                self.signal_loader.progress.connect(self.signal_progress.setValue)
+                self.signal_loader.status_update.connect(
+                    self.signal_progress.setLabelText
+                )
+                self.signal_progress.canceled.connect(self.signal_loader.stop)
+
+                def on_finished():
+                    self.signal_progress.blockSignals(True)
+                    self.signal_progress.close()
+                    if not self.signal_loader._is_cancelled:
                         try:
-                            QTimer.singleShot(
-                                100,
-                                lambda: self.event_annotator.resize(
-                                    self.event_annotator.width() + 1,
-                                    self.event_annotator.height() + 1,
-                                ),
-                            )
-                        except:
-                            pass
-                    except Exception as e:
-                        print(f"Error finalizing annotator: {e}")
-                else:
-                    self.event_annotator.close()
+                            self.event_annotator.finalize_init()
+                            self.event_annotator.show()
+                            try:
+                                QTimer.singleShot(
+                                    100,
+                                    lambda: self.event_annotator.resize(
+                                        self.event_annotator.width() + 1,
+                                        self.event_annotator.height() + 1,
+                                    ),
+                                )
+                            except:
+                                pass
+                        except Exception as e:
+                            print(f"Error finalizing annotator: {e}")
+                    else:
+                        self.event_annotator.close()
 
-            self.signal_loader.finished.connect(on_finished)
-            self.signal_loader.start()
+                self.signal_loader.finished.connect(on_finished)
+                self.signal_loader.start()
+        else:
+            # Multi position explorer: redirect to TableUI with progress bar
+            self.view_table_ui()
 
     def check_measurements(self):
         from celldetective.gui.measure_annotator import MeasureAnnotator
+        from celldetective.utils.experiment import interpret_wells_and_positions
 
-        test = self.parent_window.locate_selected_position()
-        if test:
-            self.measure_annotator = MeasureAnnotator(self)
-            self.measure_annotator.show()
+        self.well_option = self.parent_window.well_list.getSelectedIndices()
+        self.position_option = self.parent_window.position_list.getSelectedIndices()
+
+        # Count selected positions
+        well_indices, position_indices = interpret_wells_and_positions(
+            self.exp_dir, self.well_option, self.position_option
+        )
+        total_positions = 0
+        from celldetective.utils.experiment import (
+            get_positions_in_well,
+            get_experiment_wells,
+        )
+
+        wells = get_experiment_wells(self.exp_dir)
+        for widx in well_indices:
+            positions = get_positions_in_well(wells[widx])
+            if position_indices is not None:
+                total_positions += len(position_indices)
+            else:
+                total_positions += len(positions)
+
+        if total_positions == 1:
+            test = self.parent_window.locate_selected_position()
+            if test:
+                self.measure_annotator = MeasureAnnotator(self)
+                self.measure_annotator.show()
+        else:
+            # Multi position explorer: redirect to TableUI with progress bar
+            self.view_table_ui()
 
     def enable_segmentation_model_list(self):
         if self.segment_action.isChecked():
@@ -1568,6 +1627,7 @@ class ProcessPanel(QFrame, Styles):
         from celldetective.gui.tableUI import TableUI
         from celldetective.gui.workers import ProgressWindow
         from celldetective.processes.load_table import TableLoaderProcess
+        from celldetective.utils.experiment import interpret_wells_and_positions
 
         logger.info("Load table...")
 
@@ -1575,24 +1635,31 @@ class ProcessPanel(QFrame, Styles):
         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,
-        }
+        # Count selected positions
+        well_indices, position_indices = interpret_wells_and_positions(
+            self.exp_dir, self.well_option, self.position_option
+        )
+        total_positions = 0
+        from celldetective.utils.experiment import (
+            get_positions_in_well,
+            get_experiment_wells,
+        )
 
-        self.df = None
+        wells = get_experiment_wells(self.exp_dir)
+        for widx in well_indices:
+            positions = get_positions_in_well(wells[widx])
+            if position_indices is not None:
+                total_positions += len(position_indices)
+            else:
+                total_positions += len(positions)
 
-        def on_table_loaded(df):
-            self.df = df
-            if self.df is not None:
+        def show_table(df):
+            if df is not None:
                 plot_mode = "plot_track_signals"
-                if "TRACK_ID" not in list(self.df.columns):
+                if "TRACK_ID" not in list(df.columns):
                     plot_mode = "static"
                 self.tab_ui = TableUI(
-                    self.df,
+                    df,
                     f"{self.parent_window.well_list.currentText()}; Position {self.parent_window.position_list.currentText()}",
                     population=self.mode,
                     plot_mode=plot_mode,
@@ -1607,20 +1674,46 @@ class ProcessPanel(QFrame, Styles):
                 msgBox.setText("No table could be loaded...")
                 msgBox.setWindowTitle("Info")
                 msgBox.setStandardButtons(QMessageBox.Ok)
-                returnValue = msgBox.exec()
+                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)
+        if total_positions == 1:
+            # Synchronous load for single position
+            from celldetective.utils.data_loaders import load_experiment_tables
 
-        result = self.job.exec_()
+            df = load_experiment_tables(
+                self.exp_dir,
+                population=self.mode,
+                well_option=self.well_option,
+                position_option=self.position_option,
+            )
+            show_table(df)
+        else:
+            # Asynchronous load for multiple positions
+            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
+                show_table(self.df)
+
+            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)
+            self.job.exec_()
 
     def load_available_tables(self):
         """
@@ -1641,8 +1734,87 @@ class ProcessPanel(QFrame, Styles):
         self.signals = []
         if self.df is not None:
             self.signals = list(self.df.columns)
-        if self.df is None:
-            logger.info("No table could be found for the selected position(s)...")
+        else:
+            logger.info(
+                "No table could be found for the selected position(s)... Anticipating measurements..."
+            )
+
+            from celldetective.utils.experiment import extract_experiment_channels
+
+            channel_names, _ = extract_experiment_channels(self.exp_dir)
+
+            # Standard measurements
+            self.signals = ["area"]
+            for ch in channel_names:
+                self.signals.append(f"{ch}_mean")
+
+            # Anticipate from instructions
+            instr_path = os.path.join(
+                self.exp_dir, "configs", f"measurement_instructions_{self.mode}.json"
+            )
+            if os.path.exists(instr_path):
+                try:
+                    with open(instr_path, "r") as f:
+                        instr = json.load(f)
+
+                    # 1. Features
+                    features = instr.get("features", [])
+                    if features:
+                        for f_name in features:
+                            if f_name == "intensity_mean":
+                                continue  # handled by standard
+                            if f_name == "area":
+                                continue
+
+                            # For other features, skimage/celldetective might suffix them.
+                            # If it's a generic feature, skimage usually keeps the name.
+                            # If it's multichannel, it might need channel names.
+                            # For now, let's keep it simple as requested for intensity_mean and area.
+                            pass
+
+                    # 2. Isotropic measurements
+                    radii = instr.get("intensity_measurement_radii", [])
+                    ops = instr.get("isotropic_operations", [])
+                    if radii and ops:
+                        for r in radii if isinstance(radii, list) else [radii]:
+                            for op in ops:
+                                for ch in channel_names:
+                                    if isinstance(r, list):
+                                        self.signals.append(
+                                            f"{ch}_ring_{int(min(r))}_{int(max(r))}_{op}"
+                                        )
+                                    else:
+                                        self.signals.append(
+                                            f"{ch}_circle_{int(r)}_{op}"
+                                        )
+
+                    # 3. Border distances
+                    borders = instr.get("border_distances", [])
+                    if borders:
+                        for b in borders if isinstance(borders, list) else [borders]:
+                            # Logic from measure.py for suffix
+                            b_str = (
+                                str(b)
+                                .replace("(", "")
+                                .replace(")", "")
+                                .replace(", ", "_")
+                                .replace(",", "_")
+                            )
+                            suffix = (
+                                f"_slice_{b_str.replace('-', 'm')}px"
+                                if ("-" in str(b) or "," in str(b))
+                                else f"_edge_{b_str}px"
+                            )
+                            for ch in channel_names:
+                                # In measure_features, it's {ch}_mean{suffix}
+                                self.signals.append(f"{ch}_mean{suffix}")
+
+                except Exception as e:
+                    logger.warning(f"Could not parse measurement instructions: {e}")
+
+            # Remove duplicates and keep order
+            seen = set()
+            self.signals = [x for x in self.signals if not (x in seen or seen.add(x))]
 
     def set_cellpose_scale(self):
 

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()
 
 

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/utils/image_loaders.py

@@ -623,6 +623,9 @@ def fix_missing_labels(position, population="target", prefix="Aligned"):
         )
         path = position + os.sep + f"labels_{population}"
 
+    if not os.path.exists(path):
+        os.makedirs(path, exist_ok=True)
+
     if label_path != []:
         # path = os.path.split(label_path[0])[0]
         int_valid = [int(lbl.split(os.sep)[-1].split(".")[0]) for lbl in label_path]

celldetective/utils/masks.py

@@ -2,7 +2,7 @@ from typing import Union, List, Tuple
 
 import numpy as np
 from scipy import ndimage
-from scipy.ndimage.morphology import distance_transform_edt
+from scipy.ndimage import distance_transform_edt
 from skimage.morphology import disk
 from celldetective.log_manager import get_logger
 

{celldetective-1.5.0b2.dist-info → celldetective-1.5.0b4.dist-info}/METADATA

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

{celldetective-1.5.0b2.dist-info → celldetective-1.5.0b4.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=CuIe9FnuPFwA2ifQ6Z1we7xlmfgZi2uaLGG8nhwu_eo,24
+celldetective/_version.py,sha256=i0XQAcqdHCcwV-JF_A_FeVVfTjXROj_WnqM2Ktzzq1Q,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
@@ -15,27 +15,27 @@ celldetective/signals.py,sha256=2UURVmeonNgUHpiMQVSps0E9VuskKSbsfsmeCtEmfp8,1374
 celldetective/tracking.py,sha256=iwN6rQ9Bmz20JPrFoewywPBrhD864NUiMaZbIINJVZc,49758
 celldetective/datasets/segmentation_annotations/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 celldetective/datasets/signal_annotations/blank,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-celldetective/gui/InitWindow.py,sha256=dZMqXYVAYSDDZBGb7_S6IXrQoLo83fSXfymwZw2YWvw,21676
+celldetective/gui/InitWindow.py,sha256=uta0lqFsiwcPz3bh8hz44LrTGhzKWa_SQWbylSBZU_w,22366
 celldetective/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 celldetective/gui/about.py,sha256=l9SA7WnQs3ISPvZYAGMmf1A0GRXcinkyGwWJpG8akFQ,1977
 celldetective/gui/analyze_block.py,sha256=R82PVFHXfKn8BvUCpbjDOkLBNF4xRVCzYKFHitjw0kk,4114
-celldetective/gui/base_annotator.py,sha256=ThLDKfUALDbXjKXWEG2gq9BTqinE_NEGWTyVU1XPnOQ,32446
+celldetective/gui/base_annotator.py,sha256=xLCg5n4kl_EOajk1KNAdMzB05blaiGdb0kjylx88D_A,32690
 celldetective/gui/classifier_widget.py,sha256=uQ9KQmUFp6qWy0Aic-AKB9DkGNpOLxaERtYBSIX9RHw,25424
 celldetective/gui/configure_new_exp.py,sha256=vgT6ozRIGDvT3R0qENlqvDn17BpKnwyJRhRhDS6ax8A,29954
-celldetective/gui/control_panel.py,sha256=vT8Ny9JHGnx25CygjkjqLHBqwj7tL7q-tE4R_iildiQ,24115
+celldetective/gui/control_panel.py,sha256=dMNzgivt6GdYROPlYpEY5TTNcANenm9ifUI3W3OcpOo,24337
 celldetective/gui/dynamic_progress.py,sha256=wjTmDPy62qssY0zdteP3T9umIGGQk0UvebFIdn54CIc,16676
 celldetective/gui/event_annotator.py,sha256=bW6IcZsYOmGJPv-3wZHPYGmg2k43PXo0tvHa1ZAFFF8,36338
 celldetective/gui/generic_signal_plot.py,sha256=D3b6pG1yrSi8C2PPyYzK2yA6711CBBPRp5_OIrjayqs,49348
-celldetective/gui/gui_utils.py,sha256=KbxgwOXGKup_w2FntJxFDSl-eUmc2aqq6h3O5nW8nO0,33258
+celldetective/gui/gui_utils.py,sha256=t6SjEfjcaRH9a0TlbTGEiVRpCgocaCh4lgkIvRgRRwE,33497
 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=GVyNW1EDHoy3gdGPckHhzHg1L0CkISFBjPRl2Xy-jxc,34541
+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=pTBA8_XtAZRsxNtWqd8obOHbDqKyz-c1R085xy7y4Ns,56675
-celldetective/gui/plot_signals_ui.py,sha256=oReZwCZw89pFtwuezGQNI6kAz8Q_daKHvNoAKEgzn2w,28195
+celldetective/gui/plot_measurements.py,sha256=a_Mks-5XUTn2QEYih0PlXGp2lX3C34zuhK9ozzE1guM,56593
+celldetective/gui/plot_signals_ui.py,sha256=9VmA1yaTcNf1jY7drtK41R1q87dhEk7bXBCq_cQ94fs,28133
 celldetective/gui/preprocessing_block.py,sha256=cgUBv-eQBwfidK48-cTWJi0PS62wlXhsNLnsKhy6MQY,14967
-celldetective/gui/process_block.py,sha256=UZD8J2vvecooUW1l0Fl3HZnob0EjJMrVRbIjpSjzgUY,69424
+celldetective/gui/process_block.py,sha256=NBSwg32Juz3dyXMe0uRyYE-qttfsTqSDPyoBgVc5T1c,76891
 celldetective/gui/seg_model_loader.py,sha256=6DzpX630JJgtcsaDEuWA8PEkeb8FC3p__3xeSiFqdGo,23549
 celldetective/gui/survival_ui.py,sha256=IwdRm1gRvhkWdMtrQk04OIKKksW3NZSGYtZO_2GptrA,16034
 celldetective/gui/tableUI.py,sha256=kZP2lp9NwHtbWEqIyaDwohX42tRkhI0Hlf_8O5w5BD0,61267
@@ -43,7 +43,7 @@ celldetective/gui/thresholds_gui.py,sha256=w6ke2TyIEi71LxbuFGz0UrwH8h21N_ESU-o6x
 celldetective/gui/workers.py,sha256=WAtVxFEvHApBSAZMVyYsya_DHL_bYo8b57dbgUJQHc4,14890
 celldetective/gui/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 celldetective/gui/base/channel_norm_generator.py,sha256=JqNAo87zA3nMKzkGjvoeV-SHI89eIATwQj4jHv3-LpI,13973
-celldetective/gui/base/components.py,sha256=RCJ5SPNzauKhs2sBFxpUZwb3k1yyD_5lHDZ30WkFyZo,8111
+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/list_widget.py,sha256=_WU3ZRU7UcJZIxm8qx_5HF7IK7dUu8IU1FY2AaW_qgo,4694
@@ -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,7 +87,7 @@ 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/base_viewer.py,sha256=gHe9QBX6Lrn567Kc-9T6KoGuLqEP_1q4RROFBd9qLWE,29962
 celldetective/gui/viewers/channel_offset_viewer.py,sha256=aQpxrJX9qM_xX848XnFrxrhTqE22DIshtD-uKL8e4gU,12423
 celldetective/gui/viewers/contour_viewer.py,sha256=riHj03LKXLoa-Ys2o2EhCE5nULfcHMohx9LFoXbI6zU,14720
 celldetective/gui/viewers/size_viewer.py,sha256=uXITjaxg5dhQ09Q6TNUxwLxi-ZglyGFcxEH1RtGIZWw,6020
@@ -147,12 +147,12 @@ celldetective/utils/downloaders.py,sha256=BIl_8XCeaKvtMVC36WITT2g5-O-n0csoMEQXVo
 celldetective/utils/experiment.py,sha256=bgADS70QuW4KGbzDJbVpVM-tw4qmZKMWtDT1cSxugrY,58342
 celldetective/utils/image_augmenters.py,sha256=USYd8z6dVn5z1x96IYJ4mG0smN9I_S21QMGU0wyHmjc,11654
 celldetective/utils/image_cleaning.py,sha256=KliQ3K5hdwPx4eFxJnmg3yi-ZIoimEveunPJkbbA6wA,2388
-celldetective/utils/image_loaders.py,sha256=nsyneHM67R9r-mmWKI7Z6xpe5MQCLOFsaYKFhxw2R-c,34032
+celldetective/utils/image_loaders.py,sha256=9O0kpG2ZQWC2-7VNS5kf7ihmusHTqeBk9po4uiUvsFY,34107
 celldetective/utils/image_transforms.py,sha256=cgaHuEUArWWHgxlBlcQLf--zQa-4VphPJ2s2EyPN29o,11213
 celldetective/utils/io.py,sha256=WQH6B27iS722eVV8HHRaSvxMRZ217LoiEIPOqNGtqJk,1632
 celldetective/utils/mask_cleaning.py,sha256=n1Q2RfyhX0W3AcLO0U6ucSyDGRCofj6bPLSO_xeVZPI,12545
 celldetective/utils/mask_transforms.py,sha256=fX-ajhUhzZwOe7rAnMcQc6w4e2B8SZeRp9jrQLF6DFs,144
-celldetective/utils/masks.py,sha256=wz47NrCsLD_9WX2Goswl_ThgnxyLJokIN6cj8KH7ZjI,7075
+celldetective/utils/masks.py,sha256=g3QHtqyVg6RN0BfmDoPXVjwL3O4xa_dKPC_ZeGmzkeE,7064
 celldetective/utils/maths.py,sha256=pbbWWYNIHTnIBiaR2kJHPDaTPO0rpmQSPjHB7liUSG0,12465
 celldetective/utils/model_getters.py,sha256=jVq9FhAF-xUmFOETWP6hByhoWgapmJGlNmSK11fQ69g,11370
 celldetective/utils/model_loaders.py,sha256=CjScJBGtnenb8qRMZkEozdj1-ULYHvsDFS4AVgYbB5s,10576
@@ -161,29 +161,32 @@ 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.0b2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+celldetective-1.5.0b4.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
 tests/test_measure.py,sha256=FEUAs1rVHylvIvubCb0bJDNGZLVmkgXNgI3NaGQ1dA8,4542
 tests/test_neighborhood.py,sha256=gk5FmoI7ANEczUtNXYRxc48KzkfYzemwS_eYaLq4_NI,2093
-tests/test_notebooks.py,sha256=WP5TJM1HV1oN8Hp38MLyE2YuLXjUoMvMJBa343vp1Dg,299
+tests/test_notebooks.py,sha256=7HVmYiytsz0QIJ11iRkGGs4_hzNjofXAUs_OZou3Gm0,301
 tests/test_preprocessing.py,sha256=c0rKS9d5h37uDcV7fVOTnn5GMVbEB84b8ZTCTdRmvFs,1422
 tests/test_segmentation.py,sha256=k1b_zIZdlytEdJcHjAUQEO3gTBAHtv5WvrwQN2xD4kc,3470
 tests/test_signals.py,sha256=No4cah6KxplhDcKXnU8RrA7eDla4hWw6ccf7xGnBokU,3599
 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.0b2.dist-info/METADATA,sha256=D2o2GnCwnu6VqU_q3jJPPn56xqr1pnBtLDpZOfVACCg,10947
-celldetective-1.5.0b2.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-celldetective-1.5.0b2.dist-info/entry_points.txt,sha256=2NU6_EOByvPxqBbCvjwxlVlvnQreqZ3BKRCVIKEv3dg,62
-celldetective-1.5.0b2.dist-info/top_level.txt,sha256=6rsIKKfGMKgud7HPuATcpq6EhdXwcg_yknBVWn9x4C4,20
-celldetective-1.5.0b2.dist-info/RECORD,,
+celldetective-1.5.0b4.dist-info/METADATA,sha256=VgzQFDS1ExiiQdY4MjqmWfrRTC-MJQR1meL7t0Q8eMY,10947
+celldetective-1.5.0b4.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+celldetective-1.5.0b4.dist-info/entry_points.txt,sha256=2NU6_EOByvPxqBbCvjwxlVlvnQreqZ3BKRCVIKEv3dg,62
+celldetective-1.5.0b4.dist-info/top_level.txt,sha256=6rsIKKfGMKgud7HPuATcpq6EhdXwcg_yknBVWn9x4C4,20
+celldetective-1.5.0b4.dist-info/RECORD,,