Fix spikerate and scatter item clicked

Author: alejoe91

spikeinterface_gui/basescatterview.py

@@ -461,6 +461,9 @@ 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}"
 
         visible_unit_ids = self.controller.get_visible_unit_ids()
         for unit_id in visible_unit_ids:
@@ -487,6 +490,9 @@ def _panel_refresh(self):
                 line_width=2,
             )
             self.hist_lines.append(hist_lines)
+        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
 
         self._max_count = max_count
 
@@ -522,7 +528,7 @@ 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)
-        t_start, t_end = self.controller.get_t_start_t_end()
+        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
         self.refresh()

spikeinterface_gui/controller.py

@@ -614,7 +614,7 @@ def set_indices_spike_selected(self, inds):
             # set time info 
             segment_index = self.spikes['segment_index'][self._spike_selected_indices[0]]
             sample_index = self.spikes['sample_index'][self._spike_selected_indices[0]]
-            self.set_time(time=sample_index / self.sampling_frequency, segment_index=segment_index)
+            self.set_time(time=self.sample_index_to_time(sample_index), segment_index=segment_index)
 
     def get_spike_indices(self, unit_id, segment_index=None):
         if segment_index is None:

spikeinterface_gui/mainsettingsview.py

@@ -41,7 +41,6 @@ def on_change_color_mode(self):
 
     def on_use_times(self):
         self.controller.main_settings['use_times'] = self.main_settings['use_times']
-        print("Use times changed:", self.main_settings['use_times'])
         self.controller.update_time_info()
         self.notify_use_times_updated()
         # for view in self.controller.views:

spikeinterface_gui/spikerateview.py

@@ -19,7 +19,6 @@ def on_time_info_updated(self):
         self.refresh()
 
     def on_use_times_updated(self):
-        print(f"Refreshing SpikeRateView")
         self.refresh()
 
     ## Qt ##
@@ -105,25 +104,26 @@ def _panel_make_layout(self):
         self.segment_selector.param.watch(self._panel_change_segment, 'value')
 
         self.rate_fig = bpl.figure(
-            width=250,
-            height=250,
             tools="pan,wheel_zoom,reset",
             active_drag="pan",
             active_scroll="wheel_zoom",
             background_fill_color=_bg_color,
             border_fill_color=_bg_color,
             outline_line_color="white",
+            sizing_mode="stretch_both",
         )
         self.rate_fig.toolbar.logo = None
         self.rate_fig.grid.visible = False
 
         self.layout = pn.Column(
             pn.Row(self.segment_selector, sizing_mode="stretch_width"),
-            pn.Row(self.rate_fig,sizing_mode="stretch_both"),
+            pn.Row(self.rate_fig, sizing_mode="stretch_both"),
         )
         self.is_warning_active = False
 
     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
@@ -136,11 +136,12 @@ def _panel_refresh(self):
         total_frames = self.controller.final_spike_samples
         bins_s = self.settings['bin_s']
         num_bins = total_frames[segment_index] // int(sampling_frequency) // bins_s
-        t_start, _  = self.controller.get_t_start_t_stop()
+        t_start, t_stop  = self.controller.get_t_start_t_stop()
 
         # clear fig
         self.rate_fig.renderers = []
 
+        max_count = 0
         for unit_id in visible_unit_ids:
 
             spike_inds = self.controller.get_spike_indices(unit_id, segment_index=segment_index)
@@ -152,13 +153,15 @@ def _panel_refresh(self):
             color = self.get_unit_color(unit_id)
 
             line = self.rate_fig.line(
-                x=(bins[1:]+bins[:-1])/(2*sampling_frequency) + t_start,
-                y=count/bins_s,
+                x=(bins[1:]+bins[:-1]) / (2*sampling_frequency) + t_start,
+                y=count / bins_s,
                 color=color,
                 line_width=2,
             )
+            max_count = max(max_count, np.max(count/bins_s))
 
-        self.rate_fig.y_range.start = 0
+        self.rate_fig.x_range = Range1d(start=t_start, end=t_stop)
+        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])

spikeinterface_gui/tracemapview.py

@@ -115,11 +115,6 @@ def _qt_on_settings_changed(self, do_refresh=True):
     def _qt_on_spike_selection_changed(self):
         self._qt_seek_with_selected_spike()
 
-
-    def _qt_scatter_item_clicked(self, x, y):
-        # useless but needed for the MixinViewTrace
-        pass
-
     def _qt_refresh(self):
         t, _ = self.controller.get_time()
         self._qt_seek(t)
@@ -181,6 +176,12 @@ def _qt_on_time_info_updated(self):
         # we need refresh in QT because changing tab/docking/undocking doesn't trigger a refresh
         self.refresh()
 
+    def _qt_on_use_times_updated(self):
+        # Update time seeker
+        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])
+
     ## Panel ##
     def _panel_make_layout(self):
         import panel as pn
@@ -272,7 +273,7 @@ def _panel_refresh(self):
             auto_scale = False
 
         times_chunk, data_curves, scatter_x, scatter_y, scatter_colors = \
-            self.get_data_in_chunk(t1, t2, seg_index)
+            self.get_data_in_chunk(t1, t2, segment_index)
         data_curves = data_curves.T
 
         if self.color_limit is None:
@@ -304,7 +305,8 @@ def _panel_refresh(self):
     # TODO: if from a different unit, change unit visibility
     def _panel_on_tap(self, event):
         seg_index = self.controller.get_time()[1]
-        ind_spike_nearest = find_nearest_spike(self.controller, event.x, seg_index)
+        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()
@@ -341,6 +343,17 @@ def _panel_on_time_info_updated(self):
         self._block_auto_refresh_and_notify = False
         # we don't need a refresh in panel because changing tab triggers a refresh
 
+    def _panel_on_use_times_updated(self):
+        # Update time seeker
+        t_start, t_stop = self.controller.get_t_start_t_stop()
+        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()
+
 
 TraceMapView._gui_help_txt = """
 ## Trace Map View

spikeinterface_gui/traceview.py

@@ -145,7 +145,6 @@ def _qt_initialize_plot(self):
         self.graphicsview.setCentralItem(self.plot)
         self.plot.hideButtons()
         self.plot.showAxis('left', False)
-        
         self.viewBox.doubleclicked.connect(self._qt_scatter_item_clicked)
 
         self.viewBox.gain_zoom.connect(self.apply_gain_zoom)
@@ -240,11 +239,14 @@ def _qt_seek_with_selected_spike(self):
             self.notify_time_info_updated()
         self.refresh()
 
-    def _qt_on_use_times_updated(self):
-        # Update time seeker
-        t_start, t_stop = self.controller.get_t_start_t_stop()
-        self.timeseeker.set_start_stop(t_start, t_stop)
-    
+    def _qt_scatter_item_clicked(self, x, y):
+        ind_spike_nearest = find_nearest_spike(self.controller, x, segment_index=self.controller.get_time()[1])
+        if ind_spike_nearest is not None:
+            self.controller.set_indices_spike_selected([ind_spike_nearest])
+
+            self.notify_spike_selection_changed()
+            self._qt_seek_with_selected_spike()
+
     ## panel ##
     def _panel_create_toolbar(self):
         import panel as pn
@@ -346,16 +348,6 @@ def _panel_seek_with_selected_spike(self):
             self.refresh()
             self.notify_time_info_updated()
 
-    def _panel_on_use_times_updated(self):
-        # Update time seeker
-        t_start, t_stop = self.controller.get_t_start_t_stop()
-        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 = max(t_start, min(self.time_slider.value, t_stop))
-        self.refresh()
-
     # TODO: pan behavior like Qt?
     # def _panel_on_pan_start(self, event):
     #     self.drag_state["x_start"] = event.x
@@ -476,25 +468,6 @@ def _qt_on_settings_changed(self):
     def _qt_on_spike_selection_changed(self):
         MixinViewTrace._qt_seek_with_selected_spike(self)
 
-    def _qt_scatter_item_clicked(self, x, y):
-        # TODO sam : make it faster without boolean mask
-        ind_click = int(x*self.controller.sampling_frequency )
-        in_seg, = np.nonzero(self.controller.spikes['segment_index'] == self.controller.get_time()[1])
-        nearest = np.argmin(np.abs(self.controller.spikes[in_seg]['sample_index'] - ind_click))
-        
-        ind_spike_nearest = in_seg[nearest]
-        sample_index = self.controller.spikes[ind_spike_nearest]['sample_index']
-        
-        if np.abs(ind_click - sample_index) > (self.controller.sampling_frequency // 30):
-            return
-        
-        #~ self.controller.spikes['selected'][:] = False
-        #~ self.controller.spikes['selected'][ind_spike_nearest] = True
-        self.controller.set_indices_spike_selected([ind_spike_nearest])
-        
-        self.notify_spike_selection_changed()
-        self.refresh()
-
     def _qt_refresh(self):
         t, _ = self.controller.get_time()
         self._qt_seek(t)
@@ -567,10 +540,11 @@ def _qt_on_time_info_updated(self):
         # we need refresh in QT because changing tab/docking/undocking doesn't trigger a refresh
         self.refresh()
 
-    # def _qt_on_use_times_updated(self):
-    #     # Update time seeker
-    #     t_start, t_stop = self.controller.get_t_start_t_stop()
-    #     self.timeseeker.set_start_stop(t_start, t_stop)
+    def _qt_on_use_times_updated(self):
+        # Update time seeker
+        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])
 
     ## panel ##
     def _panel_make_layout(self):
@@ -679,7 +653,8 @@ def _panel_refresh(self):
 
     # TODO: if from a different unit, change unit visibility
     def _panel_on_tap(self, event):
-        ind_spike_nearest = find_nearest_spike(self.controller, event.x, self.controller.get_time()[1])
+        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()
@@ -693,8 +668,7 @@ def _panel_gain_zoom(self, event):
             factor_ratio = 1.3 if event.delta > 0 else 1 / 1.3
         else:
             factor_ratio = 1.0
-        factor = 1.3 if event.delta > 0 else 1 / 1.3
-        self.apply_gain_zoom(factor)
+        self.apply_gain_zoom(factor_ratio)
 
     def _panel_auto_scale(self, event):
         self.auto_scale()
@@ -709,14 +683,23 @@ def _panel_on_time_info_updated(self):
         self._block_auto_refresh = False
         # we don't need a refresh in panel because changing tab triggers a refresh
 
+    def _panel_on_use_times_updated(self):
+        # Update time seeker
+        t_start, t_stop = self.controller.get_t_start_t_stop()
+        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()
+
 
 
-# TODO sam refactor Qt and this
 def find_nearest_spike(controller, x, segment_index, max_distance_samples=None):
     if max_distance_samples is None:
         max_distance_samples = controller.sampling_frequency // 30
 
-    ind_click = int(x * controller.sampling_frequency)
+    ind_click = controller.time_to_sample_index(x)
     (in_seg,) = np.nonzero(controller.spikes["segment_index"] == segment_index)
 
     if len(in_seg) == 0: