celldetective 1.5.0b10__py3-none-any.whl → 1.5.0b11__py3-none-any.whl

celldetective/_version.py

@@ -1 +1 @@
-__version__ = "1.5.0b10"
+__version__ = "1.5.0b11"

celldetective/gui/base/list_widget.py

@@ -89,7 +89,7 @@ class ListWidget(CelldetectiveWidget):
         """
         Retrieves and returns the items from the list widget.
 
-        This method parses any items that contain a range (formatted as 'min-max')
+        This method parses any items that contain a range (formatted as '(min,max)')
         into a list of two values, and casts all items to the specified `dtype`.
 
         Returns
@@ -97,18 +97,33 @@ class ListWidget(CelldetectiveWidget):
         list
                 A list of the items in the list widget, with ranges split into two values.
         """
+        import re
+
+        # Pattern for tuple format: "(min,max)" with optional negative numbers and decimals
+        tuple_pattern = re.compile(r"^\((-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)\)$")
 
         items = []
         for x in range(self.list_widget.count()):
-            if len(self.list_widget.item(x).text().split("-")) == 2:
-                if self.list_widget.item(x).text()[0] == "-":
-                    items.append(self.dtype(self.list_widget.item(x).text()))
-                else:
-                    minn, maxx = self.list_widget.item(x).text().split("-")
-                    to_add = [self.dtype(minn), self.dtype(maxx)]
-                    items.append(to_add)
-            else:
-                items.append(self.dtype(self.list_widget.item(x).text()))
+            text = self.list_widget.item(x).text().strip()
+
+            # Try tuple format first: (min,max)
+            tuple_match = tuple_pattern.match(text)
+            if tuple_match:
+                try:
+                    minn = self.dtype(float(tuple_match.group(1)))
+                    maxx = self.dtype(float(tuple_match.group(2)))
+                    items.append([minn, maxx])
+                    continue
+                except ValueError:
+                    pass
+
+            # Single value
+            try:
+                items.append(self.dtype(text))
+            except ValueError:
+                print(
+                    f"Warning: Could not convert '{text}' to {self.dtype.__name__}, skipping..."
+                )
         return items
 
     def clear(self):

celldetective/gui/event_annotator.py

@@ -850,11 +850,40 @@ class EventAnnotator(BaseAnnotator):
 
         try:
             self.stop()
-            del self.stack
-            gc.collect()
-        except:
+        except Exception:
             pass
 
+        # Stop and delete animation to break reference cycles
+        if hasattr(self, "anim") and self.anim:
+            try:
+                self.anim.event_source.stop()
+            except Exception:
+                pass
+            del self.anim
+
+        # Close matplotlib figures
+        if hasattr(self, "fig"):
+            try:
+                plt.close(self.fig)
+            except Exception:
+                pass
+
+        if hasattr(self, "cell_fig"):
+            try:
+                plt.close(self.cell_fig)
+            except Exception:
+                pass
+
+        # Delete large objects
+        if hasattr(self, "stack"):
+            del self.stack
+
+        if hasattr(self, "df_tracks"):
+            del self.df_tracks
+
+        gc.collect()
+        super().closeEvent(event)
+
     def animation_generator(self):
         """
         Generator yielding frame indices for the animation,

celldetective/gui/interactions_block.py

@@ -684,5 +684,14 @@ class NeighPanel(QFrame, Styles):
 
         test = self.parent_window.locate_selected_position()
         if test:
-            self.pair_event_annotator = PairEventAnnotator(self)
-            self.pair_event_annotator.show()
+            try:
+                self.pair_event_annotator = PairEventAnnotator(self)
+                self.pair_event_annotator.show()
+            except ValueError as e:
+                # Show useful feedback if no neighborhood detected
+                msg = QMessageBox()
+                msg.setIcon(QMessageBox.Warning)
+                msg.setText(str(e))
+                msg.setWindowTitle("Warning")
+                msg.exec_()
+                return

celldetective/gui/pair_event_annotator.py

@@ -172,6 +172,10 @@ class PairEventAnnotator(CelldetectiveMainWindow):
         print(
             f"The following neighborhoods were detected: {self.neighborhood_cols=}..."
         )
+        if len(self.neighborhood_cols) == 0:
+            raise ValueError(
+                "No neighborhoods detected. Please compute neighborhoods first."
+            )
 
         self.locate_relative_tracks()
 
@@ -1449,6 +1453,7 @@ class PairEventAnnotator(CelldetectiveMainWindow):
         self.reference_population = self.neighborhood_choice_cb.currentText().split(
             "_"
         )[0]
+        self.neighbor_population = self.reference_population
 
         if "_(" in self.current_neighborhood and ")_" in self.current_neighborhood:
             self.neighbor_population = (
@@ -1457,9 +1462,6 @@ class PairEventAnnotator(CelldetectiveMainWindow):
             self.reference_population = (
                 self.current_neighborhood.split("_(")[-1].split(")_")[0].split("-")[0]
             )
-        else:
-            if "self" in self.current_neighborhood:
-                self.neighbor_population = self.reference_population
 
         print(f"Current neighborhood: {self.current_neighborhood}")
         print(f"New reference population: {self.reference_population}")
@@ -2183,18 +2185,44 @@ class PairEventAnnotator(CelldetectiveMainWindow):
 
     def closeEvent(self, event):
 
-        self.stop()
-        # result = QMessageBox.question(self,
-        # 			  "Confirm Exit...",
-        # 			  "Are you sure you want to exit ?",
-        # 			  QMessageBox.Yes| QMessageBox.No,
-        # 			  )
         try:
-            del self.stack
-        except:
+            self.stop()
+        except Exception:
             pass
 
+        # Stop and delete animation to break reference cycles
+        if hasattr(self, "anim") and self.anim:
+            try:
+                self.anim.event_source.stop()
+            except Exception:
+                pass
+            del self.anim
+
+        # Close matplotlib figures
+        if hasattr(self, "fig"):
+            try:
+                plt.close(self.fig)
+            except Exception:
+                pass
+
+        if hasattr(self, "cell_fig"):
+            try:
+                plt.close(self.cell_fig)
+            except Exception:
+                pass
+
+        # Delete large objects
+        if hasattr(self, "stack"):
+            del self.stack
+
+        if hasattr(self, "dataframes"):
+            self.dataframes.clear()
+
+        if hasattr(self, "df_relative"):
+            del self.df_relative
+
         gc.collect()
+        super().closeEvent(event)
 
     def animation_generator(self):
         """
@@ -2982,26 +3010,6 @@ class PairEventAnnotator(CelldetectiveMainWindow):
         self.draw_frame(self.framedata)
         self.fcanvas.canvas.draw()
 
-    def set_first_frame(self):
-        self.stop()
-        self.framedata = 0
-        self.draw_frame(self.framedata)
-        self.fcanvas.canvas.draw()
-
-    def set_last_frame(self):
-        self.stop()
-        self.framedata = len(self.stack) - 1
-        while len(np.where(self.stack[self.framedata].flatten() == 0)[0]) > 0.99 * len(
-            self.stack[self.framedata].flatten()
-        ):
-            self.framedata -= 1
-            if self.framedata < 0:
-                self.framedata = 0
-                break
-
-        self.draw_frame(self.framedata)
-        self.fcanvas.canvas.draw()
-
     def give_reference_cell_information(self):
 
         df_reference = self.dataframes[self.reference_population]

celldetective/gui/settings/_settings_measurements.py

@@ -680,16 +680,15 @@ class SettingsMeasurements(CelldetectiveSettingsPanel):
                     border_distances = measurement_instructions["border_distances"]
                     if border_distances is not None:
                         if isinstance(border_distances, int):
-                            distances = [border_distances]
+                            distances = [str(border_distances)]
                         elif isinstance(border_distances, list):
                             distances = []
                             for d in border_distances:
-                                if isinstance(d, int) | isinstance(d, float):
+                                if isinstance(d, (int, float)):
                                     distances.append(str(int(d)))
                                 elif isinstance(d, list):
-                                    distances.append(
-                                        str(int(d[0])) + "-" + str(int(d[1]))
-                                    )
+                                    # Use (min,max) tuple format to match CellEdgeVisualizer output
+                                    distances.append(f"({int(d[0])},{int(d[1])})")
                         self.contours_list.list_widget.clear()
                         self.contours_list.list_widget.addItems(distances)
 

celldetective/gui/settings/_settings_neighborhood.py

@@ -213,6 +213,7 @@ class SettingsNeighborhood(CelldetectiveWidget):
                 channel_names=self.attr_parent.exp_channels,
                 n_channels=self.attr_parent.nbr_channels,
                 PxToUm=1,
+                single_value_mode=True,
             )
             self.viewer.show()
 

celldetective/gui/viewers/contour_viewer.py

@@ -72,6 +72,7 @@ class CellEdgeVisualizer(StackVisualizer):
         labels=None,
         initial_edge=5,
         initial_mask_alpha=0.5,
+        single_value_mode=False,
         *args,
         **kwargs,
     ):
@@ -86,6 +87,7 @@ class CellEdgeVisualizer(StackVisualizer):
         self.invert = invert
         self.parent_list_widget = parent_list_widget
         self.parent_le = parent_le
+        self.single_value_mode = single_value_mode
 
         # SDF cache (stores label + dist_in + dist_out + voronoi)
         self.sdf_cache = OrderedDict()
@@ -201,8 +203,18 @@ class CellEdgeVisualizer(StackVisualizer):
 
     def set_measurement_in_parent_list(self):
         # Add the edge size to the parent QListWidget
-
-        self.parent_list_widget.addItems([str(self.edge_slider.value())])
+        # edge_slider is a QLabeledRangeSlider returning (min, max) tuple
+        slider_val = self.edge_slider.value()
+        if isinstance(slider_val, tuple):
+            if self.single_value_mode:
+                # For neighborhood: just output the max absolute distance
+                edge_value = str(max(abs(slider_val[0]), abs(slider_val[1])))
+            else:
+                # For contour measurements: output as "(min,max)" tuple format
+                edge_value = f"({slider_val[0]},{slider_val[1]})"
+        else:
+            edge_value = str(abs(slider_val))
+        self.parent_list_widget.addItems([edge_value])
         self.close()
 
     def generate_label_imshow(self):

celldetective/measure.py

@@ -544,10 +544,19 @@ def measure_features(
         df_props = df_props[[c for c in df_props.columns if not c.endswith("_delme")]]
 
     if border_dist is not None:
+        # Get the names of extra properties that were actually requested by the user
+        # (these were moved from features to extra_props_list earlier)
+        requested_extra_names = []
+        if extra_props_list:
+            for prop_func in extra_props_list:
+                if hasattr(prop_func, "__name__"):
+                    requested_extra_names.append(prop_func.__name__)
+
         # Filter for features containing "intensity" but not "centroid" or "peripheral"
+        # Only use user-requested features, not all available extra properties
         intensity_features = [
             f
-            for f in (features + extra)
+            for f in (features + requested_extra_names)
             if "intensity" in f and "centroid" not in f and "peripheral" not in f
         ]
 
@@ -558,7 +567,7 @@ def measure_features(
 
         clean_intensity_features = []
         for s in intensity_features:
-            if s in extra:
+            if s in requested_extra_names:
                 intensity_extra.append(getattr(extra_props, s))
             else:
                 clean_intensity_features.append(s)

celldetective/utils/masks.py

@@ -49,8 +49,10 @@ def contour_of_instance_segmentation(label, distance, sdf=None, voronoi_map=None
     """
     from scipy.ndimage import distance_transform_edt
 
-    # helper to parse string "rad1-rad2"
+    # helper to parse string "rad1-rad2" or "-12-13" or "-5--2"
     if isinstance(distance, str):
+        import re
+
         try:
             # Check for stringified tuple "(a, b)"
             distance = distance.strip()
@@ -74,13 +76,18 @@ def contour_of_instance_segmentation(label, distance, sdf=None, voronoi_map=None
                         min_r = val
                         max_r = 0
                 except ValueError:
-                    # It's a range string "5-10"
-                    parts = distance.split("-")
-                    # Assumption: "A-B" where A, B positive radii for OUTER annulus.
-                    r1 = float(parts[0])
-                    r2 = float(parts[1])
-                    min_r = -max(r1, r2)
-                    max_r = -min(r1, r2)
+                    # It's a range string like "5-10", "-12-13", or "-5--2"
+                    # Use regex to parse range with potentially negative numbers
+                    range_pattern = re.compile(r"^(-?\d+(?:\.\d+)?)-(-?\d+(?:\.\d+)?)$")
+                    match = range_pattern.match(distance)
+                    if match:
+                        r1 = float(match.group(1))
+                        r2 = float(match.group(2))
+                        # Use the values directly as specified (min, max in SDF space)
+                        min_r = min(r1, r2)
+                        max_r = max(r1, r2)
+                    else:
+                        raise ValueError(f"Could not parse range string: {distance}")
 
         except Exception:
             logger.warning(

{celldetective-1.5.0b10.dist-info → celldetective-1.5.0b11.dist-info}/METADATA

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

{celldetective-1.5.0b10.dist-info → celldetective-1.5.0b11.dist-info}/RECORD

@@ -1,13 +1,13 @@
 celldetective/__init__.py,sha256=LfnOyfUnYPGDc8xcsF_PfYEL7-CqAb7BMBPBIWGv84o,666
 celldetective/__main__.py,sha256=Rzzu9ArxZSgfBVjV-lyn-3oanQB2MumQR6itK5ZaRpA,2597
-celldetective/_version.py,sha256=IWzkcjFNinv23e_qW2_WxLXbN_bwUvMfLyYxfg2BHRw,25
+celldetective/_version.py,sha256=4JH3pE2Gi7kHI-6YVma-6xegJyqqu0l3uH4fqRqdsGA,25
 celldetective/event_detection_models.py,sha256=A7ZJFhJwfdhzfxJ-YZIj6IoI9Gc1hyAodFkKt8kNxDk,93549
 celldetective/events.py,sha256=n15R53c7QZ2wT8gjb0oeNikQbuRBrVVbyNsRCqXjzXA,8166
 celldetective/exceptions.py,sha256=f3VmIYOthWTiqMEV5xQCox2rw5c5e7yog88h-CcV4oI,356
 celldetective/extra_properties.py,sha256=s_2R4_El2p-gQNZ_EpgDxgrN3UnRitN7KDKHhyLuoHc,21681
 celldetective/filters.py,sha256=QSRSpqvwUfa0YrU5EKoobJWCQFy07fFHwZ2bXxTL3hE,6933
 celldetective/log_manager.py,sha256=Tv7_mVn0TVOyTs_2VnyEKl9_NMeDUtEkLC5njUq-r-Y,2968
-celldetective/measure.py,sha256=8f0AMBqMrilcxjW2JKnMhqgJXWwLT-9K5k3dcpOJBcw,72212
+celldetective/measure.py,sha256=LTV4HvMzGUIRD1L6SsfktUWW5EIG2qk-I69rLot0fuA,72711
 celldetective/neighborhood.py,sha256=Z5wu2nSMvabrQz91oy6DRf2o90LUY0RMXTEwgW7ORAg,74844
 celldetective/preprocessing.py,sha256=tjAMLG4ZMfopMSFulGGjMQox7czEcReV2MzEkWlL2eQ,59948
 celldetective/relative_measurements.py,sha256=j7xIj1FiY3kn5nA_wMqHV3wvjqikjnk99kZ7v9G6I5Q,42928
@@ -25,14 +25,14 @@ celldetective/gui/classifier_widget.py,sha256=uQ9KQmUFp6qWy0Aic-AKB9DkGNpOLxaERt
 celldetective/gui/configure_new_exp.py,sha256=vgT6ozRIGDvT3R0qENlqvDn17BpKnwyJRhRhDS6ax8A,29954
 celldetective/gui/control_panel.py,sha256=dMNzgivt6GdYROPlYpEY5TTNcANenm9ifUI3W3OcpOo,24337
 celldetective/gui/dynamic_progress.py,sha256=wjTmDPy62qssY0zdteP3T9umIGGQk0UvebFIdn54CIc,16676
-celldetective/gui/event_annotator.py,sha256=JVd64Gch_qzXv29VJGAa2Ytk-WhxifZVgMK-hAxnGu4,41262
+celldetective/gui/event_annotator.py,sha256=JcX1K-TAMEdbgg-8ENK1xx_H2nw-vhNvxl1ImhqhMgM,42013
 celldetective/gui/generic_signal_plot.py,sha256=47kXIuMcnQXjeNEdzM_G1WbW9TL5eMSjHC9XgWXMly4,49492
 celldetective/gui/gui_utils.py,sha256=l7P6emKVEciCRdmnbfYvJAhl0MnbT3QkL2zpSPuHRoY,34120
-celldetective/gui/interactions_block.py,sha256=34VaHFrdKsq1hYuXrosmpP15JU26dSfbyx4lyt1jxNg,28440
+celldetective/gui/interactions_block.py,sha256=G_ejjMPFwX3Zy99iZwyYyINkpA7QBDMtyS08vzANl0U,28786
 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=ljNbsKmFXQk0R9zEfBZ6XfBHzFmlL7Gt6QyPHyqh08g,38357
-celldetective/gui/pair_event_annotator.py,sha256=9PT67-8FJxcL7lSDIAZcZmrW75G_R-fpRellMOsgets,128788
+celldetective/gui/pair_event_annotator.py,sha256=dXGWrn64Iu9kjr2S3LjUzCHny2QOC3Q-qrOSqtvLvg0,128930
 celldetective/gui/plot_measurements.py,sha256=a_Mks-5XUTn2QEYih0PlXGp2lX3C34zuhK9ozzE1guM,56593
 celldetective/gui/plot_signals_ui.py,sha256=fxgkUZ_m7jFTXOwdzfJdl8wt3n8RECny3n4Tpk-GE6w,29016
 celldetective/gui/preprocessing_block.py,sha256=cgUBv-eQBwfidK48-cTWJi0PS62wlXhsNLnsKhy6MQY,14967
@@ -47,7 +47,7 @@ celldetective/gui/base/channel_norm_generator.py,sha256=HJ57wBMdBIvca92V477T-aPu
 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=mSiIYvEfz7MYMgdPDf6RKSMpKN8FkeZL7lugDNnDpnM,2245
-celldetective/gui/base/list_widget.py,sha256=APt7rCfMRRlFnHUwvwrwZGMTYM6M10zgu6uoHHsmmuA,4694
+celldetective/gui/base/list_widget.py,sha256=jHA21z6KsMigTxVJn4g7Vcs5ufR2vGSm-8GJYWflUXA,5125
 celldetective/gui/base/styles.py,sha256=3Kz1eXw6OLr90wtErhK0KPJyJbyhAlqkniqm0JNGwFc,7407
 celldetective/gui/base/utils.py,sha256=KojauRKGM9XKNhaWn211p6mJNZWIHLH75yeLpDd7pvA,1103
 celldetective/gui/help/DL-segmentation-strategy.json,sha256=PZD9xXjrwbX3TiudHJPuvcyZD28o4k-fVgeTd7dBKzI,1583
@@ -74,8 +74,8 @@ celldetective/gui/settings/_event_detection_model_params.py,sha256=f3jkh6f3oE-_5
 celldetective/gui/settings/_segmentation_model_params.py,sha256=YooEXRlkmOlHCyReiFynagrxBQn2y-dTB0FgowqZno0,6471
 celldetective/gui/settings/_settings_base.py,sha256=_Yfq6vLkwm4FW5n0-SjVQjdhfL3hR5pUGBc0ttq_YXE,2576
 celldetective/gui/settings/_settings_event_model_training.py,sha256=hpA5DTCPIMe1aVZDqO_6FudEP3a-IO6SVPfys-gdfXY,30346
-celldetective/gui/settings/_settings_measurements.py,sha256=C2jDTeB_M5RgSQT4MhepoHl_s5isxUoJyC3AbEqAmzs,48341
-celldetective/gui/settings/_settings_neighborhood.py,sha256=ws6H99bKU4NYd2IYyaJj7g9-MScr5W6UB2raP88ytfE,23767
+celldetective/gui/settings/_settings_measurements.py,sha256=SghdNs1x-XdZysh1e9WtgrzVViNSWXe3jFgQ-ee6b5U,48345
+celldetective/gui/settings/_settings_neighborhood.py,sha256=_gMoKbJOx-ssJEqf_BabI94byP6zWUg37ZM1P83tMTU,23807
 celldetective/gui/settings/_settings_segmentation.py,sha256=6DihD1mk-dN4Sstdth1iJ-0HR34rTVlTHP-pXUh_rY0,1901
 celldetective/gui/settings/_settings_segmentation_model_training.py,sha256=g-y5ZTZDwGaaevm6eI3XK_QU8PbZOY0jBdFyb1kAsqA,30440
 celldetective/gui/settings/_settings_signal_annotator.py,sha256=9LRAgOn3qcbHctAXpTDlySGSCm6kMX2Qwqpeuwz384E,11601
@@ -90,7 +90,7 @@ celldetective/gui/table_ops/_rename_col.py,sha256=UAgDSpXJo_h4pLJpHaNc2w2VhbaW4D
 celldetective/gui/viewers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 celldetective/gui/viewers/base_viewer.py,sha256=Wn4na79xRL1R6PSXIoE_UabxJNtNQ-Y5l9Q-HSb508c,32013
 celldetective/gui/viewers/channel_offset_viewer.py,sha256=cywBkxyMPyKIuwZTGA03DBSS4a-H1SAohMJYOPISLEE,16289
-celldetective/gui/viewers/contour_viewer.py,sha256=riHj03LKXLoa-Ys2o2EhCE5nULfcHMohx9LFoXbI6zU,14720
+celldetective/gui/viewers/contour_viewer.py,sha256=gRAVkwIrAQKN9hFbWNYOO8RDOw50l92owIvDM1q5Cno,15360
 celldetective/gui/viewers/size_viewer.py,sha256=uXITjaxg5dhQ09Q6TNUxwLxi-ZglyGFcxEH1RtGIZWw,6020
 celldetective/gui/viewers/spot_detection_viewer.py,sha256=JSo6tpb7qBxGjUzUXQ-Zi4uts74eVZ2gxUdD67yhQ4A,17195
 celldetective/gui/viewers/threshold_viewer.py,sha256=F-13JF2wFhyvvKfUvgRcSjWL3leAliOXy5yUergndnE,12000
@@ -153,7 +153,7 @@ celldetective/utils/image_transforms.py,sha256=cgaHuEUArWWHgxlBlcQLf--zQa-4VphPJ
 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=g3QHtqyVg6RN0BfmDoPXVjwL3O4xa_dKPC_ZeGmzkeE,7064
+celldetective/utils/masks.py,sha256=ZynSkciNkiY2F9lxxW02ZwPS_54VnF9S1M0PNi7vT5M,7483
 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
@@ -167,13 +167,14 @@ celldetective/utils/event_detection/__init__.py,sha256=GvsdyQLMTXJj1S_FfRXjrpOxE
 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=SY2kxFNXSRjXN4ncs3heDdXT3UNk8M3dELJQySysAf4,4231
-celldetective-1.5.0b10.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+celldetective-1.5.0b11.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_contour_format.py,sha256=N11Rue_mxxwsZBhocRA621bpt4Cps-1DnPGzhKLSq9o,10873
 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=YAvSr9nhLB3svDtqHTn7HDpcnYDfsZ5owYs7f_SHcDw,7459
+tests/test_measure.py,sha256=xmp-fuTzOpquiqnk3CJC0vAMLZIkcCPstx3Ru8sOtzU,10963
 tests/test_neighborhood.py,sha256=gk5FmoI7ANEczUtNXYRxc48KzkfYzemwS_eYaLq4_NI,2093
 tests/test_notebooks.py,sha256=7HVmYiytsz0QIJ11iRkGGs4_hzNjofXAUs_OZou3Gm0,301
 tests/test_partial_install.py,sha256=G69-GNcJ9YNgs6K2bVTEZO0Jpb14xMRQWTm8A6VuIco,2841
@@ -184,12 +185,13 @@ 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_event_annotator_cleanup.py,sha256=nIFWqC3za06VF5n8EDnK-URbir2WiXzECBeNaVNS_FI,11226
 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
 tests/gui/test_spot_detection_viewer.py,sha256=mCEsfTAJb5W5IeLyQmaZXq9Sjr8ehCI552RkiCEQvLw,13355
-celldetective-1.5.0b10.dist-info/METADATA,sha256=U95LVqETyItm4fg_WN8Dtv6djrbxjjrUAZ7siFYHehM,11524
-celldetective-1.5.0b10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-celldetective-1.5.0b10.dist-info/entry_points.txt,sha256=2NU6_EOByvPxqBbCvjwxlVlvnQreqZ3BKRCVIKEv3dg,62
-celldetective-1.5.0b10.dist-info/top_level.txt,sha256=6rsIKKfGMKgud7HPuATcpq6EhdXwcg_yknBVWn9x4C4,20
-celldetective-1.5.0b10.dist-info/RECORD,,
+celldetective-1.5.0b11.dist-info/METADATA,sha256=hdMBe_-bLh4h2hnn_mfZ-uA1ZUHY2ThZ31CzQJNqHVY,11524
+celldetective-1.5.0b11.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+celldetective-1.5.0b11.dist-info/entry_points.txt,sha256=2NU6_EOByvPxqBbCvjwxlVlvnQreqZ3BKRCVIKEv3dg,62
+celldetective-1.5.0b11.dist-info/top_level.txt,sha256=6rsIKKfGMKgud7HPuATcpq6EhdXwcg_yknBVWn9x4C4,20
+celldetective-1.5.0b11.dist-info/RECORD,,

tests/gui/test_event_annotator_cleanup.py

@@ -0,0 +1,310 @@
+"""
+Tests for EventAnnotator and PairEventAnnotator closeEvent cleanup.
+
+These tests verify that the memory leak fixes in closeEvent properly:
+1. Close matplotlib figures
+2. Stop and delete animations
+3. Clear large data structures
+4. Call super().closeEvent()
+
+Bug prevented: Memory leaks from unclosed matplotlib figures and FuncAnimation
+reference cycles when closing the annotator windows.
+"""
+
+import pytest
+import gc
+import logging
+from unittest.mock import MagicMock, patch, PropertyMock
+import matplotlib.pyplot as plt
+from PyQt5.QtGui import QCloseEvent
+
+
+@pytest.fixture(autouse=True)
+def disable_logging():
+    """Disable all logging to avoid Windows OSError with pytest capture."""
+    try:
+        logging.disable(logging.CRITICAL)
+        yield
+    finally:
+        logging.disable(logging.NOTSET)
+
+
+class TestEventAnnotatorCloseEvent:
+    """
+    Tests for EventAnnotator.closeEvent memory cleanup.
+
+    Bug: closeEvent did not properly close matplotlib figures or delete
+    the FuncAnimation, causing memory leaks due to reference cycles.
+
+    Fix: Added proper cleanup of fig, cell_fig, anim, stack, and df_tracks.
+    """
+
+    def test_closeevent_closes_matplotlib_figures(self, qtbot):
+        """
+        Test that closeEvent properly closes matplotlib figures.
+
+        Steps:
+        1. Create a mock EventAnnotator with fig and cell_fig attributes
+        2. Call closeEvent
+        3. Verify plt.close was called for both figures
+        """
+        with patch("celldetective.gui.event_annotator.plt") as mock_plt:
+            # Create a minimal mock that simulates the annotator
+            from celldetective.gui.event_annotator import EventAnnotator
+
+            # Mock the parent and initialization to avoid complex setup
+            with patch.object(EventAnnotator, "__init__", lambda self, parent: None):
+                annotator = EventAnnotator(None)
+
+                # Set up minimal attributes needed for closeEvent
+                annotator.fig = MagicMock()
+                annotator.cell_fig = MagicMock()
+                annotator.anim = MagicMock()
+                annotator.anim.event_source = MagicMock()
+                annotator.stack = MagicMock()
+                annotator.df_tracks = MagicMock()
+                annotator.stop = MagicMock()
+
+                # Mock stop_btn for stop() method if needed
+                annotator.stop_btn = MagicMock()
+                annotator.start_btn = MagicMock()
+                annotator.prev_frame_btn = MagicMock()
+                annotator.next_frame_btn = MagicMock()
+
+                # Create a real QCloseEvent
+                event = QCloseEvent()
+
+                # Patch super().closeEvent to avoid Qt issues
+                with patch.object(EventAnnotator.__bases__[0], "closeEvent"):
+                    EventAnnotator.closeEvent(annotator, event)
+
+                # Verify figures were closed
+                assert mock_plt.close.call_count >= 2
+
+    def test_closeevent_stops_animation(self, qtbot):
+        """
+        Test that closeEvent stops the animation.
+
+        Steps:
+        1. Create mock annotator with anim attribute
+        2. Call closeEvent
+        3. Verify animation event_source.stop() was called
+        """
+        from celldetective.gui.event_annotator import EventAnnotator
+
+        with patch.object(EventAnnotator, "__init__", lambda self, parent: None):
+            annotator = EventAnnotator(None)
+
+            # Set up animation mock
+            mock_anim = MagicMock()
+            mock_anim.event_source = MagicMock()
+            annotator.anim = mock_anim
+
+            # Set up other required attributes
+            annotator.fig = MagicMock()
+            annotator.cell_fig = MagicMock()
+            annotator.stack = MagicMock()
+            annotator.df_tracks = MagicMock()
+            annotator.stop = MagicMock()
+            annotator.stop_btn = MagicMock()
+            annotator.start_btn = MagicMock()
+            annotator.prev_frame_btn = MagicMock()
+            annotator.next_frame_btn = MagicMock()
+
+            event = QCloseEvent()
+
+            with patch("celldetective.gui.event_annotator.plt"):
+                with patch.object(EventAnnotator.__bases__[0], "closeEvent"):
+                    EventAnnotator.closeEvent(annotator, event)
+
+            # Verify animation was stopped
+            mock_anim.event_source.stop.assert_called_once()
+
+
+class TestPairEventAnnotatorCloseEvent:
+    """
+    Tests for PairEventAnnotator.closeEvent memory cleanup.
+
+    Bug: closeEvent only deleted self.stack and didn't close figures,
+    stop animations, or clear dataframes.
+
+    Fix: Added proper cleanup of fig, cell_fig, anim, stack, dataframes,
+    and df_relative. Also calls super().closeEvent().
+    """
+
+    def test_closeevent_clears_dataframes(self, qtbot):
+        """
+        Test that closeEvent properly clears dataframes dictionary.
+
+        Steps:
+        1. Create mock PairEventAnnotator with dataframes attribute
+        2. Call closeEvent
+        3. Verify dataframes.clear() was called
+        """
+        from celldetective.gui.pair_event_annotator import PairEventAnnotator
+
+        with patch.object(PairEventAnnotator, "__init__", lambda self, parent: None):
+            annotator = PairEventAnnotator(None)
+
+            # Set up dataframes mock
+            mock_dataframes = MagicMock()
+            annotator.dataframes = mock_dataframes
+
+            # Set up other required attributes
+            annotator.fig = MagicMock()
+            annotator.cell_fig = MagicMock()
+            annotator.anim = MagicMock()
+            annotator.anim.event_source = MagicMock()
+            annotator.stack = MagicMock()
+            annotator.df_relative = MagicMock()
+            annotator.stop = MagicMock()
+            annotator.stop_btn = MagicMock()
+            annotator.start_btn = MagicMock()
+            annotator.prev_frame_btn = MagicMock()
+            annotator.next_frame_btn = MagicMock()
+
+            event = QCloseEvent()
+
+            with patch("celldetective.gui.pair_event_annotator.plt"):
+                with patch.object(PairEventAnnotator.__bases__[0], "closeEvent"):
+                    PairEventAnnotator.closeEvent(annotator, event)
+
+            # Verify dataframes.clear() was called
+            mock_dataframes.clear.assert_called_once()
+
+    def test_closeevent_deletes_df_relative(self):
+        """
+        Test that closeEvent code deletes df_relative.
+
+        Steps:
+        1. Inspect the closeEvent source code
+        2. Verify it contains the delete statement for df_relative
+        """
+        import inspect
+        from celldetective.gui.pair_event_annotator import PairEventAnnotator
+
+        source = inspect.getsource(PairEventAnnotator.closeEvent)
+
+        # Verify the cleanup code exists
+        assert "del self.df_relative" in source or "df_relative" in source
+
+    def test_closeevent_closes_figures(self, qtbot):
+        """
+        Test that closeEvent properly closes matplotlib figures.
+
+        Steps:
+        1. Create mock PairEventAnnotator with fig and cell_fig
+        2. Call closeEvent
+        3. Verify plt.close was called
+        """
+        from celldetective.gui.pair_event_annotator import PairEventAnnotator
+
+        with patch("celldetective.gui.pair_event_annotator.plt") as mock_plt:
+            with patch.object(
+                PairEventAnnotator, "__init__", lambda self, parent: None
+            ):
+                annotator = PairEventAnnotator(None)
+
+                # Set up required attributes
+                annotator.fig = MagicMock()
+                annotator.cell_fig = MagicMock()
+                annotator.anim = MagicMock()
+                annotator.anim.event_source = MagicMock()
+                annotator.stack = MagicMock()
+                annotator.dataframes = {}
+                annotator.df_relative = MagicMock()
+                annotator.stop = MagicMock()
+                annotator.stop_btn = MagicMock()
+                annotator.start_btn = MagicMock()
+                annotator.prev_frame_btn = MagicMock()
+                annotator.next_frame_btn = MagicMock()
+
+                event = QCloseEvent()
+
+                with patch.object(PairEventAnnotator.__bases__[0], "closeEvent"):
+                    PairEventAnnotator.closeEvent(annotator, event)
+
+                # Verify figures were closed
+                assert mock_plt.close.call_count >= 2
+
+
+class TestPairEventAnnotatorNoDuplicateMethods:
+    """
+    Test that duplicate method definitions have been removed.
+
+    Bug: set_first_frame and set_last_frame were defined twice in the class,
+    with the later definition shadowing the earlier one.
+
+    Fix: Removed the simpler first definitions, keeping the more complete versions.
+    """
+
+    def test_no_duplicate_set_first_frame(self):
+        """
+        Test that set_first_frame is defined only once.
+
+        Steps:
+        1. Import PairEventAnnotator
+        2. Use inspect to find all method definitions
+        3. Verify set_first_frame appears only once
+        """
+        import inspect
+        from celldetective.gui.pair_event_annotator import PairEventAnnotator
+
+        # Get the source code
+        source = inspect.getsource(PairEventAnnotator)
+
+        # Count occurrences of 'def set_first_frame'
+        count = source.count("def set_first_frame(")
+
+        assert count == 1, f"set_first_frame is defined {count} times, expected 1"
+
+    def test_no_duplicate_set_last_frame(self):
+        """
+        Test that set_last_frame is defined only once.
+
+        Steps:
+        1. Import PairEventAnnotator
+        2. Use inspect to find all method definitions
+        3. Verify set_last_frame appears only once
+        """
+        import inspect
+        from celldetective.gui.pair_event_annotator import PairEventAnnotator
+
+        # Get the source code
+        source = inspect.getsource(PairEventAnnotator)
+
+        # Count occurrences of 'def set_last_frame'
+        count = source.count("def set_last_frame(")
+
+        assert count == 1, f"set_last_frame is defined {count} times, expected 1"
+
+
+class TestPairEventAnnotatorNoNeighborhoodsError:
+    """
+    Test that PairEventAnnotator raises ValueError when no neighborhoods detected.
+
+    Bug: PairEventAnnotator crashed with KeyError when opened without computed
+    neighborhoods.
+
+    Fix: Added check for empty neighborhood_cols and raise ValueError with
+    user-friendly message.
+    """
+
+    def test_raises_valueerror_on_empty_neighborhoods(self, qtbot):
+        """
+        Test that ValueError is raised when neighborhood_cols is empty.
+
+        Steps:
+        1. Mock PairEventAnnotator initialization to simulate empty neighborhoods
+        2. Verify ValueError is raised with appropriate message
+        """
+        # This is a more complex test that would require mocking the entire
+        # initialization chain. For now, we test the check exists in the code.
+        import inspect
+        from celldetective.gui.pair_event_annotator import PairEventAnnotator
+
+        source = inspect.getsource(PairEventAnnotator.__init__)
+
+        # Verify the check exists
+        assert "len(self.neighborhood_cols) == 0" in source
+        assert "raise ValueError" in source

tests/test_contour_format.py

@@ -0,0 +1,299 @@
+"""
+Unit tests for contour measurement format parsing and interpretation.
+
+Tests the complete pipeline:
+1. CellEdgeVisualizer output format: "(min,max)"
+2. ListWidget.getItems() parsing
+3. contour_of_instance_segmentation() interpretation
+4. measure_features() with border_distances
+"""
+
+import unittest
+import numpy as np
+import pandas as pd
+
+
+class TestContourFormatParsing(unittest.TestCase):
+    """
+    Test that the contour format "(min,max)" is correctly parsed by list_widget.getItems()
+    and contour_of_instance_segmentation().
+    """
+
+    def test_tuple_format_parsing_positive(self):
+        """Test parsing of positive range like (0,5)"""
+        from celldetective.utils.masks import contour_of_instance_segmentation
+
+        # Create a simple label with a square object
+        label = np.zeros((50, 50), dtype=int)
+        label[15:35, 15:35] = 1  # 20x20 square
+
+        # Test with tuple format string "(0,5)" - inner contour 0-5px
+        result = contour_of_instance_segmentation(label, "(0,5)")
+
+        # Should have non-zero pixels (edge region exists)
+        self.assertGreater(np.sum(result > 0), 0, "Contour should have pixels")
+
+        # The result should be smaller than the original object
+        self.assertLess(
+            np.sum(result > 0), np.sum(label > 0), "Edge should be smaller than object"
+        )
+
+    def test_tuple_format_parsing_negative(self):
+        """Test parsing of negative range like (-5,0) - outer contour"""
+        from celldetective.utils.masks import contour_of_instance_segmentation
+
+        label = np.zeros((50, 50), dtype=int)
+        label[15:35, 15:35] = 1
+
+        # Test with tuple format string "(-5,0)" - outer contour
+        result = contour_of_instance_segmentation(label, "(-5,0)")
+
+        # Should have non-zero pixels in the region outside the original object
+        self.assertGreater(np.sum(result > 0), 0, "Outer contour should have pixels")
+
+    def test_tuple_format_parsing_mixed(self):
+        """Test parsing of mixed range like (-3,3) - crossing boundary"""
+        from celldetective.utils.masks import contour_of_instance_segmentation
+
+        label = np.zeros((50, 50), dtype=int)
+        label[15:35, 15:35] = 1
+
+        # Test with tuple format string "(-3,3)" - straddles boundary
+        result = contour_of_instance_segmentation(label, "(-3,3)")
+
+        # Should have non-zero pixels
+        self.assertGreater(np.sum(result > 0), 0, "Mixed contour should have pixels")
+
+    def test_list_format_direct(self):
+        """Test that list format [min, max] works correctly"""
+        from celldetective.utils.masks import contour_of_instance_segmentation
+
+        label = np.zeros((50, 50), dtype=int)
+        label[15:35, 15:35] = 1
+
+        # Test with list format [-5, 5]
+        result = contour_of_instance_segmentation(label, [-5, 5])
+
+        self.assertGreater(np.sum(result > 0), 0, "List format should work")
+
+    def test_tuple_format_direct(self):
+        """Test that tuple format (min, max) works correctly"""
+        from celldetective.utils.masks import contour_of_instance_segmentation
+
+        label = np.zeros((50, 50), dtype=int)
+        label[15:35, 15:35] = 1
+
+        # Test with tuple format (-5, 5)
+        result = contour_of_instance_segmentation(label, (-5, 5))
+
+        self.assertGreater(np.sum(result > 0), 0, "Tuple format should work")
+
+
+class TestListWidgetParsing(unittest.TestCase):
+    """
+    Test that ListWidget.getItems() correctly parses the "(min,max)" format.
+    """
+
+    def setUp(self):
+        """Set up a mock list widget for testing."""
+        from unittest.mock import MagicMock
+
+        # Create a mock item that returns text
+        self.mock_item = MagicMock()
+        self.mock_list_widget = MagicMock()
+
+    def test_parse_tuple_format(self):
+        """Test that getItems parses (min,max) format correctly."""
+        import re
+
+        # Simulate the parsing logic from getItems
+        tuple_pattern = re.compile(r"^\((-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)\)$")
+
+        test_cases = [
+            ("(0,5)", [0, 5]),
+            ("(-5,0)", [-5, 0]),
+            ("(-10,10)", [-10, 10]),
+            ("(-3,3)", [-3, 3]),
+            ("(0, 10)", [0, 10]),  # with space
+        ]
+
+        for text, expected in test_cases:
+            match = tuple_pattern.match(text.strip())
+            self.assertIsNotNone(match, f"Should match pattern: {text}")
+            minn = int(float(match.group(1)))
+            maxx = int(float(match.group(2)))
+            self.assertEqual([minn, maxx], expected, f"Failed for: {text}")
+
+    def test_parse_single_value(self):
+        """Test that single values are parsed correctly."""
+        import re
+
+        tuple_pattern = re.compile(r"^\((-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)\)$")
+
+        test_cases = ["5", "10", "-5", "0"]
+
+        for text in test_cases:
+            match = tuple_pattern.match(text.strip())
+            self.assertIsNone(match, f"Should NOT match tuple pattern: {text}")
+            # Should be parseable as int
+            val = int(text)
+            self.assertIsInstance(val, int)
+
+
+class TestContourMeasurementIntegration(unittest.TestCase):
+    """
+    Integration test for the complete contour measurement pipeline.
+    Tests that measure_features correctly uses border_distances with the new format.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        """Create test data for all tests."""
+        # Create a larger image with clear intensity gradient
+        cls.frame = np.ones((100, 100, 1), dtype=float)
+        # Create a gradient - center is brighter
+        for i in range(100):
+            for j in range(100):
+                dist_from_center = np.sqrt((i - 50) ** 2 + (j - 50) ** 2)
+                cls.frame[i, j, 0] = max(0, 1 - dist_from_center / 50)
+
+        # Create a single centered object
+        cls.labels = np.zeros((100, 100), dtype=int)
+        cls.labels[35:65, 35:65] = 1  # 30x30 square centered at (50, 50)
+
+    def test_measure_with_list_border_distance(self):
+        """Test that measure_features works with list [min, max] border distance."""
+        from celldetective.measure import measure_features
+
+        result = measure_features(
+            self.frame,
+            self.labels,
+            features=["intensity_mean"],
+            channels=["test"],
+            border_dist=[[-5, 5]],  # Edge region from -5 to +5 around boundary
+        )
+
+        self.assertIsInstance(result, pd.DataFrame)
+        self.assertEqual(len(result), 1)
+        # Check that edge intensity column exists
+        edge_cols = [c for c in result.columns if "edge" in c or "slice" in c]
+        self.assertGreater(len(edge_cols), 0, "Should have edge measurement columns")
+
+    def test_measure_with_positive_only_border(self):
+        """Test inner contour measurement [0, 5]."""
+        from celldetective.measure import measure_features
+
+        result = measure_features(
+            self.frame,
+            self.labels,
+            features=["intensity_mean"],
+            channels=["test"],
+            border_dist=[[0, 5]],  # Inner edge only
+        )
+
+        self.assertIsInstance(result, pd.DataFrame)
+        self.assertEqual(len(result), 1)
+
+    def test_measure_with_negative_only_border(self):
+        """Test outer contour measurement [-5, 0]."""
+        from celldetective.measure import measure_features
+
+        result = measure_features(
+            self.frame,
+            self.labels,
+            features=["intensity_mean"],
+            channels=["test"],
+            border_dist=[[-5, 0]],  # Outer edge only
+        )
+
+        self.assertIsInstance(result, pd.DataFrame)
+        self.assertEqual(len(result), 1)
+
+    def test_measure_with_scalar_border_distance(self):
+        """Test that scalar border_dist still works (backwards compatibility)."""
+        from celldetective.measure import measure_features
+
+        result = measure_features(
+            self.frame,
+            self.labels,
+            features=["intensity_mean"],
+            channels=["test"],
+            border_dist=[5],  # Scalar - should be interpreted as [0, 5]
+        )
+
+        self.assertIsInstance(result, pd.DataFrame)
+        self.assertEqual(len(result), 1)
+
+
+class TestContourWithEdgeCases(unittest.TestCase):
+    """Test edge cases and potential issues with contour computation."""
+
+    def test_small_object_with_large_contour(self):
+        """Test that small objects with large contour distance don't crash."""
+        from celldetective.utils.masks import contour_of_instance_segmentation
+
+        # Very small object
+        label = np.zeros((50, 50), dtype=int)
+        label[24:26, 24:26] = 1  # 2x2 pixel object
+
+        # Large contour request - may result in empty contour
+        result = contour_of_instance_segmentation(label, [0, 10])
+
+        # Should not crash, may be empty or small
+        self.assertEqual(result.shape, label.shape)
+
+    def test_empty_label_returns_zeros(self):
+        """Test that empty labels return zero array."""
+        from celldetective.utils.masks import contour_of_instance_segmentation
+
+        label = np.zeros((50, 50), dtype=int)
+
+        result = contour_of_instance_segmentation(label, [0, 5])
+
+        self.assertTrue(np.all(result == 0), "Empty label should return zeros")
+
+    def test_multiple_objects(self):
+        """Test contour with multiple distinct objects."""
+        from celldetective.utils.masks import contour_of_instance_segmentation
+
+        label = np.zeros((100, 100), dtype=int)
+        label[10:30, 10:30] = 1
+        label[60:80, 60:80] = 2
+
+        result = contour_of_instance_segmentation(label, [0, 3])
+
+        # Should have both object IDs in result
+        unique_ids = np.unique(result[result > 0])
+        self.assertIn(1, unique_ids, "Object 1 should be in result")
+        self.assertIn(2, unique_ids, "Object 2 should be in result")
+
+
+class TestSuffixFormatting(unittest.TestCase):
+    """Test that measurement column names are formatted correctly."""
+
+    def test_get_suffix_function(self):
+        """Test the get_suffix helper function logic."""
+
+        # Simulate the get_suffix function from measure.py
+        def get_suffix(d):
+            d_str = str(d)
+            d_clean = (
+                d_str.replace("(", "")
+                .replace(")", "")
+                .replace(", ", "_")
+                .replace(",", "_")
+            )
+            if "-" in d_str or "," in d_str:
+                return f"_slice_{d_clean.replace('-', 'm')}px"
+            else:
+                return f"_edge_{d_clean}px"
+
+        # Test cases
+        self.assertEqual(get_suffix(5), "_edge_5px")
+        self.assertEqual(get_suffix(-5), "_slice_m5px")
+        self.assertEqual(get_suffix([0, 5]), "_slice_[0_5]px")
+        self.assertEqual(get_suffix([-5, 5]), "_slice_[m5_5]px")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_measure.py

@@ -239,5 +239,92 @@ class TestNumpyArrayHandling(unittest.TestCase):
             self.fail(f"Spot detection failed with numpy array channels: {e}")
 
 
+class TestExtraPropertiesNotAutoIncluded(unittest.TestCase):
+    """
+    Regression test for bug where ALL extra_properties functions containing 'intensity'
+    were being included in edge measurements, instead of only user-requested ones.
+
+    Bug: In measure_features(), when border_dist was set, the code used `extra`
+    (ALL available extra_properties functions) instead of `requested_extra_names`
+    (only user-requested ones). This caused unwanted measurements and warnings.
+
+    Fix: Changed to use only requested_extra_names in intensity_features list.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        """Create simple test data."""
+        cls.frame = np.ones((100, 100, 1), dtype=float)
+        cls.labels = np.zeros((100, 100), dtype=int)
+        cls.labels[40:60, 40:60] = 1  # 20x20 square
+
+    def test_border_dist_does_not_include_unrequested_extra_props(self):
+        """
+        Test that edge measurements only include requested features,
+        not all extra_properties containing 'intensity'.
+
+        Before fix: Would include ~30+ extra_properties functions with 'intensity'.
+        After fix: Only includes explicitly requested features.
+        """
+        result = measure_features(
+            self.frame,
+            self.labels,
+            features=["intensity_mean"],  # Only request mean intensity
+            channels=["test"],
+            border_dist=[5],
+        )
+
+        self.assertIsInstance(result, pd.DataFrame)
+
+        # Get all column names related to edge/slice measurements
+        edge_columns = [c for c in result.columns if "edge" in c or "slice" in c]
+
+        # Should only have requested intensity_mean edge measurement, not all extra_properties
+        # Before the fix, this would include many unwanted columns like:
+        # - mean_dark_intensity_*
+        # - intensity_percentile_*
+        # - etc.
+
+        # Count intensity-related edge columns - should be minimal (just what we requested)
+        intensity_edge_cols = [
+            c for c in edge_columns if "intensity" in c.lower() or "mean" in c.lower()
+        ]
+
+        # We requested only intensity_mean, so should have at most 1-2 edge columns per channel
+        # (the mean intensity for the edge region)
+        # Before the fix, this would be 30+ columns
+        self.assertLess(
+            len(intensity_edge_cols),
+            10,
+            f"Too many intensity edge columns found ({len(intensity_edge_cols)}). "
+            f"This suggests unrequested extra_properties are being included. "
+            f"Columns: {intensity_edge_cols}",
+        )
+
+    def test_no_features_requested_only_adds_mean(self):
+        """
+        Test that when no intensity features are requested, only basic mean is added.
+        Should not include all extra_properties.
+        """
+        result = measure_features(
+            self.frame,
+            self.labels,
+            features=["area"],  # Non-intensity feature only
+            channels=["test"],
+            border_dist=[5],
+        )
+
+        self.assertIsInstance(result, pd.DataFrame)
+
+        # Should have area column
+        self.assertIn("area", result.columns)
+
+        # Edge columns should only have basic intensity (auto-added for edges)
+        edge_columns = [c for c in result.columns if "edge" in c or "slice" in c]
+
+        # Should have minimal edge measurements (just auto-added mean for edge measurement)
+        self.assertLess(len(edge_columns), 10, f"Too many edge columns: {edge_columns}")
+
+
 if __name__ == "__main__":
     unittest.main()