Defer updates for hidden expensive views

Author: rossant

docs/changelog.md

@@ -29,6 +29,9 @@ behavior they verify rather than listed separately.
   with `n_spikes_amplitudes_background` (10,000 by default).
 - Waveform, Amplitude, and Correlogram views use fixed total spike budgets
   across multi-cluster selections, while retaining their per-cluster ceilings.
+- Hidden or inactive-tab Waveform, Amplitude, and Correlogram views defer
+  selection plotting until they become visible, retaining only the latest
+  selection.
 
 ### Changed
 

docs/performance.md

@@ -28,6 +28,11 @@ Other common cluster display limits are eight clusters for the Waveform,
 Feature, Amplitude, and scatter views, and 20 for histogram and Probe views.
 These limits control what a view plots; they do not change the table selection.
 
+Waveform, Amplitude, and Correlogram views also defer selection plotting while
+their dock is hidden or in an inactive tab. Their public cluster selection is
+updated immediately, but the canvas is redrawn only when it becomes visible.
+Only the latest pending selection is retained.
+
 ## How spikes are chosen
 
 The standard selector samples up to the configured number independently from

phy/cluster/views/amplitude.py

@@ -44,6 +44,7 @@ class AmplitudeView(MarkerSizeMixin, LassoMixin, ManualClusteringView):
 
     # Do not show too many clusters.
     max_n_clusters = 8
+    defer_hidden_updates = True
 
     _default_position = 'right'
 

phy/cluster/views/base.py

@@ -65,10 +65,13 @@ class ManualClusteringView:
     plot_canvas_class = PlotCanvas
     ex_status = ''  # the GUI can update this to
     max_n_clusters = 0  # By default, show all clusters.
+    defer_hidden_updates = False
 
     def __init__(self, shortcuts=None, **kwargs):
         self._lock = None
         self._closed = False
+        self._dock_visible = True
+        self._pending_selection = None
         self.cluster_ids = ()
 
         # Load default shortcuts, and override with any user shortcuts.
@@ -156,6 +159,14 @@ def on_select_threaded(self, sender, cluster_ids, gui=None, **kwargs):
         # than leaving its previous contents on screen.
         if self.max_n_clusters and len(cluster_ids) > self.max_n_clusters:
             cluster_ids = cluster_ids[:self.max_n_clusters]
+        if self.defer_hidden_updates and not self._dock_visible:
+            # Keep the public selection state current while retaining only the
+            # latest small payload needed to redraw the view when it is shown.
+            cluster_ids = list(cluster_ids)
+            self.cluster_ids = cluster_ids
+            self._pending_selection = (cluster_ids, dict(kwargs))
+            return
+        self._pending_selection = None
 
         # The lock is used so that two different background threads do not access the same
         # view simultaneously, which can lead to conflicts, errors in the plotting code,
@@ -206,6 +217,7 @@ def finished():
             emit('is_busy', self, False)
             self._lock = None
             self.update_status()
+            self._flush_pending_selection()
 
         # Start the task on the thread pool, and let the OpenGL canvas know that we're
         # starting to record all OpenGL calls instead of executing them immediately.
@@ -223,6 +235,24 @@ def finished():
             worker.run()
             self._lock = None
 
+    def _flush_pending_selection(self):
+        """Render the latest selection deferred while this view was hidden."""
+        if (
+            not self._pending_selection
+            or not self._dock_visible
+            or self._lock
+            or self._closed
+        ):
+            return
+        cluster_ids, kwargs = self._pending_selection
+        self._pending_selection = None
+        self.on_select_threaded(
+            self,
+            cluster_ids=cluster_ids,
+            gui=self.gui,
+            **kwargs,
+        )
+
     def on_cluster(self, up):
         """Callback function when a clustering action occurs. May be overridden.
 
@@ -251,6 +281,14 @@ def attach(self, gui):
 
         gui.add_view(self, position=self._default_position)
         self.gui = gui
+        self._dock_visible = self.dock.isVisible()
+
+        def on_visibility_changed(visible):
+            self._dock_visible = visible
+            if visible:
+                self._flush_pending_selection()
+
+        self.dock.visibilityChanged.connect(on_visibility_changed)
 
         # Set the view state.
         self.set_state(gui.state.get_view_state(self))
@@ -281,6 +319,8 @@ def on_close_view(view_, gui):
                 return
             logger.debug('Close view %s.', self.name)
             self._closed = True
+            self._pending_selection = None
+            self.dock.visibilityChanged.disconnect(on_visibility_changed)
             gui.remove_menu(self.name)
             unconnect(on_select)
             gui.state.update_view_state(self, self.state)

phy/cluster/views/correlogram.py

@@ -42,6 +42,7 @@ class CorrelogramView(ScalingMixin, ManualClusteringView):
 
     # Do not show too many clusters.
     max_n_clusters = 20
+    defer_hidden_updates = True
 
     _default_position = 'left'
     cluster_ids = ()

phy/cluster/views/tests/test_base.py

@@ -29,6 +29,18 @@ def status(self):
         return 'hello'
 
 
+class DeferredView(ManualClusteringView):
+    defer_hidden_updates = True
+    max_n_clusters = 2
+
+    def __init__(self):
+        super().__init__()
+        self.updates = []
+
+    def plot(self, **kwargs):
+        self.updates.append((list(self.cluster_ids), kwargs))
+
+
 def test_manual_clustering_view_1(qtbot, tempdir):
     v = MyView()
     v.canvas.show()
@@ -88,3 +100,56 @@ class Supervisor:
     assert v.cluster_ids == [3, 2]
 
     _stop_and_close(qtbot, v)
+
+
+def test_manual_clustering_view_defers_latest_selection_while_hidden(qtbot, gui):
+    v = DeferredView()
+    v.attach(gui)
+
+    class Supervisor:
+        pass
+
+    emit('select', Supervisor(), cluster_ids=[1], marker='visible')
+    assert v.updates == [([1], {'marker': 'visible'})]
+
+    v.dock.hide()
+    qtbot.waitUntil(lambda: not v._dock_visible)
+    emit('select', Supervisor(), cluster_ids=[2], marker='superseded')
+    emit('select', Supervisor(), cluster_ids=[3, 4, 5], marker='latest')
+
+    # Public state follows the limited selection, but no hidden plot occurs and
+    # only the latest payload remains retained.
+    assert v.cluster_ids == [3, 4]
+    assert v.updates == [([1], {'marker': 'visible'})]
+    assert v._pending_selection == ([3, 4], {'marker': 'latest'})
+
+    v.dock.show()
+    qtbot.waitUntil(lambda: len(v.updates) == 2)
+    assert v.updates[-1] == ([3, 4], {'marker': 'latest'})
+    assert v._pending_selection is None
+
+    _stop_and_close(qtbot, v)
+
+
+def test_manual_clustering_view_defers_inactive_tab(qtbot, gui):
+    hidden = DeferredView()
+    visible = DeferredView()
+    hidden.attach(gui)
+    visible.attach(gui)
+    gui.tabifyDockWidget(hidden.dock, visible.dock)
+    visible.dock.raise_()
+    qtbot.waitUntil(lambda: not hidden._dock_visible and visible._dock_visible)
+
+    class Supervisor:
+        pass
+
+    emit('select', Supervisor(), cluster_ids=[7])
+    assert hidden.updates == []
+    assert visible.updates == [([7], {})]
+
+    hidden.dock.raise_()
+    qtbot.waitUntil(lambda: len(hidden.updates) == 1)
+    assert hidden.updates == [([7], {})]
+
+    _stop_and_close(qtbot, hidden)
+    _stop_and_close(qtbot, visible)

phy/cluster/views/waveform.py

@@ -96,6 +96,7 @@ class WaveformView(ScalingMixin, ManualClusteringView):
 
     # Do not show too many clusters.
     max_n_clusters = 8
+    defer_hidden_updates = True
 
     _default_position = 'right'
     ax_color = (0.75, 0.75, 0.75, 1.0)