Avoid recursive calls when time changes and remove self.segment_index

Author: alejoe91

spikeinterface_gui/basescatterview.py

@@ -361,11 +361,11 @@ def _panel_make_layout(self):
 
         self.lasso_tool = LassoSelectTool()
 
-        self.segment_index = 0
+        segment_index = self.controller.get_time()[1]
         self.segment_selector = pn.widgets.Select(
             name="",
             options=[f"Segment {i}" for i in range(self.controller.num_segments)],
-            value=f"Segment {self.segment_index}",
+            value=f"Segment {segment_index}",
         )
         self.segment_selector.param.watch(self._panel_change_segment, 'value')
 
@@ -466,9 +466,10 @@ def _panel_refresh(self):
         colors = []
 
         segment_index = self.controller.get_time()[1]
-        if segment_index != self.segment_index:
-            self.segment_index = segment_index
-            self.segment_selector.value = f"Segment {self.segment_index}"
+        # get view segment index from segment selector
+        segment_index_from_selector = self.segment_selector.options.index(self.segment_selector.value)
+        if segment_index != segment_index_from_selector:
+            self.segment_selector.value = f"Segment {segment_index}"
 
         visible_unit_ids = self.controller.get_visible_unit_ids()
         for unit_id in visible_unit_ids:
@@ -531,8 +532,8 @@ def _panel_on_select_button(self, event):
 
     def _panel_change_segment(self, event):
         self._current_selected = 0
-        self.segment_index = int(self.segment_selector.value.split()[-1])
-        self.controller.set_time(segment_index=self.segment_index)
+        segment_index = int(self.segment_selector.value.split()[-1])
+        self.controller.set_time(segment_index=segment_index)
         t_start, t_end = self.controller.get_t_start_t_stop()
         self.scatter_fig.x_range.start = t_start
         self.scatter_fig.x_range.end = t_end
@@ -555,7 +556,7 @@ def _on_panel_selection_geometry(self, event):
                 return
 
             # Append the current polygon to the lasso vertices if shift is held
-            segment_index = self.segment_index
+            segment_index = self.controller.get_time()[1]
             if self._lasso_vertices[segment_index] is None:
                 self._lasso_vertices[segment_index] = []
             if len(selected) > self._current_selected:
@@ -582,7 +583,8 @@ def _panel_update_selected_spikes(self):
         selected_spike_indices = np.intersect1d(selected_spike_indices, self.plotted_inds)
         if len(selected_spike_indices) > 0:
             # map absolute indices to visible spikes
-            sl = self.controller.segment_slices[self.segment_index]
+            segment_index = self.controller.get_time()[1]
+            sl = self.controller.segment_slices[segment_index]
             spikes_in_seg = self.controller.spikes[sl]
             visible_mask = np.zeros(len(spikes_in_seg), dtype=bool)
             for unit_index, unit_id in self.controller.iter_visible_units():
@@ -604,7 +606,8 @@ def _panel_on_spike_selection_changed(self):
             return
         elif len(selected_indices) == 1:
             selected_segment = self.controller.spikes[selected_indices[0]]['segment_index']
-            if selected_segment != self.segment_index:
+            segment_index = self.controller.get_time()[1]
+            if selected_segment != segment_index:
                 self.segment_selector.value = f"Segment {selected_segment}"
                 self._panel_change_segment(None)
         # update selected spikes

spikeinterface_gui/controller.py

@@ -60,11 +60,8 @@ def __init__(self, analyzer=None, backend="qt", parent=None, verbose=False, save
         self.verbose = verbose
         t0 = time.perf_counter()
 
-
         self.main_settings = _default_main_settings.copy()
 
-
-
         self.num_channels = self.analyzer.get_num_channels()
         # this now private and shoudl be acess using function
         self._visible_unit_ids = [self.unit_ids[0]]
@@ -421,19 +418,21 @@ def set_time(self, time=None, segment_index=None):
     def update_time_info(self):
         # set default time info
         if self.main_settings["use_times"] and self.analyzer.has_recording():
-            self.time_info = dict(
-                time_by_seg=np.array(
-                    [
-                        self.analyzer.recording.get_start_time(segment_index) for segment_index in range(self.num_segments)
-                    ],
-                    dtype="float64"),
-                segment_index=0
+            time_by_seg=np.array(
+                [
+                    self.analyzer.recording.get_start_time(segment_index) for segment_index in range(self.num_segments)
+                ],
+                dtype="float64"
             )
         else:
+            time_by_seg=np.array([0] * self.num_segments, dtype="float64")
+        if not hasattr(self, 'time_info'):
             self.time_info = dict(
-                time_by_seg=np.array([0] * self.num_segments, dtype="float64"),
+                time_by_seg=time_by_seg,
                 segment_index=0
             )
+        else:
+            self.time_info['time_by_seg'] = time_by_seg
 
     def get_t_start_t_stop(self):
         segment_index = self.time_info["segment_index"]

spikeinterface_gui/spikerateview.py

@@ -100,11 +100,11 @@ def _panel_make_layout(self):
         import bokeh.plotting as bpl
         from .utils_panel import _bg_color
 
-        self.segment_index = 0
+        segment_index = self.controller.get_time()[1]
         self.segment_selector = pn.widgets.Select(
             name="",
             options=[f"Segment {i}" for i in range(self.controller.num_segments)],
-            value=f"Segment {self.segment_index}",
+            value=f"Segment {segment_index}",
         )
         self.segment_selector.param.watch(self._panel_change_segment, 'value')
 
@@ -130,9 +130,9 @@ def _panel_refresh(self):
         from bokeh.models import Range1d
 
         segment_index = self.controller.get_time()[1]
-        if segment_index != self.segment_index:
-            self.segment_index = segment_index
-            self.segment_selector.value = f"Segment {self.segment_index}"
+        segment_index_from_selector = self.segment_selector.options.index(self.segment_selector.value)
+        if segment_index != segment_index_from_selector:
+            self.segment_selector.value = f"Segment {segment_index}"
 
         visible_unit_ids = self.controller.get_visible_unit_ids()
 
@@ -169,8 +169,8 @@ def _panel_refresh(self):
         self.rate_fig.y_range = Range1d(start=0, end=max_count*1.2)
 
     def _panel_change_segment(self, event):
-        self.segment_index = int(self.segment_selector.value.split()[-1])
-        self.controller.set_time(segment_index=self.segment_index)
+        segment_index = int(self.segment_selector.value.split()[-1])
+        self.controller.set_time(segment_index=segment_index)
         self.refresh()
         self.notify_time_info_updated()
 

spikeinterface_gui/tracemapview.py

@@ -168,27 +168,27 @@ def _qt_on_time_info_updated(self):
         time, segment_index = self.controller.get_time()
         # Block auto refresh to avoid recursive calls
         self._block_auto_refresh_and_notify = True
-
         self._qt_change_segment(segment_index)
         self.timeseeker.seek(time)
-        
-        self._block_auto_refresh_and_notify = False
-        # we need refresh in QT because changing tab/docking/undocking doesn't trigger a refresh
         self.refresh()
+        self._block_auto_refresh_and_notify = False
 
     def _qt_on_use_times_updated(self):
-        # Update time seeker
+        # Block auto refresh to avoid recursive calls
+        self._block_auto_refresh_and_notify = True
         t_start, t_stop = self.controller.get_t_start_t_stop()
         self.timeseeker.set_start_stop(t_start, t_stop)
         self.timeseeker.seek(self.controller.get_time()[0])
+        self.refresh()
+        self._block_auto_refresh_and_notify = False
 
     ## Panel ##
     def _panel_make_layout(self):
         import panel as pn
         import bokeh.plotting as bpl
         from .utils_panel import _bg_color
         from bokeh.models import ColumnDataSource, LinearColorMapper, Range1d
-        from bokeh.events import MouseWheel, Tap
+        from bokeh.events import MouseWheel, DoubleTap
 
 
         # Create figure
@@ -203,7 +203,7 @@ def _panel_make_layout(self):
         self.figure.toolbar.logo = None
 
         self.figure.on_event(MouseWheel, self._panel_gain_zoom)
-        self.figure.on_event(Tap, self._panel_on_tap)
+        self.figure.on_event(DoubleTap, self._panel_on_double_tap)
 
         # Add selection line
         self.selection_line = self.figure.line(
@@ -302,16 +302,6 @@ def _panel_refresh(self):
         self.figure.x_range.end = t2
         self.figure.y_range.end = data_curves.shape[1]
 
-    # TODO: if from a different unit, change unit visibility
-    def _panel_on_tap(self, event):
-        seg_index = self.controller.get_time()[1]
-        time = event.x
-        ind_spike_nearest = find_nearest_spike(self.controller, time, seg_index)
-        if ind_spike_nearest is not None:
-            self.controller.set_indices_spike_selected([ind_spike_nearest])
-            self._panel_seek_with_selected_spike()
-            self.notify_spike_selection_changed()
-
     def _panel_on_settings_changed(self):
         self.make_color_lut()
         self.refresh()
@@ -365,4 +355,5 @@ def _panel_on_use_times_updated(self):
 * **auto scale**: Automatically adjust the scale of the traces.
 * **time (s)**: Set the time point to display traces.
 * **mouse wheel**: change the scale of the traces.
+* **double click**: select the nearest spike and center the view on it.
 """

spikeinterface_gui/traceview.py

@@ -210,7 +210,7 @@ def _qt_xsize_zoom(self, xmove):
         factor = xmove/100.
         newsize = self.xsize*(factor+1.)
         limits = self.spinbox_xsize.opts['bounds']
-        if newsize>0. and newsize<limits[1]:
+        if newsize > 0. and newsize < limits[1]:
             self.spinbox_xsize.setValue(newsize)
 
     def _qt_on_scroll_time(self, val):
@@ -348,6 +348,14 @@ def _panel_seek_with_selected_spike(self):
             self.refresh()
             self.notify_time_info_updated()
 
+    def _panel_on_double_tap(self, event):
+        time = event.x
+        ind_spike_nearest = find_nearest_spike(self.controller, time, self.controller.get_time()[1])
+        if ind_spike_nearest is not None:
+            self.controller.set_indices_spike_selected([ind_spike_nearest])
+            self._panel_seek_with_selected_spike()
+            self.notify_spike_selection_changed()
+
     # TODO: pan behavior like Qt?
     # def _panel_on_pan_start(self, event):
     #     self.drag_state["x_start"] = event.x
@@ -535,24 +543,25 @@ def _qt_on_time_info_updated(self):
 
         self._qt_change_segment(segment_index)
         self.timeseeker.seek(time)
-        
-        self._block_auto_refresh_and_notify = False
-        # we need refresh in QT because changing tab/docking/undocking doesn't trigger a refresh
         self.refresh()
+        self._block_auto_refresh_and_notify = False
 
     def _qt_on_use_times_updated(self):
         # Update time seeker
+        self._block_auto_refresh_and_notify = True
         t_start, t_stop = self.controller.get_t_start_t_stop()
         self.timeseeker.set_start_stop(t_start, t_stop)
         self.timeseeker.seek(self.controller.get_time()[0])
+        self.refresh()
+        self._block_auto_refresh_and_notify = False
 
     ## panel ##
     def _panel_make_layout(self):
         import panel as pn
         import bokeh.plotting as bpl
         from .utils_panel import _bg_color
         from bokeh.models import ColumnDataSource, Range1d
-        from bokeh.events import Tap, MouseWheel
+        from bokeh.events import DoubleTap, MouseWheel
 
         self.figure = bpl.figure(
             sizing_mode="stretch_both",
@@ -592,7 +601,7 @@ def _panel_make_layout(self):
             x="x", y="y", size=10, fill_color="color", fill_alpha=self.settings['alpha'], source=self.spike_source
         )
 
-        self.figure.on_event(Tap, self._panel_on_tap)
+        self.figure.on_event(DoubleTap, self._panel_on_double_tap)
 
         self._panel_create_toolbar()
 
@@ -652,13 +661,6 @@ def _panel_refresh(self):
             self.figure.y_range.end = n - 0.5
 
     # TODO: if from a different unit, change unit visibility
-    def _panel_on_tap(self, event):
-        time = event.x
-        ind_spike_nearest = find_nearest_spike(self.controller, time, self.controller.get_time()[1])
-        if ind_spike_nearest is not None:
-            self.controller.set_indices_spike_selected([ind_spike_nearest])
-            self._panel_seek_with_selected_spike()
-            self.notify_spike_selection_changed()
 
     def _panel_on_spike_selection_changed(self):
         self._panel_seek_with_selected_spike()
@@ -676,22 +678,22 @@ def _panel_auto_scale(self, event):
     def _panel_on_time_info_updated(self):
         # Update segment and time slider range
         time, segment_index = self.controller.get_time()
-        self._block_auto_refresh = True
+        self._block_auto_refresh_and_notify = True
         self._panel_change_segment(segment_index)
         # Update time slider value
         self.time_slider.value = time
-        self._block_auto_refresh = False
-        # we don't need a refresh in panel because changing tab triggers a refresh
+        self.refresh()
+        self._block_auto_refresh_and_notify = False
 
     def _panel_on_use_times_updated(self):
         # Update time seeker
         t_start, t_stop = self.controller.get_t_start_t_stop()
+        self._block_auto_refresh_and_notify = True
         self.time_slider.start = t_start
         self.time_slider.end = t_stop
-
-        # Optionally clamp the current value if out of range
         self.time_slider.value = self.controller.get_time()[0]
         self.refresh()
+        self._block_auto_refresh_and_notify = False
 
 
 
@@ -725,4 +727,5 @@ def find_nearest_spike(controller, x, segment_index, max_distance_samples=None):
 * **auto scale**: Automatically adjust the scale of the traces.
 * **time (s)**: Set the time point to display traces.
 * **mouse wheel**: change the scale of the traces.
+* **double click**: select the nearest spike and center the view on it.
 """