Merge branch 'main' of github.com:SpikeInterface/spikeinterface-gui into fix-order-mergeview

Author: alejoe91

spikeinterface_gui/backend_panel.py

@@ -418,6 +418,29 @@ def _handle_shortcut(self, event):
                     tabs.stylesheets = []
 
 
+    def set_external_curation(self, curation_data):
+        """Set external curation to controlled and triggers curation and unitlist refresh
+
+        Parameters
+        ----------
+        curation_data : dict
+            The external curation data to be set.
+        """
+        if "curation" not in self.views:
+            return
+
+        curation_view = self.views["curation"]
+        self.controller.set_curation_data(curation_data)
+        self.controller.current_curation_saved = True
+        curation_view.notify_manual_curation_updated()
+        curation_view.refresh()
+
+        # we also need to refresh the unit list view to update the unit visibility according to the new curation
+        if "unitlist" in self.views:
+            unitlist_view = self.views["unitlist"]
+            unitlist_view.update_manual_labels()
+
+
 def get_local_ip():
     """
     Get the local IP address of the machine.

spikeinterface_gui/basescatterview.py

@@ -17,7 +17,7 @@ class BaseScatterView(ViewBase):
             {'name': 'display_high_percentiles', 'type': 'float', 'value' : 98.0, 'limits':(50, 100), 'step':0.5},
         ]
     _need_compute = False
-    
+
     def __init__(self, spike_data, y_label, controller=None, parent=None, backend="qt"):
 
         # compute data bounds
@@ -46,6 +46,12 @@ def get_unit_data(self, unit_id, segment_index=0):
         spike_times = self.controller.sample_index_to_time(spike_indices)
         spike_data = self.spike_data[inds]
 
+        if len(spike_data) == 1:
+            spike_data_value = spike_data[0]
+            ymin = spike_data_value - 0.1 * spike_data_value
+            ymax = spike_data_value + 0.1 * spike_data_value
+            return spike_times, spike_data, np.array([1]), np.array([ymin, ymax]), ymin, ymax, inds
+
         # avoid clear outliers in the plot and histogram by using percentiles
         ymin, ymax = np.percentile(spike_data, [self.settings['display_low_percentiles'], self.settings['display_high_percentiles']])
         min_bin_size = np.min(np.diff(np.unique(spike_data)))
@@ -185,6 +191,9 @@ def on_unit_visibility_changed(self):
                 self._current_selected = self.controller.get_indices_spike_selected().size
         self.refresh(set_scatter_range=True)
 
+    def on_spike_selection_changed(self):
+        self.refresh()
+
     def on_use_times_updated(self):
         self.refresh(set_scatter_range=True)
 
@@ -295,6 +304,8 @@ def _qt_refresh(self, set_scatter_range=False):
                 unit_id, 
                 segment_index=segment_index
             )
+            if len(spike_times) == 0:
+                continue
 
             # make a copy of the color
             color = QT.QColor(self.get_unit_color(unit_id))
@@ -314,7 +325,7 @@ def _qt_refresh(self, set_scatter_range=False):
 
         # set x range to time range of the current segment for scatter, and max count for histogram
         # set y range to min and max of visible spike amplitudes
-        if set_scatter_range or not self._first_refresh_done:
+        if len(ymins) > 0 and (set_scatter_range or not self._first_refresh_done):
             ymin = np.min(ymins)
             ymax = np.max(ymaxs)
             t_start, t_stop = self.controller.get_t_start_t_stop()
@@ -490,6 +501,7 @@ def _panel_make_layout(self):
         self.plotted_inds = []
 
     def _panel_refresh(self, set_scatter_range=False):
+        import panel as pn
         from bokeh.models import FixedTicker
 
         self.plotted_inds = []
@@ -516,6 +528,8 @@ def _panel_refresh(self, set_scatter_range=False):
                 unit_id,
                 segment_index=segment_index
             )
+            if len(spike_times) == 0:
+                continue
             color = self.get_unit_color(unit_id)
             xs.extend(spike_times)
             ys.extend(spike_data)
@@ -555,28 +569,45 @@ def _panel_refresh(self, set_scatter_range=False):
         # handle selected spikes
         self._panel_update_selected_spikes()
 
-        # set y range to min and max of visible spike amplitudes
+        # Defer Range updates to avoid nested document lock issues
+        # def update_ranges():
         if set_scatter_range or not self._first_refresh_done:
             self.y_range.start = np.min(ymins)
             self.y_range.end = np.max(ymaxs)
             self._first_refresh_done = True
         self.hist_fig.x_range.end = max_count
         self.hist_fig.xaxis.ticker = FixedTicker(ticks=[0, max_count // 2, max_count])
 
+        # Schedule the update to run after the current event loop iteration
+        # pn.state.execute(update_ranges, schedule=True)
+
     def _panel_on_select_button(self, event):
-        if self.select_toggle_button.value:
-            self.scatter_fig.toolbar.active_drag = self.lasso_tool
-        else:
-            self.scatter_fig.toolbar.active_drag = None
-            self.scatter_source.selected.indices = []
+        import panel as pn
+
+        value = self.select_toggle_button.value
+
+        def _do_update():
+            if value:
+                self.scatter_fig.toolbar.active_drag = self.lasso_tool
+            else:
+                self.scatter_fig.toolbar.active_drag = None
+                self.scatter_source.selected.indices = []
+
+        pn.state.execute(_do_update, schedule=True)
 
     def _panel_change_segment(self, event):
+        import panel as pn
+
         self._current_selected = 0
         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
+
+        def _do_update():
+            self.scatter_fig.x_range.start = t_start
+            self.scatter_fig.x_range.end = t_end
+
+        pn.state.execute(_do_update, schedule=True)
         self.refresh(set_scatter_range=True)
         self.notify_time_info_updated()
 
@@ -618,9 +649,17 @@ def _panel_split(self, event):
         self.split()
 
     def _panel_update_selected_spikes(self):
+        import panel as pn
+
         # handle selected spikes
         selected_spike_indices = self.controller.get_indices_spike_selected()
         selected_spike_indices = np.intersect1d(selected_spike_indices, self.plotted_inds)
+        if len(selected_spike_indices) == 1:
+            selected_segment = self.controller.spikes[selected_spike_indices[0]]['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)
         if len(selected_spike_indices) > 0:
             # map absolute indices to visible spikes
             segment_index = self.controller.get_time()[1]
@@ -634,23 +673,16 @@ def _panel_update_selected_spikes(self):
             # set selected spikes in scatter plot
             if self.settings["auto_decimate"] and len(selected_indices) > 0:
                 selected_indices, = np.nonzero(np.isin(self.plotted_inds, selected_spike_indices))
-            self.scatter_source.selected.indices = list(selected_indices)
         else:
-            self.scatter_source.selected.indices = []
+            selected_indices = []
+
+        def _do_update():
+            self.scatter_source.selected.indices = list(selected_indices)
+
+        pn.state.execute(_do_update, schedule=True)
 
     def _panel_on_spike_selection_changed(self):
-        # set selection in scatter plot
-        selected_indices = self.controller.get_indices_spike_selected()
-        if len(selected_indices) == 0:
-            self.scatter_source.selected.indices = []
-            return
-        elif len(selected_indices) == 1:
-            selected_segment = self.controller.spikes[selected_indices[0]]['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
+        # update selected spikes (scheduled via pn.state.execute inside)
         self._panel_update_selected_spikes()
 
     def _panel_handle_shortcut(self, event):

spikeinterface_gui/controller.py

@@ -9,10 +9,7 @@
 from spikeinterface.widgets.utils import get_unit_colors
 from spikeinterface import compute_sparsity
 from spikeinterface.core import get_template_extremum_channel
-import spikeinterface.postprocessing
-import spikeinterface.qualitymetrics
 from spikeinterface.core.sorting_tools import spike_vector_to_indices
-from spikeinterface.core.core_tools import check_json
 from spikeinterface.curation import validate_curation_dict
 from spikeinterface.curation.curation_model import CurationModel
 from spikeinterface.widgets.utils import make_units_table_from_analyzer
@@ -50,6 +47,8 @@ def __init__(
         skip_extensions=None,
         disable_save_settings_button=False,
         external_data=None,
+        curation_callback=None,
+        curation_callback_kwargs=None,
         user_main_settings=None,
     ):
         self.views = []
@@ -329,6 +328,7 @@ def __init__(
         self._traces_cached = {}
 
         self.units_table = make_units_table_from_analyzer(analyzer, extra_properties=extra_unit_properties)
+
         if displayed_unit_properties is None:
             displayed_unit_properties = list(_default_displayed_unit_properties)
         if extra_unit_properties is not None:
@@ -340,7 +340,9 @@ def __init__(
         self.update_time_info()
 
         self.curation = curation
-        # TODO: Reload the dictionary if it already exists
+        self.curation_callback = curation_callback
+        self.curation_callback_kwargs = curation_callback_kwargs
+
         if self.curation:
             # rules:
             #  * if user sends curation_data, then it is used
@@ -349,6 +351,7 @@ def __init__(
 
             if curation_data is not None:
                 # validate the curation data
+                curation_data = deepcopy(curation_data)
                 format_version = curation_data.get("format_version", None)
                 # assume version 2 if not present
                 if format_version is None:
@@ -358,24 +361,6 @@ def __init__(
                 except Exception as e:
                     raise ValueError(f"Invalid curation data.\nError: {e}")
 
-                if curation_data.get("merges") is None:
-                    curation_data["merges"] = []
-                else:
-                    # here we reset the merges for better formatting (str)
-                    existing_merges = curation_data["merges"]
-                    new_merges = []
-                    for m in existing_merges:
-                        if "unit_ids" not in m:
-                            continue
-                        if len(m["unit_ids"]) < 2:
-                            continue
-                        new_merges = add_merge(new_merges, m["unit_ids"])
-                    curation_data["merges"] = new_merges
-                if curation_data.get("splits") is None:
-                    curation_data["splits"] = []
-                if curation_data.get("removed") is None:
-                    curation_data["removed"] = []
-
             elif self.analyzer.format == "binary_folder":
                 json_file = self.analyzer.folder / "spikeinterface_gui" / "curation_data.json"
                 if json_file.exists():
@@ -390,24 +375,27 @@ def __init__(
 
             if curation_data is None:
                 curation_data = deepcopy(empty_curation_data)
+                curation_data["unit_ids"] = self.unit_ids.tolist()
 
-            self.curation_data = curation_data
-
-            self.has_default_quality_labels = False
-            if "label_definitions" not in self.curation_data:
+            if "label_definitions" not in curation_data:
                 if label_definitions is not None:
-                    self.curation_data["label_definitions"] = label_definitions
+                    curation_data["label_definitions"] = label_definitions
                 else:
-                    self.curation_data["label_definitions"] = default_label_definitions.copy()
+                    curation_data["label_definitions"] = default_label_definitions.copy()
 
-            if "quality" in self.curation_data["label_definitions"]:
-                curation_dict_quality_labels = self.curation_data["label_definitions"]["quality"]["label_options"]
+            # This will enable the default shortcuts if has default quality labels
+            self.has_default_quality_labels = False
+            if "quality" in curation_data["label_definitions"]:
+                curation_dict_quality_labels = curation_data["label_definitions"]["quality"]["label_options"]
                 default_quality_labels = default_label_definitions["quality"]["label_options"]
                 if set(curation_dict_quality_labels) == set(default_quality_labels):
                     if self.verbose:
                         print('Curation quality labels are the default ones')
                     self.has_default_quality_labels = True
 
+            curation_data = CurationModel(**curation_data).model_dump()
+            self.curation_data = curation_data
+
     def check_is_view_possible(self, view_name):
         from .viewlist import get_all_possible_views
         possible_class_views = get_all_possible_views()
@@ -710,6 +698,12 @@ def get_traces(self, trace_source='preprocessed', **kargs):
     def get_contact_location(self):
         location = self.analyzer.get_channel_locations()
         return location
+
+    def get_channel_groups(self):
+        if self.has_extension("recording"):
+            return self.analyzer.recording.get_channel_groups()
+        else:
+            return np.zeros(self.analyzer.get_num_channels(), dtype=int)
 
     def get_waveform_sweep(self):
         return self.nbefore, self.nafter
@@ -721,7 +715,7 @@ def get_waveforms(self, unit_id):
         wfs = self.waveforms_ext.get_waveforms_one_unit(unit_id, force_dense=False)
         if self.analyzer.sparsity is None:
             # dense waveforms
-            chan_inds = np.arange(self.analyzer.recording.get_num_channels(), dtype='int64')
+            chan_inds = np.arange(self.analyzer.get_num_channels(), dtype='int64')
         else:
             # sparse waveforms
             chan_inds = self.analyzer.sparsity.unit_id_to_channel_indices[unit_id]
@@ -849,7 +843,7 @@ def compute_auto_merge(self, **params):
         )
 
         return merge_unit_groups, extra
-    
+
     def curation_can_be_saved(self):
         return self.analyzer.format != "memory"
 
@@ -861,6 +855,23 @@ def construct_final_curation(self):
         model = CurationModel(**d)
         return model
 
+    def set_curation_data(self, curation_data):
+        print("Setting curation data")
+        new_curation_data = empty_curation_data.copy()
+        new_curation_data.update(curation_data)
+
+        if "unit_ids" not in curation_data:
+            print("Setting unit_ids from controller")
+            new_curation_data["unit_ids"] = self.unit_ids.tolist()
+
+        if "label_definitions" not in curation_data:
+            print("Setting default label definitions")
+            new_curation_data["label_definitions"] = default_label_definitions.copy()
+
+        # validate the curation data
+        model = CurationModel(**new_curation_data)
+        self.curation_data = model.model_dump()
+
     def save_curation_in_analyzer(self):
         if self.analyzer.format == "memory":
             print("Analyzer is an in-memory object. Cannot save curation file in it.")
@@ -883,6 +894,16 @@ def save_curation_in_analyzer(self):
             sigui_group.attrs["curation_data"] = curation_model.model_dump(mode="json")
             self.current_curation_saved = True
 
+    def save_curation_callback(self):
+        curation = self.construct_final_curation()
+        curation_data = curation.model_dump()
+        if self.curation_callback_kwargs is None:
+            curation_callback_kwargs = {}
+        else:
+            curation_callback_kwargs = self.curation_callback_kwargs
+        self.curation_callback(curation_data, **curation_callback_kwargs)
+        self.current_curation_saved = True
+
     def get_split_unit_ids(self):
         if not self.curation:
             return []