Merge with main

Author: alejoe91

README.md

@@ -222,7 +222,7 @@ sigui --mode=web --root-folder path-to-my-analyzers
 ![launcher_web](docs/source/images/launcher_web.png)
 
 
-## Customizing the layout
+## Customizing layout and settings
 
 You can create your own custom layout by specifying which views you'd like
 to see, and where they go. The basic window layout supports eight "zones",
@@ -248,7 +248,7 @@ E.g. suppose your layout is only non-empty in zones 1, 4, 5, 6 and 7:
 +---------------+--------------+
 ```
 
-Then zone1 will stretch right-wards to make a three-zone view. Zone4 will stretch
+Then zone1 will stretch right-wards to make a two-zone view. Zone4 will stretch
 downwards to make a long two-zone view.
 
 To specify your own layout, put the specification in a `.json` file. This should
@@ -278,6 +278,41 @@ sigui --layout_file=path/to/my_layout.json path/to/sorting_analyzer
 
 Find a list of available views [in this file](https://github.com/SpikeInterface/spikeinterface-gui/blob/main/spikeinterface_gui/viewlist.py).
 
+You can also edit the initial settings for each view. There are two ways to do this.
+First, you can open the gui, edit the settings of any or all views, then press the 
+"Save as default settings" button in the `mainsettings` view. This will save a 
+`settings.json` file in your spikeinterface-gui config (saved in `~/.config/spikeinterface_gui/`).
+The saved settings will automatically load next time you start the gui.
+
+If you want more direct control, you can pass your own setting json file
+to the `settings-file` flag (or by passing a `user_settings` dict to `run_mainwindow`). 
+The settings file should contain a settings dict for each view. The view names are the
+same as used in the layout file, and each setting name can be seen in the settings
+tab of each view. Below is an example settings file:
+
+**my_settings.json**
+
+``` json
+{
+    "probe": {
+        "show_channel_id": true
+    },
+    "waveform": {
+        "overlap": false, 
+        "plot_std": false
+    },
+    "spikeamplitude": {
+        "max_spikes_per_unit": 1000, 
+        "alpha": 0.2
+    }
+}
+```
+
+You can then use this file by running e.g.
+
+```bash
+sigui --settings_file=path/to/my_settings.json path/to/sorting_analyzer
+```
 
 ## Deploy the GUI in web mode
 

docs/source/custom_layout.rst renamed to docs/source/custom_layout_settings.rst

@@ -1,5 +1,5 @@
-Customizing the layout
-======================
+Customizing layout and settings
+===============================
 
 You can create your own custom layout by specifying which views you'd like
 to see, and where they go. The basic window layout supports eight "zones",
@@ -26,7 +26,7 @@ E.g. suppose your layout is only non-empty in zones 1, 4, 5, 6 and 7:
     +---------------+--------------+
 
 
-Then zone1 will stretch right-wards to make a three-zone view. Zone4 will stretch
+Then zone1 will stretch right-wards to make a two-zone view. Zone4 will stretch
 downwards to make a long two-zone view.
 
 To specify your own layout, put the specification in a ``.json`` file. This should
@@ -55,3 +55,40 @@ using the ``--layout_file`` flag:
    sigui --layout_file=path/to/my_layout.json path/to/sorting_analyzer
 
 Find a list of available views `in this file <https://github.com/SpikeInterface/spikeinterface-gui/blob/main/spikeinterface_gui/viewlist.py>`_.
+
+You can also edit the initial settings for each view. There are two ways to do this.
+First, you can open the gui, edit the settings of any or all views, then press the 
+"Save as default settings" button in the ``mainsettings`` view. This will save a 
+``settings.json`` file in your spikeinterface-gui config (saved in ``~/.config/spikeinterface_gui/``).
+The saved settings will automatically load next time you start the gui.
+
+If you want more direct control, you can pass your own setting json file
+to the ``settings-file`` flag (or by passing a ``user_settings`` dict to ``run_mainwindow``). 
+The settings file should contain a settings dict for each view. The view names are the
+same as used in the layout file, and each setting name can be seen in the settings
+tab of each view. Below is an example settings file:
+
+**my_settings.json**
+
+.. code-block:: json
+
+    {
+        "probe": {
+            "show_channel_id": true
+        },
+        "waveform": {
+            "overlap": false, 
+            "plot_std": false
+        },
+        "spikeamplitude": {
+            "max_spikes_per_unit": 1000, 
+            "alpha": 0.2
+        }
+    }
+
+
+You can then use this file by running e.g.
+
+.. code-block:: bash
+
+    sigui --settings_file=path/to/my_settings.json path/to/sorting_analyzer

docs/source/index.rst

@@ -50,7 +50,7 @@ This is a web app internally using Panel, useful when the data is remote
    installation
    launch
    usage
-   custom_layout
+   custom_layout_settings
    deployments
    views
    developers

spikeinterface_gui/backend_panel.py

@@ -185,13 +185,13 @@ def listen_setting_changes(view):
 
 class PanelMainWindow:
 
-    def __init__(self, controller, layout_preset=None, layout=None):
+    def __init__(self, controller, layout_preset=None, layout=None, user_settings=None):
         self.controller = controller
         self.layout_preset = layout_preset
         self.layout = layout
         self.verbose = controller.verbose
 
-        self.make_views()
+        self.make_views(user_settings)
         self.create_main_layout()
 
         # refresh all views wihtout notiying
@@ -202,7 +202,7 @@ def __init__(self, controller, layout_preset=None, layout=None):
             if view.is_view_visible():
                 view.refresh()
 
-    def make_views(self):
+    def make_views(self, user_settings):
         self.views = {}
         # this contains view layout + settings + compute
         self.view_layouts = {}
@@ -227,6 +227,13 @@ def make_views(self):
                 sizing_mode="stretch_both"
             )
 
+            if user_settings is not None and user_settings.get(view_name) is not None:
+                for setting_name, user_setting in user_settings.get(view_name).items():
+                    if setting_name not in view.settings.keys():
+                        raise KeyError(f"Setting {setting_name} is not a valid setting for View {view_name}. Check your settings file.")
+                    with param.parameterized.discard_events(view.settings._parameterized):
+                        view.settings[setting_name] = user_setting
+
             tabs = [("📊", view.layout)]
             if view_class._settings is not None:
                 settings = pn.Param(view.settings._parameterized, sizing_mode="stretch_height", 

spikeinterface_gui/backend_qt.py

@@ -148,18 +148,22 @@ def create_settings(view, parent):
 def listen_setting_changes(view):
     view.settings.sigTreeStateChanged.connect(view.on_settings_changed)
 
+def stop_listen_setting_changes(view):
+    view.settings.sigTreeStateChanged.disconnect(view.on_settings_changed)
+
 
 class QtMainWindow(QT.QMainWindow):
     main_window_closed = QT.pyqtSignal(object)
 
-    def __init__(self, controller, parent=None, layout_preset=None, layout=None):
+    def __init__(self, controller, parent=None, layout_preset=None, layout=None, user_settings=None):
         QT.QMainWindow.__init__(self, parent)
 
         self.controller = controller
         self.verbose = controller.verbose
         self.layout_preset = layout_preset
         self.layout = layout
-        self.make_views()
+        
+        self.make_views(user_settings)
         self.create_main_layout()
 
         # refresh all views wihtout notiying
@@ -173,7 +177,7 @@ def __init__(self, controller, parent=None, layout_preset=None, layout=None):
         # for view_name, dock in self.docks.items():
         #     dock.visibilityChanged.connect(self.views[view_name].refresh)
 
-    def make_views(self):
+    def make_views(self, user_settings):
         self.views = {}
         self.docks = {}
         for view_name, view_class in possible_class_views.items():
@@ -190,6 +194,16 @@ def make_views(self):
 
             widget = ViewWidget(view_class)
             view = view_class(controller=self.controller, parent=widget, backend='qt')
+
+            if user_settings is not None and user_settings.get(view_name) is not None:
+                for setting_name, user_setting in user_settings.get(view_name).items():
+                    if setting_name not in view.settings.keys().keys():
+                        raise KeyError(f"Setting {setting_name} is not a valid setting for View {view_name}. Check your settings file.")
+                    stop_listen_setting_changes(view)
+                    view.settings[setting_name] = user_setting
+                    listen_setting_changes(view)
+
+
             widget.set_view(view)
             dock = QT.QDockWidget(view_name)
             dock.setWidget(widget)

spikeinterface_gui/controller.py

@@ -35,11 +35,12 @@ class Controller():
     def __init__(self, analyzer=None, backend="qt", parent=None, verbose=False, save_on_compute=False,
                  curation=False, curation_data=None, label_definitions=None, with_traces=True,
                  displayed_unit_properties=None,
-                 extra_unit_properties=None, skip_extensions=None):
+                 extra_unit_properties=None, skip_extensions=None, disable_save_settings_button=False):
         self.views = []
         skip_extensions = skip_extensions if skip_extensions is not None else []
         self.skip_extensions = skip_extensions
         self.backend = backend
+        self.disable_save_settings_button = disable_save_settings_button
         if self.backend == "qt":
             from .backend_qt import SignalHandler
             self.signal_handler = SignalHandler(self, parent=parent)
@@ -443,6 +444,29 @@ def get_t_start_t_stop(self):
         else:
             return 0, self.get_num_samples(segment_index) / self.sampling_frequency
 
+    def get_times_chunk(self, segment_index, t1, t2):
+        ind1, ind2 = self.get_chunk_indices(t1, t2, segment_index)
+        if self.main_settings["use_times"]:
+            recording = self.analyzer.recording
+            times_chunk = recording.get_times(segment_index=segment_index)[ind1:ind2]
+        else:
+            times_chunk = np.arange(ind2 - ind1, dtype='float64') / self.controller.sampling_frequency + max(t1, 0)
+        return times_chunk
+
+    def get_chunk_indices(self, t1, t2, segment_index):
+        if self.main_settings["use_times"]:
+            recording = self.analyzer.recording
+            ind1, ind2 = recording.time_to_sample_index([t1, t2], segment_index=segment_index)
+        else:
+            t_start = 0.0
+            sr = self.sampling_frequency
+            ind1 = int((t1 - t_start) * sr)
+            ind2 = int((t2 - t_start) * sr)
+
+        ind1 = max(0, ind1)
+        ind2 = min(self.get_num_samples(segment_index), ind2)
+        return ind1, ind2
+
     def sample_index_to_time(self, sample_index):
         segment_index = self.time_info["segment_index"]
         if self.main_settings["use_times"] and self.analyzer.has_recording():
@@ -610,14 +634,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)