Merge pull request #188 from alejoe91/busy-indicator

Add context manager for busy indicator

Author: samuelgarcia

spikeinterface_gui/controller.py

@@ -570,14 +570,33 @@ def get_traces(self, trace_source='preprocessed', **kargs):
         cache_key = (kargs.get("segment_index", None), kargs.get("start_frame", None), kargs.get("end_frame", None))
         if cache_key in self._traces_cached:
             return self._traces_cached[cache_key]
+        else:
+            # check if start_frame and end_frame are a subset interval of a cached one
+            for cached_key in self._traces_cached.keys():
+                cached_seg = cached_key[0]
+                cached_start = cached_key[1]
+                cached_end = cached_key[2]
+                req_seg = kargs.get("segment_index", None)
+                req_start = kargs.get("start_frame", None)
+                req_end = kargs.get("end_frame", None)
+                if cached_seg is not None and req_seg is not None:
+                    if cached_seg != req_seg:
+                        continue
+                if cached_start is not None and cached_end is not None and req_start is not None and req_end is not None:
+                    if req_start >= cached_start and req_end <= cached_end:
+                        # subset found
+                        traces = self._traces_cached[cached_key]
+                        start_offset = req_start - cached_start
+                        end_offset = req_end - cached_start
+                        return traces[start_offset:end_offset, :]
 
         if len(self._traces_cached) > 4:
             self._traces_cached.pop(list(self._traces_cached.keys())[0])
 
         if trace_source == 'preprocessed':
             rec = self.analyzer.recording
         elif trace_source == 'raw':
-            raise NotImplemented
+            raise NotImplementedError("Raw traces not implemented yet")
             # TODO get with parent recording the non process recording
         kargs['return_in_uV'] = self.return_in_uV
         traces = rec.get_traces(**kargs)

spikeinterface_gui/mergeview.py

@@ -198,7 +198,7 @@ def _qt_make_layout(self):
         row_layout = QT.QHBoxLayout()
 
         but = QT.QPushButton('Calculate merges')
-        but.clicked.connect(self._qt_calculate_potential_automerge)
+        but.clicked.connect(self._compute_merges)
         row_layout.addWidget(but)
 
         if self.controller.curation:
@@ -269,8 +269,11 @@ def _qt_refresh(self):
             self.table.resizeColumnToContents(i)
         self.table.setSortingEnabled(True)
 
-    def _qt_calculate_potential_automerge(self):
-        self.get_potential_merges()
+    def _compute_merges(self):
+        with self.busy_cursor():
+            self.get_potential_merges()
+        if len(self.proposed_merge_unit_groups) == 0:
+            self.warning(f"No potential merges found with method {self.method}")
         self.refresh()
 
     def _qt_on_spike_selection_changed(self):
@@ -318,7 +321,7 @@ def _panel_make_layout(self):
         self.table_area = pn.pane.Placeholder("No merges computed yet.", height=400)
 
         self.caluculate_merges_button = pn.widgets.Button(name="Calculate merges", button_type="primary", sizing_mode="stretch_width")
-        self.caluculate_merges_button.on_click(self._panel_calculate_merges)
+        self.caluculate_merges_button.on_click(self._panel_compute_merges)
 
         calculate_list = [self.caluculate_merges_button]
 
@@ -378,11 +381,8 @@ def _panel_refresh(self):
         self.table.on_click(self._panel_on_click)
         self.table_area.update(self.table)
 
-    def _panel_calculate_merges(self, event):
-        import panel as pn
-        self.table_area.update(pn.indicators.LoadingSpinner(size=50, value=True))
-        self.get_potential_merges()
-        self.refresh()
+    def _panel_compute_merges(self, event):
+        self._compute_merges()
 
     def _panel_on_method_change(self, event):
         self.method = event.new

spikeinterface_gui/tracemapview.py

@@ -1,6 +1,5 @@
 import numpy as np
-
-import matplotlib.cm
+from contextlib import nullcontext
 import matplotlib.colors
 
 from .view_base import ViewBase
@@ -29,16 +28,17 @@ def __init__(self, controller=None, parent=None, backend="qt"):
         self.channel_order_reverse = np.argsort(self.channel_order, kind="stable")
         self.color_limit = None
         self.last_data_curves = None
+        self.factor = None
 
         self.xsize = 0.5
         self._block_auto_refresh_and_notify = False
+        self.trace_context = nullcontext
 
         ViewBase.__init__(self, controller=controller, parent=parent, backend=backend)
         MixinViewTrace.__init__(self)
 
         self.make_color_lut()
 
-        
     def apply_gain_zoom(self, factor_ratio):
         if self.color_limit is None:
             return
@@ -62,61 +62,8 @@ def make_color_lut(self):
         if self.settings['reverse_colormap']:
             self.lut = self.lut[::-1]
 
-
-    def get_data_in_chunk(self, t1, t2, segment_index):
-        t_start = 0.0
-        sr = self.controller.sampling_frequency
-
-        ind1 = max(0, int((t1 - t_start) * sr))
-        ind2 = min(self.controller.get_num_samples(segment_index), int((t2 - t_start) * sr))
-
-        traces_chunk = self.controller.get_traces(segment_index=segment_index, start_frame=ind1, end_frame=ind2)
-
-        sl = self.controller.segment_slices[segment_index]
-        spikes_seg = self.controller.spikes[sl]
-        i1, i2 = np.searchsorted(spikes_seg["sample_index"], [ind1, ind2])
-        spikes_chunk = spikes_seg[i1:i2].copy()
-        spikes_chunk["sample_index"] -= ind1
-
-        data_curves = traces_chunk[:, self.channel_order]
-
-        if data_curves.dtype != "float32":
-            data_curves = data_curves.astype("float32")
-
-        times_chunk = np.arange(traces_chunk.shape[0], dtype='float64')/self.controller.sampling_frequency+max(t1, 0)
-
-        scatter_x = []
-        scatter_y = []
-        scatter_colors = []
-        scatter_unit_ids = []
-
-        for unit_index, unit_id in self.controller.iter_visible_units():
-
-            inds = np.flatnonzero(spikes_chunk["unit_index"] == unit_index)
-            if inds.size == 0:
-                continue
-
-            # Get spikes for this unit
-            unit_spikes = spikes_chunk[inds]
-            channel_inds = unit_spikes["channel_index"]
-            sample_inds = unit_spikes["sample_index"]
-
-            x = times_chunk[sample_inds]
-            y = self.channel_order_reverse[channel_inds] + 0.5
-
-            # This should both for qt (QTColor) and panel (html color)
-            color = self.get_unit_color(unit_id)
-
-            scatter_x.extend(x)
-            scatter_y.extend(y)
-            scatter_colors.extend([color] * len(x))
-            scatter_unit_ids.extend([str(unit_id)] * len(x))
-
-        # used for auto scaled
-        self.last_data_curves = data_curves
-
-        return times_chunk, data_curves, scatter_x, scatter_y, scatter_colors, scatter_unit_ids
-
+    def get_visible_channel_inds(self):
+        return self.channel_order
 
     ## Qt ##
     def _qt_make_layout(self, **kargs):
@@ -149,7 +96,6 @@ def _qt_make_layout(self, **kargs):
         # self.on_params_changed(do_refresh=False)
         #this do refresh
         self._qt_change_segment(0)
-        
 
     def _qt_on_settings_changed(self, do_refresh=True):
 
@@ -197,9 +143,10 @@ def _qt_seek(self, t):
         self.scroll_time.valueChanged.connect(self._qt_on_scroll_time)
 
         seg_index = self.controller.get_time()[1]
-        times_chunk, data_curves, scatter_x, scatter_y, scatter_colors, scatter_unit_ids = \
+        times_chunk, data_curves, scatter_x, scatter_y, scatter_colors = \
             self.get_data_in_chunk(t1, t2, seg_index)
-        
+        data_curves = data_curves.T
+
         if self.color_limit is None:
             self.color_limit = np.max(np.abs(data_curves))
 
@@ -212,8 +159,8 @@ def _qt_seek(self, t):
         # self.scatter.clear()
         self.scatter.setData(x=scatter_x, y=scatter_y, brush=scatter_colors)
 
-        self.plot.setXRange( t1, t2, padding = 0.0)
-        self.plot.setYRange(0, num_chans, padding = 0.0)
+        self.plot.setXRange(t1, t2, padding=0.0)
+        self.plot.setYRange(0, num_chans, padding=0.0)
 
     def _qt_on_time_info_updated(self):
         # Update segment and time slider range
@@ -275,7 +222,7 @@ def _panel_make_layout(self):
         # Add data sources
         self.image_source = ColumnDataSource({"image": [], "x": [], "y": [], "dw": [], "dh": []})
 
-        self.spike_source = ColumnDataSource({"x": [], "y": [], "color": [], "unit_id": []})
+        self.spike_source = ColumnDataSource({"x": [], "y": [], "color": []})
 
         # Create color mapper
         self.color_mapper = LinearColorMapper(palette="Greys256", low=-1, high=1)
@@ -317,8 +264,9 @@ def _panel_refresh(self):
         else:
             auto_scale = False
 
-        times_chunk, data_curves, scatter_x, scatter_y, scatter_colors, scatter_unit_ids = \
+        times_chunk, data_curves, scatter_x, scatter_y, scatter_colors = \
             self.get_data_in_chunk(t1, t2, seg_index)
+        data_curves = data_curves.T
 
         if self.color_limit is None:
             self.color_limit = np.max(np.abs(data_curves))
@@ -335,7 +283,6 @@ def _panel_refresh(self):
             "x": scatter_x,
             "y": scatter_y,
             "color": scatter_colors,
-            "unit_id": scatter_unit_ids,
         })
 
         if auto_scale:
@@ -350,7 +297,7 @@ 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 = self.find_nearest_spike(self.controller, event.x, seg_index)
+        ind_spike_nearest = find_nearest_spike(self.controller, event.x, seg_index)
         if ind_spike_nearest is not None:
             self.controller.set_indices_spike_selected([ind_spike_nearest])
             self._panel_seek_with_selected_spike()
@@ -364,8 +311,8 @@ def _panel_on_spike_selection_changed(self):
         self._panel_seek_with_selected_spike()
 
     def _panel_gain_zoom(self, event):
-        factor = 1.3 if event.delta > 0 else 1 / 1.3
-        self.color_mapper.high = self.color_mapper.high * factor
+        factor_ratio = 1.3 if event.delta > 0 else 1 / 1.3
+        self.color_mapper.high = self.color_mapper.high * factor_ratio
         self.color_mapper.low = -self.color_mapper.high
 
     def _panel_auto_scale(self, event):