retain quality labels

Author: chrishalcrow

spikeinterface_gui/basescatterview.py

@@ -56,7 +56,7 @@ def get_unit_data(self, unit_id, segment_index=0):
             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']])
+        ymin, ymax = np.percentile(spike_data[~np.isnan(spike_data)], [self.settings['display_low_percentiles'], self.settings['display_high_percentiles']])
         min_bin_size = np.min(np.diff(np.unique(spike_data)))
         bins = np.linspace(ymin, ymax, self.settings['num_bins'])
         # if bins are too small, adjust the number of bins to ensure a minimum bin size and avoid jumps in the histogram
@@ -329,8 +329,8 @@ 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 len(ymins) > 0 and (set_scatter_range or not self._first_refresh_done):
-            ymin = np.min(ymins)
-            ymax = np.max(ymaxs)
+            ymin = np.nanmin(ymins)
+            ymax = np.nanmax(ymaxs)
             t_start, t_stop = self.controller.get_t_start_t_stop()
             self.viewBox.setXRange(t_start, t_stop, padding = 0.0)
             self.viewBox.setYRange(ymin, ymax, padding = 0.0)

spikeinterface_gui/controller.py

@@ -83,7 +83,6 @@ def __init__(
             self.signal_handler = SignalHandler(self, parent=parent)
 
         self.with_traces = with_traces
-        self.main_settings = _default_main_settings.copy()
         self.save_on_compute = save_on_compute
         self.verbose = verbose
 
@@ -95,6 +94,8 @@ def __init__(
 
         self.set_analyzer_info(analyzer)
         self.units_table = make_units_table_from_analyzer(self.analyzer, extra_properties=extra_unit_properties)
+        
+        self.set_curation_info(curation, curation_data, label_definitions, curation_callback, curation_callback_kwargs)
 
         # parse events
         self.events = None
@@ -114,81 +115,7 @@ def __init__(
         # spikeinterface handle colors in matplotlib style tuple values in range (0,1)
         self.refresh_colors()
 
-        self.curation = curation
-        self.curation_callback = curation_callback
-        self.curation_callback_kwargs = curation_callback_kwargs
-
-        self._potential_merges = None
-        self.curation = curation
-        # TODO: Reload the dictionary if it already exists
-        if self.curation:
-            # rules:
-            #  * if user sends curation_data, then it is used
-            #  * otherwise, if curation_data already exists in folder it is used
-            #  * otherwise create an empty one
-
-            if curation_data is not None:
-                # validate the curation data
-                format_version = curation_data.get("format_version", None)
-                # assume version 2 if not present
-                if format_version is None:
-                    raise ValueError("Curation data format version is missing and is required in the curation data.")
-                try:
-                    validate_curation_dict(curation_data)
-                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():
-                    with open(json_file, "r") as f:
-                        curation_data = json.load(f)
-
-            elif self.analyzer.format == "zarr":
-                import zarr
-                zarr_root = zarr.open(self.analyzer.folder, mode='r')
-                if "spikeinterface_gui" in zarr_root.keys() and "curation_data" in zarr_root["spikeinterface_gui"].attrs.keys():
-                    curation_data = zarr_root["spikeinterface_gui"].attrs["curation_data"]
-
-            if curation_data is None:
-                curation_data = deepcopy(empty_curation_data)
-                curation_data["label_definitions"] = default_label_definitions.copy()
-
-            if curation_data.get("discard_spikes") is None:
-                curation_data["discard_spikes"] = []
-
-            self.curation_data = curation_data
-
-            if "label_definitions" not in self.curation_data:
-                if label_definitions is not None:
-                    self.curation_data["label_definitions"] = label_definitions
-
-            self.has_default_quality_labels = False
-            if "quality" in self.curation_data["label_definitions"]:
-                curation_dict_quality_labels = self.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
+        
 
     def check_is_view_possible(self, view_name):
         from .viewlist import get_all_possible_views
@@ -473,30 +400,83 @@ def set_analyzer_info(self, analyzer):
         self.update_time_info()
 
 
-    def check_is_view_possible(self, view_name):
-        from .viewlist import get_all_possible_views
-        possible_class_views = get_all_possible_views()
-        view_class = possible_class_views[view_name]
-        if view_class._depend_on is not None:
-            depencies_ok = all(self.has_extension(k) for k in view_class._depend_on)
-            if not depencies_ok:
-                if self.verbose:
-                    print(view_name, 'does not have all dependencies', view_class._depend_on)                
-                return False
-        return True
+    def set_curation_info(self, curation, curation_data, label_definitions, curation_callback, curation_callback_kwargs):
 
-    def declare_a_view(self, new_view):
-        assert new_view not in self.views, 'view already declared {}'.format(self)
-        self.views.append(new_view)
-        self.signal_handler.connect_view(new_view)
-        
-    @property
-    def channel_ids(self):
-        return self.analyzer.channel_ids
+        self.curation = curation
+        self.curation_callback = curation_callback
+        self.curation_callback_kwargs = curation_callback_kwargs
 
-    @property
-    def unit_ids(self):
-        return self.analyzer.unit_ids
+        self._potential_merges = None
+        self.curation = curation
+        # TODO: Reload the dictionary if it already exists
+        if self.curation:
+            # rules:
+            #  * if user sends curation_data, then it is used
+            #  * otherwise, if curation_data already exists in folder it is used
+            #  * otherwise create an empty one
+
+            if curation_data is not None:
+                # validate the curation data
+                format_version = curation_data.get("format_version", None)
+                # assume version 2 if not present
+                if format_version is None:
+                    raise ValueError("Curation data format version is missing and is required in the curation data.")
+                try:
+                    validate_curation_dict(curation_data)
+                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():
+                    with open(json_file, "r") as f:
+                        curation_data = json.load(f)
+
+            elif self.analyzer.format == "zarr":
+                import zarr
+                zarr_root = zarr.open(self.analyzer.folder, mode='r')
+                if "spikeinterface_gui" in zarr_root.keys() and "curation_data" in zarr_root["spikeinterface_gui"].attrs.keys():
+                    curation_data = zarr_root["spikeinterface_gui"].attrs["curation_data"]
+
+            if curation_data is None:
+                curation_data = deepcopy(empty_curation_data)
+                curation_data["label_definitions"] = default_label_definitions.copy()
+
+            if curation_data.get("discard_spikes") is None:
+                curation_data["discard_spikes"] = []
+
+            self.curation_data = curation_data
+
+            if "label_definitions" not in self.curation_data:
+                if label_definitions is not None:
+                    self.curation_data["label_definitions"] = label_definitions
+
+            self.has_default_quality_labels = False
+            if "quality" in self.curation_data["label_definitions"]:
+                curation_dict_quality_labels = self.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
 
     def get_time(self):
         """
@@ -953,7 +933,6 @@ def construct_final_curation(self, with_explicit_new_unit_ids=False):
         d["format_version"] = "2"
         d["unit_ids"] = self.unit_ids.tolist()
         d.update(self.curation_data.copy())
-
         if with_explicit_new_unit_ids:
             split_new_id_strategy = self.main_settings.get('split_new_id_strategy')
             merge_new_id_strategy = self.main_settings.get('merge_new_id_strategy')
@@ -972,7 +951,7 @@ def apply_curation(self):
         curated_analyzer = apply_curation(self.analyzer, curation)
 
         self.applied_curations.append(curation)
-        self.remove_curation()
+        self.remove_curation(curated_analyzer)
 
         self.set_analyzer_info(curated_analyzer)
 
@@ -984,10 +963,21 @@ def apply_curation(self):
         for view in self.views:
             view.reinitialize()
 
-    def remove_curation(self):
-        label_definitioins = self.curation_data.get("label_definitions", None)
+    def remove_curation(self, curated_analyzer):
+        """Removes curation from the controller, retaining quality labels."""
+
         curation_data = deepcopy(empty_curation_data)
+        # retain label definitions and 'quality' label
+        label_definitioins = self.curation_data.get("label_definitions", None)
         curation_data["label_definitions"] = label_definitioins
+
+        if (quality_labels := curated_analyzer.get_sorting_property('quality')) is not None:
+            manual_labels = []
+            for unit_id, quality_label in zip(curated_analyzer.unit_ids, quality_labels):
+                manual_labels.append({'unit_id': unit_id, 'labels': {'quality': [quality_label]}})
+
+            curation_data['manual_labels'] = manual_labels
+
         self.curation_data = curation_data
 
     def set_curation_data(self, curation_data):

spikeinterface_gui/curationview.py

@@ -4,7 +4,7 @@
 from .view_base import ViewBase
 
 from spikeinterface.core.core_tools import check_json
-
+from spikeinterface.curation.curation_model import SequentialCuration
 
 class CurationView(ViewBase):
     id = "curation"
@@ -301,9 +301,6 @@ def _qt_export_json(self):
                     f.write(curation_model.model_dump_json(indent=4))
                 self.controller.current_curation_saved = True
             else:
-                # Keep this here until `SeqentialCuration` in release of spikeinterface
-                from spikeinterface.curation.curation_model import SequentialCuration
-
                 current_curation_model = self.controller.construct_final_curation()
                 applied_curations = self.controller.applied_curations
                 current_and_applied_curations = applied_curations + [current_curation_model]

spikeinterface_gui/unitlistview.py

@@ -130,7 +130,7 @@ def _qt_set_up_visible_columns(self):
 
     def _qt_reinitialize(self):
 
-        self._qt_set_up_visible_columns()
+        #self._qt_set_up_visible_columns()
         self._qt_full_table_refresh()
         self._qt_refresh()
 
@@ -227,7 +227,6 @@ def _qt_full_table_refresh(self):
 
         self.table.clear()
 
-
         internal_column_names = ['unit_id', 'visible',  'channel_id']
 
         # internal labels

spikeinterface_gui/utils_global.py

@@ -68,9 +68,9 @@ def add_new_unit_ids_to_curation_dict(curation_dict, sorting, split_new_id_strat
     """
 
     from spikeinterface.core.sorting_tools import generate_unit_ids_for_split, generate_unit_ids_for_merge_group
-    from spikeinterface.curation.curation_model import CurationModel
+    from spikeinterface.curation.curation_model import Curation
 
-    curation_model = CurationModel(**curation_dict)
+    curation_model = Curation(**curation_dict)
     old_unit_ids = copy(curation_model.unit_ids)
 
     if len(curation_model.splits) > 0:

spikeinterface_gui/view_base.py

@@ -40,7 +40,6 @@ def __init__(self, controller=None, parent=None, backend="qt"):
                 create_settings(self)
             self.notifier = SignalNotifier(view=self)
             self.busy = pn.indicators.LoadingSpinner(value=True, size=20, name='busy...')
-        self.layout = None
         make_layout()
         if self._settings is not None:
             listen_setting_changes(self)