Plugin refactor [7]: Fix trajectory plot, better interactions

src/napari_deeplabcut/_tests/e2e/test_points_layers.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import numpy as np
 import pytest
 from napari.layers import Points
 
-from napari_deeplabcut.core.layers import populate_keypoint_layer_properties
+from napari_deeplabcut.core.layers import PointsInteractionObserver, populate_keypoint_layer_properties
 
 
 @pytest.mark.usefixtures("qtbot")
@@ -100,7 +102,7 @@ def test_layer_insert_does_not_crash_when_current_property_is_nan(viewer, keypoi
     layer = viewer.add_points(data, **md)
     # Plot cannot be formed because of the NaN,
     # but the layer must still be added and cycle mode must not be enabled.
-    assert keypoint_controls._matplotlib_canvas.df is None
+    assert keypoint_controls._traj_mpl_canvas.df is None
     assert isinstance(layer, Points)
     assert layer.face_color_mode != "cycle"
 
@@ -239,3 +241,71 @@ def test_copy_paste_same_frame_does_not_duplicate_existing_keypoints(
 
     # no duplicates expected on same frame
     assert len(layer.data) == before
+
+
+def test_points_interaction_observer_emits_on_selected_data_change(viewer, qtbot):
+    layer = viewer.add_points(
+        np.array([[0, 0], [1, 1]]),
+        properties={"label": np.array(["nose", "tail"], dtype=object)},
+    )
+    viewer.layers.selection.active = layer
+
+    seen = []
+
+    observer = PointsInteractionObserver(viewer, seen.append, debounce_ms=0)
+    observer.install()
+
+    layer.selected_data.select_only(1)
+
+    qtbot.waitUntil(lambda: len(seen) >= 1, timeout=1000)
+
+    evt = seen[-1]
+    assert evt.viewer is viewer
+    assert isinstance(evt.layer, Points)
+    assert "selection" in evt.reasons
+    assert tuple(sorted(evt.layer.selected_data)) == (1,)
+
+    observer.close()
+
+
+def test_points_interaction_observer_rebinds_when_active_layer_changes(viewer, qtbot):
+    layer1 = viewer.add_points(
+        np.array([[0, 0], [1, 1]]),
+        properties={"label": np.array(["nose", "tail"], dtype=object)},
+        name="points-1",
+    )
+    layer2 = viewer.add_points(
+        np.array([[2, 2], [3, 3]]),
+        properties={"label": np.array(["paw", "ear"], dtype=object)},
+        name="points-2",
+    )
+
+    seen = []
+    observer = PointsInteractionObserver(viewer, seen.append, debounce_ms=0)
+    observer.install()
+
+    viewer.layers.selection.active = layer1
+    layer1.selected_data.select_only(0)
+    qtbot.waitUntil(lambda: any("selection" in ev.reasons for ev in seen), timeout=1000)
+
+    count_after_layer1 = len(seen)
+
+    # Switch active layer
+    viewer.layers.selection.active = layer2
+    qtbot.waitUntil(lambda: len(seen) > count_after_layer1, timeout=1000)
+
+    count_after_active_switch = len(seen)
+
+    # Mutating old inactive layer selection should not produce a new callback
+    layer1.selected_data.select_only(1)
+    qtbot.wait(50)
+    assert len(seen) == count_after_active_switch
+
+    # Mutating new active layer selection should produce a callback
+    layer2.selected_data.select_only(1)
+    qtbot.waitUntil(lambda: len(seen) > count_after_active_switch, timeout=1000)
+    assert seen[-1].layer is not None
+    assert seen[-1].layer.name == layer2.name
+    assert "selection" in seen[-1].reasons
+
+    observer.close()

src/napari_deeplabcut/_tests/test_widgets.py

@@ -16,7 +16,7 @@
 from napari_deeplabcut.ui.color_scheme_display import ColorSchemeDisplay
 from napari_deeplabcut.ui.dialogs import ShortcutRow
 from napari_deeplabcut.ui.labels_and_dropdown import KeypointsDropdownMenu, LabelPair
-from napari_deeplabcut.ui.plots.trajectory import KeypointMatplotlibCanvas
+from napari_deeplabcut.ui.plots.trajectory import TrajectoryMatplotlibCanvas
 
 from .conftest import force_show
 
@@ -235,7 +235,7 @@ def test_color_scheme_display(qtbot):
 @pytest.mark.usefixtures("qtbot")
 def test_matplotlib_canvas_initialization_and_slider(viewer, points, qtbot):
     # Create the canvas widget
-    canvas = KeypointMatplotlibCanvas(viewer)
+    canvas = TrajectoryMatplotlibCanvas(viewer)
     qtbot.add_widget(canvas)
 
     # Simulate adding a Points layer (triggers _load_dataframe)
@@ -254,8 +254,11 @@ def test_matplotlib_canvas_initialization_and_slider(viewer, points, qtbot):
     assert canvas._window == initial_window + 100
     assert canvas.slider_value.text() == str(initial_window + 100)
 
-    # Test plot refresh on frame change
+    # Test plot refresh does nothing when plot is hidden
     canvas.update_plot_range(event=type("Event", (), {"value": [5]}))
+    assert canvas._n == 0
+    # Test plot refresh on frame change (forced as it is hidden)
+    canvas.update_plot_range(event=type("Event", (), {"value": [5]}), force=True)
     assert canvas._n == 5
     # Check that x-limits reflect the new window
     start, end = canvas.ax.get_xlim()
@@ -286,7 +289,7 @@ def fake_add_dock_widget(*args, **kwargs):
     # Ensure it wouldn't try to dock again
     monkeypatch.setattr(controls.viewer.window, "add_dock_widget", fake_add_dock_widget)
 
-    controls._ensure_mpl_canvas_docked()
+    controls._ensure_traj_canvas_docked()
     assert called["count"] == 0, "add_dock_widget should not be called when already docked"
     assert controls._mpl_docked is True  # stays docked
 
@@ -301,7 +304,7 @@ def test_ensure_mpl_canvas_docked_missing_window(keypoint_controls, qtbot):
     controls.viewer = types.SimpleNamespace()  # no 'window'
 
     controls._mpl_docked = False
-    controls._ensure_mpl_canvas_docked()
+    controls._ensure_traj_canvas_docked()
 
     # Nothing should change; crucially, no exceptions should be raised
     assert controls._mpl_docked is False
@@ -322,11 +325,11 @@ def test_trajectory_loader_ignores_invalid_properties(viewer, keypoint_controls,
 
     layer = viewer.add_points(np.array([[0.0, 10.0, 20.0]]), **md)
     assert layer is not None
-    assert keypoint_controls._matplotlib_canvas.df is None  # loader should have bailed out safely
+    assert keypoint_controls._traj_mpl_canvas.df is None  # loader should have bailed out safely
 
 
 @pytest.mark.usefixtures("qtbot")
-def test_ensure_mpl_canvas_docked_missing_qt_window(keypoint_controls, qtbot):
+def test_ensure_traj_canvas_docked_missing_qt_window(keypoint_controls, qtbot):
     """If window._qt_window is None, method should safely no-op."""
     controls = keypoint_controls
     qtbot.add_widget(controls)
@@ -341,7 +344,7 @@ def add_dock_widget(self, *args, **kwargs):
     controls.viewer = types.SimpleNamespace(window=DummyWindow())
 
     controls._mpl_docked = False
-    controls._ensure_mpl_canvas_docked()
+    controls._ensure_traj_canvas_docked()
 
     # Still undocked, no crash
     assert controls._mpl_docked is False
@@ -365,7 +368,7 @@ def add_dock_widget(self, *args, **kwargs):
     controls._mpl_docked = False
 
     # Should not raise
-    controls._ensure_mpl_canvas_docked()
+    controls._ensure_traj_canvas_docked()
 
     # Docking failed → remains undocked
     assert controls._mpl_docked is False

src/napari_deeplabcut/_tests/ui/test_traj_select.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from napari_deeplabcut.ui.plots.trajectory import TrajectoryMatplotlibCanvas
+
+
+@pytest.mark.e2e
+@pytest.mark.usefixtures("qtbot")
+def test_sync_visible_lines_to_points_selection_shows_all_when_no_points_selected(viewer, qtbot):
+    layer = viewer.add_points(
+        np.array([[0, 0], [1, 1]]),
+        properties={"label": np.array(["nose", "tail"], dtype=object)},
+    )
+
+    canvas = TrajectoryMatplotlibCanvas(viewer)
+    qtbot.addWidget(canvas)
+
+    # Avoid relying on df creation for this focused visibility test
+    canvas.df = object()
+    (line_nose,) = canvas.ax.plot([0, 1], [0, 1])
+    (line_tail,) = canvas.ax.plot([0, 1], [1, 0])
+    canvas._lines = {
+        "nose": [line_nose],
+        "tail": [line_tail],
+    }
+
+    layer.selected_data.clear()
+    canvas.sync_visible_lines_to_points_selection()
+
+    assert line_nose.get_visible() is True
+    assert line_tail.get_visible() is True
+
+
+@pytest.mark.e2e
+@pytest.mark.usefixtures("qtbot")
+def test_sync_visible_lines_to_points_selection_filters_by_selected_labels(viewer, qtbot):
+    layer = viewer.add_points(
+        np.array([[0, 0], [1, 1], [2, 2]]),
+        properties={"label": np.array(["nose", "tail", "nose"], dtype=object)},
+    )
+
+    canvas = TrajectoryMatplotlibCanvas(viewer)
+    qtbot.addWidget(canvas)
+
+    canvas.df = object()
+    (line_nose,) = canvas.ax.plot([0, 1], [0, 1])
+    (line_tail,) = canvas.ax.plot([0, 1], [1, 0])
+    canvas._lines = {
+        "nose": [line_nose],
+        "tail": [line_tail],
+    }
+
+    # Select a point whose label is "tail"
+    layer.selected_data.select_only(1)
+    canvas.sync_visible_lines_to_points_selection()
+
+    assert line_nose.get_visible() is False
+    assert line_tail.get_visible() is True
+
+
+@pytest.mark.e2e
+@pytest.mark.usefixtures("qtbot")
+def test_sync_visible_lines_to_points_selection_shows_label_if_any_selected_point_has_that_label(viewer, qtbot):
+    layer = viewer.add_points(
+        np.array([[0, 0], [1, 1], [2, 2]]),
+        properties={"label": np.array(["nose", "tail", "nose"], dtype=object)},
+    )
+
+    canvas = TrajectoryMatplotlibCanvas(viewer)
+    qtbot.addWidget(canvas)
+
+    canvas.df = object()
+    (line_nose,) = canvas.ax.plot([0, 1], [0, 1])
+    (line_tail,) = canvas.ax.plot([0, 1], [1, 0])
+    canvas._lines = {
+        "nose": [line_nose],
+        "tail": [line_tail],
+    }
+
+    # Select both nose points
+    layer.selected_data.update({0, 2})
+    canvas.sync_visible_lines_to_points_selection()
+
+    assert line_nose.get_visible() is True
+    assert line_tail.get_visible() is False