Merge pull request #140 from samuelgarcia/some_fix

Implement color mode in main settings.

Author: samuelgarcia

spikeinterface_gui/backend_panel.py

@@ -13,6 +13,7 @@ class SignalNotifier(param.Parameterized):
     manual_curation_updated = param.Event()
     time_info_updated = param.Event()
     active_view_updated = param.Event()
+    unit_color_changed = param.Event()
 
     def __init__(self, view=None):
         param.Parameterized.__init__(self)
@@ -41,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):
@@ -61,6 +65,7 @@ def connect_view(self, view):
         view.notifier.param.watch(self.on_manual_curation_updated, "manual_curation_updated")
         view.notifier.param.watch(self.on_time_info_updated, "time_info_updated")
         view.notifier.param.watch(self.on_active_view_updated, "active_view_updated")
+        view.notifier.param.watch(self.on_unit_color_changed, "unit_color_changed")
 
     def on_spike_selection_changed(self, param):
         if not self._active:
@@ -112,6 +117,14 @@ def on_active_view_updated(self, param):
                 view._panel_view_is_active = True
             else:
                 view._panel_view_is_active = False
+    
+    def on_unit_color_changed(self, param):
+        if not self._active:
+            return
+        for view in self.controller.views:
+            if param.obj.view == view:
+                continue
+            view.on_unit_color_changed()
 
 param_type_map = {
     "float": param.Number,
@@ -125,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):
@@ -167,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"])
 
 
 
@@ -216,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")
@@ -351,8 +364,14 @@ def start_server(mainwindow, address="localhost", port=0):
 
     pn.config.sizing_mode = "stretch_width"
 
-    mainwindow.main_layout.servable()
+    # mainwindow.main_layout.servable()
+    # TODO alessio : find automatically a port when port = 0
 
+    if address != "localhost":
+        websocket_origin = f"{address}:{port}"
+    else:
+        websocket_origin = None
+    
     server = pn.serve({"/": mainwindow.main_layout}, address=address, port=port,
-                      show=False, start=True, dev=True, autoreload=True,
+                      show=False, start=True, dev=True, autoreload=True,websocket_origin=websocket_origin,
                       title="SpikeInterface GUI")

spikeinterface_gui/backend_qt.py

@@ -18,6 +18,7 @@ class SignalNotifier(QT.QObject):
     channel_visibility_changed = QT.pyqtSignal()
     manual_curation_updated = QT.pyqtSignal()
     time_info_updated = QT.pyqtSignal()
+    unit_color_changed = QT.pyqtSignal()
 
     def __init__(self, parent=None, view=None):
         QT.QObject.__init__(self, parent=parent)
@@ -38,6 +39,10 @@ def notify_manual_curation_updated(self):
     def notify_time_info_updated(self):
         self.time_info_updated.emit()
 
+    def notify_unit_color_changed(self):
+        self.unit_color_changed.emit()
+
+
 # Used by controler to handle/callback signals
 class SignalHandler(QT.QObject):
     def __init__(self, controller, parent=None):
@@ -57,6 +62,7 @@ def connect_view(self, view):
         view.notifier.channel_visibility_changed.connect(self.on_channel_visibility_changed)
         view.notifier.manual_curation_updated.connect(self.on_manual_curation_updated)
         view.notifier.time_info_updated.connect(self.on_time_info_updated)
+        view.notifier.unit_color_changed.connect(self.on_unit_color_changed)
 
     def on_spike_selection_changed(self):
         if not self._active:
@@ -68,6 +74,7 @@ def on_spike_selection_changed(self):
             view.on_spike_selection_changed()
 
     def on_unit_visibility_changed(self):
+
         if not self._active:
             return
         for view in self.controller.views:
@@ -102,6 +109,15 @@ def on_time_info_updated(self):
                 # do not refresh it self
                 continue
             view.on_time_info_updated()
+    
+    def on_unit_color_changed(self):
+        if not self._active:
+            return
+        for view in self.controller.views:
+            if view.qt_widget == self.sender().parent():
+                # do not refresh it self
+                continue
+            view.on_unit_color_changed()
 
 
 def create_settings(view, parent):

spikeinterface_gui/controller.py

@@ -21,6 +21,11 @@
     ('visible', 'bool'), ('selected', 'bool'), ('rand_selected', 'bool')]
 
 
+_default_main_settings = dict(
+    max_visible_units=10,
+    color_mode='color_by_unit',
+)
+
 # TODO handle return_scaled
 from spikeinterface.widgets.sorting_summary import _default_displayed_unit_properties
 
@@ -54,6 +59,11 @@ def __init__(self, analyzer=None, backend="qt", parent=None, verbose=False, save
         self.verbose = verbose
         t0 = time.perf_counter()
 
+
+        self.main_settings = _default_main_settings.copy()
+
+
+
         self.num_channels = self.analyzer.get_num_channels()
         # this now private and shoudl be acess using function
         self._visible_unit_ids = [self.unit_ids[0]]
@@ -218,8 +228,7 @@ def __init__(self, analyzer=None, backend="qt", parent=None, verbose=False, save
         self.sampling_frequency = self.analyzer.sampling_frequency
 
         # spikeinterface handle colors in matplotlib style tuple values in range (0,1)
-        self.colors = get_unit_colors(self.analyzer.sorting, color_engine='matplotlib', map_name='gist_ncar', 
-                                      shuffle=True, seed=42)
+        self.refresh_colors()
 
         # at init, we set the visible channels as the sparsity of the first unit
         self.visible_channel_inds = self.analyzer_sparsity.unit_id_to_channel_indices[self.unit_ids[0]].astype("int64")
@@ -328,9 +337,6 @@ def __init__(self, analyzer=None, backend="qt", parent=None, verbose=False, save
                         print('Curation quality labels are the default ones')
                     self.has_default_quality_labels = True
 
-        self.main_settings = dict(
-            max_visible_units=10,
-        )
 
     def check_is_view_possible(self, view_name):
         from .viewlist import possible_class_views
@@ -387,6 +393,29 @@ def get_information_txt(self):
 
         return txt
 
+    def refresh_colors(self):
+        if self.backend == "qt":
+            self._cached_qcolors = {}
+        elif self.backend == "panel":
+            pass
+
+        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'] == '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'] == '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']
+            for i, unit_id in enumerate(self.get_visible_unit_ids()):
+                self.colors[unit_id] = cmap(i)
+
+
     def get_unit_color(self, unit_id):
         # scalar unit_id -> color html or QtColor
         return self.colors[unit_id]

spikeinterface_gui/main.py

@@ -26,8 +26,9 @@ def run_mainwindow(
     skip_extensions=None,
     recording=None,
     start_app=True,
-    make_servable=False,
     layout_preset=None,
+    address="localhost",
+    port=0,
     verbose=False,
 ):
     """
@@ -62,6 +63,10 @@ def run_mainwindow(
         If True, the QT app loop is started
     layout_preset : str | None
         The name of the layout preset. None is default.
+    address: str, default : "localhost"
+        For "web" mode only. By default only on local machine.
+    port: int, default: 0
+        For "web" mode only. If 0 then the port is automatic.
     verbose: bool, default: False
         If True, print some information in the console
     """
@@ -111,14 +116,15 @@ def run_mainwindow(
         win.show()
         if start_app:
             app.exec()
+    
     elif backend == "panel":
         import panel
         from .backend_panel import PanelMainWindow, start_server
         win = PanelMainWindow(controller, layout_preset=layout_preset)
+        win.main_layout.servable(title='SpikeInterface GUI')
         if start_app:
-            start_server(win)
-        elif make_servable:
-            win.main_layout.servable(title='SpikeInterface GUI')
+            start_server(win, address=address, port=port)
+            
 
     return win
 

spikeinterface_gui/mainsettingsview.py

@@ -1,14 +1,16 @@
 from .view_base import ViewBase
 
 
-
+# this control controller.main_settings
 main_settings = [
     {'name': 'max_visible_units', 'type': 'int', 'value' : 10 },
+    {'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
@@ -26,7 +28,15 @@ def on_max_visible_units_changed(self):
             visible_ids = visible_ids[:max_visible]
             self.controller.set_visible_unit_ids(visible_ids)
             self.notify_unit_visibility_changed()
+    
+    def on_change_color_mode(self):
 
+        self.controller.main_settings['color_mode'] = self.main_settings['color_mode']
+        self.controller.refresh_colors()
+        self.notify_unit_color_changed()
+
+        # for view in self.controller.views:
+        #     view.refresh()
 
     ## QT zone
     def _qt_make_layout(self):
@@ -49,6 +59,7 @@ def _qt_make_layout(self):
         self.layout.addWidget(self.tree_main_settings)
 
         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):
@@ -57,8 +68,22 @@ def _qt_refresh(self):
 
     ## 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]