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

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/gui/test_spot_detection_viewer.py

@@ -185,3 +185,210 @@ def test_spot_detection_visualizer_interactions(qtbot, dummy_data):
     # Preview should revert to original
     reverted_img = viewer.im.get_array()
     np.testing.assert_array_equal(reverted_img, expected_img)
+
+
+@pytest.fixture
+def dark_spots_data():
+    """
+    Create a dummy stack with DARK spots on a BRIGHT background.
+    This simulates scenarios like:
+    - Absorbing particles on a bright field
+    - Phase contrast imaging with dark nuclei
+    The invert preprocessing filter should be used to detect these spots.
+    """
+    frames = 5
+    y, x = 100, 100
+    channels = 2
+
+    # Bright background (value 1000)
+    stack = np.ones((frames, y, x, channels), dtype=np.float32) * 1000
+
+    # Create coordinate grids
+    Y, X = np.ogrid[:y, :x]
+
+    # Dark Gaussian spot 1 at (22, 22)
+    center_y1, center_x1 = 22, 22
+    sigma = 2.0
+    gaussian1 = np.exp(-((Y - center_y1) ** 2 + (X - center_x1) ** 2) / (2 * sigma**2))
+
+    # Dark Gaussian spot 2 at (62, 62)
+    center_y2, center_x2 = 62, 62
+    gaussian2 = np.exp(-((Y - center_y2) ** 2 + (X - center_x2) ** 2) / (2 * sigma**2))
+
+    # Subtract from bright background to create dark spots
+    # Spot 1: drops to ~0 at center, Spot 2: drops to ~200 at center
+    dark_spots_frame = 1000 - (gaussian1 * 1000 + gaussian2 * 800)
+    dark_spots_frame = dark_spots_frame.astype(np.float32)
+
+    for f in range(frames):
+        stack[f, :, :, 1] = dark_spots_frame
+
+    # Channel 0 stays uniform bright (no spots)
+
+    # Create dummy masks
+    masks = np.zeros((frames, y, x), dtype=np.uint16)
+    masks[:, 15:30, 15:30] = 1  # Mask around Spot 1
+    masks[:, 55:70, 55:70] = 2  # Mask around Spot 2
+
+    return stack, masks
+
+
+def test_dark_spot_detection_with_invert(qtbot, dark_spots_data):
+    """
+    Test detection of dark spots on a bright background using the invert filter.
+
+    Bug Prevention:
+    - Ensures the preprocessing pipeline (invert) correctly transforms images
+      before spot detection.
+    - Verifies that the detection uses the preprocessed image, not the raw image.
+
+    Steps:
+    1. Load stack with dark spots on bright background.
+    2. Switch to the dark spots channel.
+    3. Add an "invert" preprocessing filter with max value 1000.
+    4. Set detection parameters (diameter, threshold).
+    5. Trigger detection.
+    6. Verify that both dark spots are detected.
+
+    Expected Outcome:
+    - 2 spots detected at positions (22, 22) and (62, 62).
+    """
+    stack, labels = dark_spots_data
+    channel_names = ["Uniform", "DarkSpots"]
+
+    parent_channel_cb = MagicMock()
+    parent_diameter_le = MagicMock()
+    parent_threshold_le = MagicMock()
+    parent_preprocessing_list = MagicMock()
+
+    viewer = SpotDetectionVisualizer(
+        stack=stack,
+        labels=labels,
+        channel_names=channel_names,
+        n_channels=2,
+        parent_channel_cb=parent_channel_cb,
+        parent_diameter_le=parent_diameter_le,
+        parent_threshold_le=parent_threshold_le,
+        parent_preprocessing_list=parent_preprocessing_list,
+        window_title="Test Dark Spot Detection",
+        channel_cb=True,
+        contrast_slider=False,
+        frame_slider=False,
+    )
+
+    qtbot.addWidget(viewer)
+    viewer.show()
+    qtbot.waitForWindowShown(viewer)
+
+    # 1. Switch to DarkSpots channel (Index 1)
+    viewer.detection_channel_cb.setCurrentIndex(1)
+    assert viewer.detection_channel == 1
+    viewer.change_frame(0)
+
+    # Verify image is bright with dark spots
+    current_img = viewer.target_img
+    # The center of spot 1 (22, 22) should be dark (near 0)
+    assert (
+        current_img[22, 22] < 100
+    ), f"Expected dark spot at (22,22), got {current_img[22, 22]}"
+    # The background should be bright (near 1000)
+    assert (
+        current_img[0, 0] > 900
+    ), f"Expected bright background, got {current_img[0, 0]}"
+
+    # 2. Add invert preprocessing filter
+    # invert filter inverts the image: output = max_value - input
+    # With max_value=1000, dark spots become bright spots
+    viewer.preprocessing.list.items.append(["invert", 1000])
+    viewer.preprocessing.list.list_widget.addItems(["invert_1000"])
+
+    # 3. Set detection parameters
+    viewer.spot_diam_le.clear()
+    qtbot.keyClicks(viewer.spot_diam_le, "4")
+    viewer.spot_thresh_le.clear()
+    qtbot.keyClicks(viewer.spot_thresh_le, "0.01")
+    viewer.control_valid_parameters()
+
+    assert viewer.diameter == 4.0
+    assert viewer.thresh == 0.01
+
+    # Enable preview to verify inversion works
+    viewer.preview_cb.setChecked(True)
+    viewer.update_preview_if_active()
+    qtbot.wait(200)
+
+    # After inversion, the former dark spot at (22, 22) should now be bright
+    preview_img = viewer.im.get_array()
+    assert (
+        preview_img[22, 22] > 900
+    ), f"After invert, spot should be bright. Got {preview_img[22, 22]}"
+
+    # 4. Trigger detection
+    qtbot.mouseClick(viewer.apply_diam_btn, 1)
+    qtbot.wait(200)
+
+    # 5. Verify spots detected
+    n_spots = (
+        len(viewer.spot_positions)
+        if hasattr(viewer, "spot_positions") and viewer.spot_positions is not None
+        else 0
+    )
+    assert (
+        n_spots == 2
+    ), f"Expected 2 dark spots detected, found {n_spots}. Positions: {getattr(viewer, 'spot_positions', 'N/A')}"
+
+    # Verify positions
+    pos = viewer.spot_positions
+    has_spot_1 = np.any(np.all(np.abs(pos - [22, 22]) < 5, axis=1))
+    has_spot_2 = np.any(np.all(np.abs(pos - [62, 62]) < 5, axis=1))
+    assert has_spot_1, f"Dark Spot 1 not found near (22, 22). Positions: {pos}"
+    assert has_spot_2, f"Dark Spot 2 not found near (62, 62). Positions: {pos}"
+
+
+def test_viewer_initializes_from_parent_values(qtbot, dummy_data):
+    """
+    Test that the viewer initializes its widgets from initial_* arguments.
+    """
+    stack, labels = dummy_data
+    channel_names = ["Background", "Spots"]
+
+    # Mock parent widgets
+    parent_channel_cb = MagicMock()
+    parent_diameter_le = MagicMock()
+    parent_threshold_le = MagicMock()
+    parent_preprocessing_list = MagicMock()
+
+    initial_params = [["gauss", 1.5], ["invert", 500]]
+
+    viewer = SpotDetectionVisualizer(
+        stack=stack,
+        labels=labels,
+        channel_names=channel_names,
+        n_channels=2,
+        parent_channel_cb=parent_channel_cb,
+        parent_diameter_le=parent_diameter_le,
+        parent_threshold_le=parent_threshold_le,
+        parent_preprocessing_list=parent_preprocessing_list,
+        window_title="Test Init Values",
+        channel_cb=True,
+        contrast_slider=False,
+        frame_slider=False,
+        # Pass initial values
+        initial_diameter="8.5",
+        initial_threshold="1.2",
+        initial_preprocessing=initial_params,
+    )
+
+    qtbot.addWidget(viewer)
+    viewer.show()
+    qtbot.waitForWindowShown(viewer)
+
+    # Verify widgets were initialized with passed values
+    assert viewer.spot_diam_le.text() == "8.5"
+    assert viewer.spot_thresh_le.text() == "1.2"
+
+    # Verify preprocessing list was populated
+    current_filters = viewer.preprocessing.list.items
+    assert len(current_filters) == 2
+    assert current_filters[0] == ["gauss", 1.5]
+    assert current_filters[1] == ["invert", 500]