Fix color mode and NDscatter in panel

Author: alejoe91

spikeinterface_gui/backend_panel.py

@@ -42,6 +42,9 @@ def notify_active_view_updated(self):
         # views
         self.param.trigger("active_view_updated")
 
+    def notify_unit_color_changed(self):
+        self.param.trigger("unit_color_changed")
+
 
 class SignalHandler(param.Parameterized):
     def __init__(self, controller, parent=None):
@@ -135,16 +138,16 @@ class SettingsProxy:
     # for instance self.settings['my_params'] instead of self.settings.my_params
     # self.settings['my_params'] = value instead of self.settings.my_params = value
     def __init__(self, myparametrized):
-        self._parametrized = myparametrized
+        self._parameterized = myparametrized
 
     def __getitem__(self, key):
-        return getattr(self._parametrized, key)
+        return getattr(self._parameterized, key)
 
     def __setitem__(self, key, value):
-        self._parametrized.param.update(**{key:value})
+        self._parameterized.param.update(**{key:value})
 
     def keys(self):
-        return list(p for p in self._parametrized.param if p != "name")
+        return list(p for p in self._parameterized.param if p != "name")
 
 
 def create_dynamic_parameterized(settings):
@@ -177,7 +180,7 @@ def create_settings(view):
 
 def listen_setting_changes(view):
     for setting_data in view._settings:
-        view.settings._parametrized.param.watch(view.on_settings_changed, setting_data["name"])
+        view.settings._parameterized.param.watch(view.on_settings_changed, setting_data["name"])
 
 
 
@@ -226,7 +229,7 @@ def make_views(self):
 
             tabs = [("📊", view.layout)]
             if view_class._settings is not None:
-                settings = pn.Param(view.settings._parametrized, sizing_mode="stretch_height", 
+                settings = pn.Param(view.settings._parameterized, sizing_mode="stretch_height", 
                                     name=f"{view_name.capitalize()} settings")
                 if view_class._need_compute:
                     compute_button = pn.widgets.Button(name="Compute", button_type="primary")

spikeinterface_gui/controller.py

@@ -23,7 +23,7 @@
 
 _default_main_settings = dict(
     max_visible_units=10,
-    color_mode='all_colorized',
+    color_mode='color_by_unit',
 )
 
 # TODO handle return_scaled
@@ -399,16 +399,16 @@ def refresh_colors(self):
         elif self.backend == "panel":
             pass
 
-        if self.main_settings['color_mode'] == 'all_colorized':
+        if self.main_settings['color_mode'] == 'color_by_unit':
             self.colors = get_unit_colors(self.analyzer.sorting, color_engine='matplotlib', map_name='gist_ncar', 
                                         shuffle=True, seed=42)
-        elif  self.main_settings['color_mode'] == 'colorize_only_visible':
+        elif  self.main_settings['color_mode'] == 'color_only_visible':
             unit_colors = get_unit_colors(self.analyzer.sorting, color_engine='matplotlib', map_name='gist_ncar', 
                                         shuffle=True, seed=42)            
             self.colors = {unit_id: (0.3, 0.3, 0.3, 1.) for unit_id in self.unit_ids}
             for unit_id in self.get_visible_unit_ids():
                 self.colors[unit_id] = unit_colors[unit_id]
-        elif  self.main_settings['color_mode'] == 'colorize_by_visibility':
+        elif  self.main_settings['color_mode'] == 'color_by_visibility':
             self.colors = {unit_id: (0.3, 0.3, 0.3, 1.) for unit_id in self.unit_ids}
             import matplotlib.pyplot as plt
             cmap = plt.colormaps['tab10']

spikeinterface_gui/mainsettingsview.py

@@ -4,14 +4,13 @@
 # this control controller.main_settings
 main_settings = [
     {'name': 'max_visible_units', 'type': 'int', 'value' : 10 },
-    {'name': 'color_mode', 'type': 'list', 'value' : 'all_colorized',
-        'limits': ['all_colorized', 'colorize_only_visible', 'colorize_by_visibility']},
-
+    {'name': 'color_mode', 'type': 'list', 'value' : 'color_by_unit',
+             'limits': ['color_by_unit', 'color_only_visible', 'color_by_visibility']},
 ]
 
 
 class MainSettingsView(ViewBase):
-    _supported_backend = ['qt', ]
+    _supported_backend = ['qt', 'panel']
     _settings = None
     _depend_on = []
     _need_compute = False
@@ -62,17 +61,29 @@ def _qt_make_layout(self):
         self.main_settings.param('max_visible_units').sigValueChanged.connect(self.on_max_visible_units_changed)
         self.main_settings.param('color_mode').sigValueChanged.connect(self.on_change_color_mode)
 
-        
-
 
     def _qt_refresh(self):
         pass
 
 
     ## panel zone
     def _panel_make_layout(self):
-        pass
-
+        import panel as pn
+        from .backend_panel import create_dynamic_parameterized, SettingsProxy
+
+        # Create method and arguments layout
+        self.main_settings = SettingsProxy(create_dynamic_parameterized(main_settings))
+        self.main_settings_layout = pn.Param(self.main_settings._parameterized, sizing_mode="stretch_both", 
+                                             name=f"Main settings")
+        self.main_settings._parameterized.param.watch(self._panel_on_max_visible_units_changed, 'max_visible_units')
+        self.main_settings._parameterized.param.watch(self._panel_on_change_color_mode, 'color_mode')
+        self.layout = pn.Column(self.main_settings_layout, sizing_mode="stretch_both")
+
+    def _panel_on_max_visible_units_changed(self, event):
+        self.on_max_visible_units_changed()
+
+    def _panel_on_change_color_mode(self, event):
+        self.on_change_color_mode()
 
     def _panel_refresh(self):
         pass

spikeinterface_gui/mergeview.py

@@ -285,16 +285,16 @@ def _panel_make_layout(self):
 
         # Create method and arguments layout
         method_settings = SettingsProxy(create_dynamic_parameterized(self._methods))
-        self.method_selector = pn.Param(method_settings._parametrized, sizing_mode="stretch_width", name="Method")
+        self.method_selector = pn.Param(method_settings._parameterized, sizing_mode="stretch_width", name="Method")
         for setting_data in self._methods:
-            method_settings._parametrized.param.watch(self._panel_on_method_change, setting_data["name"])
+            method_settings._parameterized.param.watch(self._panel_on_method_change, setting_data["name"])
 
         self.method_params = {}
         self.method_params_selectors = {}
         for method, params in self._method_params.items():
             method_params = SettingsProxy(create_dynamic_parameterized(params))
             self.method_params[method] = method_params
-            self.method_params_selectors[method] = pn.Param(method_params._parametrized, sizing_mode="stretch_width",
+            self.method_params_selectors[method] = pn.Param(method_params._parameterized, sizing_mode="stretch_width",
                                                             name=f"{method.capitalize()} parameters")
         self.method = list(self.method_params.keys())[0]
 

spikeinterface_gui/ndscatterview.py

@@ -76,8 +76,9 @@ def new_tour_step(self):
         self.tour_step+=1
         if self.tour_step>=num_step:
             self.tour_step = 0
-            
-        self.refresh()
+
+        # avoid printing refresh time
+        self._refresh(update_colors=False, update_components=False)
 
     def next_face(self):
         self.n_face += 1
@@ -118,39 +119,25 @@ def on_channel_visibility_changed(self):
     def apply_dot(self, data):
         projected = np.dot(data[:, self.selected_comp], self.projection[self.selected_comp, :])
         return projected
-    
-    def get_plotting_data(self, concatenated=True):
-
-        if concatenated:
-            # panel prefer concatenated
-            visible_unit_indices = self.controller.get_visible_unit_indices()
-            spike_indices = np.flatnonzero(np.isin(self.pc_unit_index, visible_unit_indices))
-            projected = self.apply_dot(self.data[spike_indices, :])
-            scatter_x = projected[:, 0]
-            scatter_y = projected[:, 1]
-
-            # set new limit
-            if len(projected) > 0 and self.auto_update_limit:
+
+    def get_plotting_data(self, return_spike_indices=False):
+        scatter_x = {}
+        scatter_y = {}
+        all_limits = []
+        spike_indices = {}
+        for unit_ind, unit_id in self.controller.iter_visible_units():
+            mask = np.flatnonzero(self.pc_unit_index == unit_ind)
+            projected = self.apply_dot(self.data[mask, :])
+            scatter_x[unit_id] = projected[:, 0]
+            scatter_y[unit_id] = projected[:, 1]
+            if self.auto_update_limit and len(projected) > 0:
                 projected_2d = projected[:, :2]
-                self.limit = float(np.percentile(np.abs(projected_2d), 95) * 2.)
-        else:
-            # qt prefer by unit (because no need for color vectors)
-            scatter_x = {}
-            scatter_y = {}
-            all_limits = []
-            spike_indices = None
-            for unit_ind, unit_id in self.controller.iter_visible_units():
-                mask = np.flatnonzero(self.pc_unit_index == unit_ind)
-                projected = self.apply_dot(self.data[mask, :])
-                scatter_x[unit_id] = projected[:, 0]
-                scatter_y[unit_id] = projected[:, 1]
-                if self.auto_update_limit and len(projected) > 0:
-                    projected_2d = projected[:, :2]
-                    all_limits.append(float(np.percentile(np.abs(projected_2d), 95) * 2.))
-            if len(all_limits) > 0 and self.auto_update_limit:
-                self.limit = max(all_limits)
+                all_limits.append(float(np.percentile(np.abs(projected_2d), 95) * 2.))
+            if return_spike_indices:
+                spike_indices[unit_id] = mask
+        if len(all_limits) > 0 and self.auto_update_limit:
+            self.limit = max(all_limits)
 
-
         self.limit = max(self.limit, 0.1)  # ensure limit is at least 0.1
 
         mask = np.isin(self.random_spikes_indices, self.controller.get_indices_spike_selected())
@@ -163,7 +150,10 @@ def get_plotting_data(self, concatenated=True):
             selected_scatter_x = projected_select[:, 0]
             selected_scatter_y = projected_select[:, 1]
 
-        return scatter_x, scatter_y, spike_indices, selected_scatter_x, selected_scatter_y
+        if return_spike_indices:
+            return scatter_x, scatter_y, selected_scatter_x, selected_scatter_y, spike_indices
+        else:
+            return scatter_x, scatter_y, selected_scatter_x, selected_scatter_y
 
 
     def update_selected_components(self):
@@ -286,7 +276,7 @@ def _qt_refresh(self, update_components=True):
         # self.scatter.setData(x=scatter_x, y=scatter_y, brush=scatter_colors, pen=pg.mkPen(None))
         # self.scatter_select.setData(selected_scatter_x, selected_scatter_y)
 
-        scatter_x, scatter_y, spike_indices, selected_scatter_x, selected_scatter_y = self.get_plotting_data(concatenated=False)
+        scatter_x, scatter_y, selected_scatter_x, selected_scatter_y = self.get_plotting_data()
         for unit_index, unit_id in self.controller.iter_visible_units():
             color = self.get_unit_color(unit_id)
             self.scatter.addPoints(x=scatter_x[unit_id], y=scatter_y[unit_id],  pen=pg.mkPen(None), brush=color)
@@ -440,20 +430,28 @@ def _panel_make_layout(self):
 
         self.tour_timer = None
 
-    def _panel_refresh(self, update_components=True):
+    def _panel_refresh(self, update_components=True, update_colors=True):
         if update_components:
             self.update_selected_components()
-        scatter_x, scatter_y, spike_indices, selected_scatter_x, selected_scatter_y = self.get_plotting_data(concatenated=True)
+        scatter_x, scatter_y, selected_scatter_x, selected_scatter_y = self.get_plotting_data()
 
-        # format rgba
-        spike_colors = self.controller.get_spike_colors(self.pc_unit_index[spike_indices])
+        xs, ys, colors = [], [], []
+        for unit_id in scatter_x.keys():
+            color = self.get_unit_color(unit_id)
+            xs.extend(scatter_x[unit_id])
+            ys.extend(scatter_y[unit_id])
+            if update_colors:
+                colors.extend([color] * len(scatter_x[unit_id]))
 
+        if not update_colors:
+            colors = self.scatter_source.data.get("color")
 
         self.scatter_source.data = {
-            "x": scatter_x,
-            "y": scatter_y,
-            "color": spike_colors,
+            "x": xs,
+            "y": ys,
+            "color": colors,
         }
+
         self.scatter_select_source.data = {
             "x": selected_scatter_x,
             "y": selected_scatter_y,

spikeinterface_gui/probeview.py

@@ -580,8 +580,8 @@ def _panel_on_pan_end(self, event):
             # Update unit visibility
             new_x, new_y = self.unit_circle.center
             self.update_unit_visibility(new_x, new_y, self.settings['radius_units'])
-            self._panel_update_unit_glyphs()  # Update glyphs to reflect new visibility
             self.notify_unit_visibility_changed()
+            self._panel_update_unit_glyphs()  # Update glyphs to reflect new visibility
 
         elif self.should_resize_channel_circle is not None:
             x_center, y_center = self.channel_circle.center
@@ -609,8 +609,8 @@ def _panel_on_pan_end(self, event):
             self.settings["radius_units"] = new_radius
             # Update unit visibility
             self.update_unit_visibility(x_center, y_center, self.settings['radius_units'])
-            self._panel_update_unit_glyphs()
             self.notify_unit_visibility_changed()
+            self._panel_update_unit_glyphs()
 
         self.should_move_channel_circle = None
         self.should_move_unit_circle = None
@@ -647,7 +647,6 @@ def _panel_on_tap(self, event):
                 if len(self.controller.get_visible_unit_ids()) == 1:
                     select_only = True
 
-            self._panel_update_unit_glyphs()
 
             if select_only:
                 # Update selection circles
@@ -659,6 +658,7 @@ def _panel_on_tap(self, event):
                 self.controller.set_channel_visibility(visible_channel_inds)
                 self.notify_channel_visibility_changed
             self.notify_unit_visibility_changed()
+            self._panel_update_unit_glyphs()
 
 
 def circle_from_roi(roi):

spikeinterface_gui/unitlist.py

@@ -1,6 +1,5 @@
 import warnings
 import numpy as np
-import time
 
 from .view_base import ViewBase
 
@@ -22,13 +21,13 @@ def __init__(self, controller=None, parent=None, backend="qt"):
     ## common ##
     def show_all(self):
         self.controller.set_visible_unit_ids(self.controller.unit_ids)
-        self.refresh()
         self.notify_unit_visibility_changed()
+        self.refresh()
 
     def hide_all(self):
         self.controller.set_all_unit_visibility_off()
-        self.refresh()
         self.notify_unit_visibility_changed()
+        self.refresh()
 
     def get_selected_unit_ids(self):
         if self.backend == 'qt':
@@ -605,6 +604,10 @@ def _panel_refresh(self):
             visible.append(dict_unit_visible[unit_id])
         df.loc[:, "visible"] = visible
 
+        if self.controller.main_settings['color_mode'] in ('color_by_visibility', 'color_only_visible'):
+            # in the mode color change dynamically but without notify to avoid double refresh
+            self._panel_refresh_colors()
+
         table_columns = self.table.value.columns
 
         for table_col in table_columns:
@@ -650,8 +653,8 @@ def _panel_on_visible_checkbox_toggled(self, row):
 
         # update the visible column
         self.table.value.loc[self.controller.unit_ids, "visible"] = self.controller.get_units_visibility_mask()
-        self.refresh()
         self.notify_unit_visibility_changed()
+        self.refresh()
 
     def _panel_on_unit_visibility_changed(self):
         # update selection to match visible units
@@ -661,6 +664,25 @@ def _panel_on_unit_visibility_changed(self):
         self.table.selection = rows_to_select
         self.refresh()
 
+    def _panel_refresh_colors(self):
+        import matplotlib.colors as mcolors
+
+        unit_ids_data = []
+        for unit_id in self.table.value.index.values:
+            unit_ids_data.append(
+                {
+                    "id": str(unit_id),
+                    "color": mcolors.to_hex(self.controller.get_unit_color(unit_id))
+                }
+            )
+        self.table.value.loc[:, "unit_id"] = unit_ids_data
+
+    def _panel_on_unit_color_changed(self):
+        # here we update the unit colors, since they are then fixed in the table
+        # during refresh
+        self._panel_refresh_colors()
+        self.refresh()
+
     def _panel_on_edit(self, event):
         column = event.column
         if self.label_definitions is not None and column in self.label_definitions: