Merge pull request #176 from chrishalcrow/greedy-layout

samuelgarcia · web-flow · commit 0443dcb6860a · 2025-09-24T11:14:35.000+02:00
Greedy layout idea
diff --git a/README.md b/README.md
@@ -200,23 +200,28 @@ 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",
 which are laid out as follows:
 
-```
-+-----------------+-----------------+
-| [zone1   zone2] | [zone3 | [zone4 |
-+-----------------+        |        +
-| [zone5   zone6] | zone7] | zone8] |
-+-----------------+-----------------+
-```
++---------------+--------------+
+| zone1   zone2 | zone3  zone4 |
++               +              +
+| zone5   zone6 | zone7  zone8 |
++---------------+--------------+
+
+If a zone has free space below it or to the right of it, it will try to use it.
+Stretching downwards takes precedence over stretching rightwards.
+E.g. suppose your layout is only non-empty in zones 1, 4, 5, 6 and 7:
 
-If zones are not included, the other zones take over their space. Hence if you'd
-like to show waveforms as a long view, you can set zone3 to display waveforms
-and then set zone7 to display nothing. The waveforms in zone3 will take over the
-blank space from zone7.
++---------------+--------------+
+| zone1         |        zone4 |
++               +              +
+| zone5   zone6 | zone7        |
++---------------+--------------+
+
+Then zone1 will stretch right-wards to make a three-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
 be a list of zones, and which views should appear in which zones. An example:
 
-
 **my_layout.json**
 ```
 {
diff --git a/spikeinterface_gui/backend_panel.py b/spikeinterface_gui/backend_panel.py
@@ -1,9 +1,11 @@
 import param
 import panel as pn
-
+import numpy as np
+from copy import copy
 
 from .viewlist import possible_class_views
 from .layout_presets import get_layout_description
+from .utils_global import get_size_bottom_row, get_size_top_row
 
 # Used by views to emit/trigger signals
 class SignalNotifier(param.Parameterized):
@@ -182,8 +184,6 @@ def listen_setting_changes(view):
     for setting_data in view._settings:
         view.settings._parameterized.param.watch(view.on_settings_changed, setting_data["name"])
 
-
-
 class PanelMainWindow:
 
     def __init__(self, controller, layout_preset=None, layout=None):
@@ -283,57 +283,29 @@ def create_main_layout(self):
             allow_drag=False,
         )
 
-        all_zones = [f'zone{a}' for a in range(1,9)]
-        is_zone = [(layout_zone.get(zone) is not None) and (len(layout_zone.get(zone)) > 0) for zone in all_zones]
-
-        # Get number of columns and rows per sub-region
-        num_cols_12 = max(is_zone[0]*1 + is_zone[1]*1, is_zone[4]*1 + is_zone[5]*1)
-        num_cols_56 = num_cols_12
-        num_cols_37 = (is_zone[2] or is_zone[6])*1 
-
-        num_rows_12 = ((is_zone[0] or is_zone[1])*1 - (is_zone[4] or is_zone[5])*1) + 1
-
-        # Do sub-regions [1,2], [4,5] [3][7] and [5][8] separately. For each, find out if
-        # both zones are present. If they are, place both in sub-region. If not, place one.
-
-        row_slice_12 = slice(0,num_rows_12)
-        if (is_zone[0] and is_zone[1]):
-            gs[row_slice_12, slice(0,1)] = layout_zone.get('zone1')
-            gs[row_slice_12, slice(1,2)] = layout_zone.get('zone2')
-        elif (is_zone[0] and not is_zone[1]):
-            gs[row_slice_12, slice(0,num_cols_12)] = layout_zone.get('zone1')
-        elif (is_zone[1] and not is_zone[0]):
-            gs[row_slice_12, slice(0,num_cols_12)] = layout_zone.get('zone2')
-
-        row_slice_56 = slice(num_rows_12, 2)
-        if (is_zone[4] and is_zone[5]):
-            gs[row_slice_56, slice(0,1)] = layout_zone.get('zone5')
-            gs[row_slice_56, slice(1,2)] = layout_zone.get('zone6')
-        elif (is_zone[4] and not is_zone[5]):
-            gs[row_slice_56, slice(0,num_cols_56)] = layout_zone.get('zone5')
-        elif (is_zone[5] and not is_zone[4]):
-            gs[row_slice_56, slice(0,num_cols_56)] = layout_zone.get('zone6')
-
-        col_slice_37 = slice(num_cols_12,num_cols_12+1)
-        if is_zone[2] and is_zone[6]:
-            gs[slice(0, 1), col_slice_37] = layout_zone.get('zone3')
-            gs[slice(1, 2), col_slice_37] = layout_zone.get('zone7')
-        elif is_zone[2] and not is_zone[6]:
-            gs[slice(0, 2), col_slice_37] = layout_zone.get('zone3')
-        elif is_zone[6] and not is_zone[2]:
-            gs[slice(0, 2), col_slice_37] = layout_zone.get('zone7')
-
-        col_slice_48 = slice(num_cols_12+num_cols_37,num_cols_12+num_cols_37+1)
-        if is_zone[3] and is_zone[7]:
-            gs[slice(0, 1), col_slice_48] = layout_zone.get('zone4')
-            gs[slice(1, 2), col_slice_48] = layout_zone.get('zone8')
-        elif is_zone[3] and not is_zone[7]:
-            gs[slice(0, 2), col_slice_48] = layout_zone.get('zone4')
-        elif is_zone[7] and not is_zone[3]:
-            gs[slice(0, 2), col_slice_48] = layout_zone.get('zone8')
+        gs = self.make_half_layout(gs, ['zone1', 'zone2', 'zone5', 'zone6'], layout_zone, 0)
+        gs = self.make_half_layout(gs, ['zone3', 'zone4', 'zone7', 'zone8'], layout_zone, 2)
 
         self.main_layout = gs
 
+    def make_half_layout(self, gs, all_zones, layout_zone, shift):
+
+        is_zone = [(layout_zone.get(zone) is not None) and (len(layout_zone.get(zone)) > 0) for zone in all_zones]
+        is_zone_array = np.reshape(is_zone, (2,2))
+        original_zone_array = copy(is_zone_array)
+
+        for zone_index, zone_name in enumerate(all_zones):
+            row = zone_index // 2
+            col = zone_index % 2
+            if row == 0:
+                num_rows, num_cols = get_size_top_row(row, col, is_zone_array, original_zone_array)
+            elif row == 1:
+                num_rows, num_cols = get_size_bottom_row(row, col, is_zone_array, original_zone_array)
+            if num_rows > 0 and num_cols > 0:
+                gs[slice(row, row + num_rows), slice(col+shift,col+num_cols+shift)] = layout_zone.get(zone_name)
+
+        return gs
+
     def update_visibility(self, event):
         active = event.new
         tab_names = event.obj._names
diff --git a/spikeinterface_gui/backend_qt.py b/spikeinterface_gui/backend_qt.py
@@ -1,16 +1,17 @@
 from .myqt import QT
 import pyqtgraph as pg
 import markdown
-
+import numpy as np
+from copy import copy
 
 import weakref
 
 from .viewlist import possible_class_views
 from .layout_presets import get_layout_description
+from .utils_global import get_size_bottom_row, get_size_top_row
 
 from .utils_qt import qt_style, add_stretch_to_qtoolbar
 
-
 # Used by views to emit/trigger signals
 class SignalNotifier(QT.QObject):
     spike_selection_changed = QT.pyqtSignal()
@@ -153,7 +154,6 @@ def __init__(self, controller, parent=None, layout_preset=None, layout=None):
             # refresh do not work because view are not yet visible at init
             view._refresh()
         self.controller.signal_handler.activate()
-
         # TODO sam : all veiws are always refreshed at the moment so this is useless.
         # uncommen this when ViewBase.is_view_visible() work correctly
         # for view_name, dock in self.docks.items():
@@ -200,47 +200,8 @@ def create_main_layout(self):
             view_names = [view_name for view_name in view_names if view_name in self.views.keys()]
             widgets_zone[zone] = view_names
 
-        ## Handle left
-        first_left = None
-        for zone in ['zone1', 'zone5', 'zone2',  'zone6']:
-            if len(widgets_zone[zone]) == 0:
-                continue
-            view_name = widgets_zone[zone][0]
-            dock = self.docks[view_name]
-            if len(widgets_zone[zone]) > 0 and first_left is None:
-                self.addDockWidget(areas['left'], dock)
-                first_left = view_name
-            elif zone == 'zone5':
-                self.splitDockWidget(self.docks[first_left], dock, orientations['vertical'])
-            elif zone == 'zone2':
-                self.splitDockWidget(self.docks[first_left], dock, orientations['horizontal'])
-            elif zone == 'zone6':
-                if len(widgets_zone['zone5']) > 0:
-                    z = widgets_zone['zone5'][0]
-                    self.splitDockWidget(self.docks[z], dock, orientations['horizontal'])
-                else:
-                    self.splitDockWidget(self.docks[first_left], dock, orientations['vertical'])
-
-        ## Handle right
-        first_top = None
-        for zone in ['zone3', 'zone4', 'zone7',  'zone8']:
-            if len(widgets_zone[zone]) == 0:
-                continue
-            view_name = widgets_zone[zone][0]
-            dock = self.docks[view_name]
-            if len(widgets_zone[zone]) > 0 and first_top is None:
-                self.addDockWidget(areas['right'], dock)
-                first_top = view_name
-            elif zone == 'zone4':
-                self.splitDockWidget(self.docks[first_top], dock, orientations['horizontal'])
-            elif zone == 'zone7':
-                self.splitDockWidget(self.docks[first_top], dock, orientations['vertical'])
-            elif zone == 'zone8':
-                if len(widgets_zone['zone4']) > 0:
-                    z = widgets_zone['zone4'][0]
-                    self.splitDockWidget(self.docks[z], dock, orientations['vertical'])
-                else:
-                    self.splitDockWidget(self.docks[first_top], dock, orientations['horizontal'])
+        self.make_dock(widgets_zone, ['zone1', 'zone2', 'zone5', 'zone6'], "left", col_shift=0)
+        self.make_dock(widgets_zone, ['zone3', 'zone4', 'zone7', 'zone8'], "right", col_shift=2)
         
         # make tabs
         for zone, view_names in widgets_zone.items():
@@ -256,6 +217,104 @@ def create_main_layout(self):
             # make visible the first of each zone
             self.docks[view_name0].raise_()
 
+    def make_dock(self, widgets_zone, all_zones, side_of_window, col_shift):
+
+        all_zones_array = np.transpose(np.reshape(all_zones, (2,2)))
+        is_zone = np.array([(widgets_zone.get(zone) is not None) and (len(widgets_zone.get(zone)) > 0) for zone in all_zones])
+        is_zone_array = np.reshape(is_zone, (2,2))
+        
+        # If the first non-zero zero (from left to right) is on the bottom, move it up
+        for column_index, zones_in_columns in enumerate(is_zone_array):
+            if np.any(zones_in_columns):
+                first_is_top = zones_in_columns[0]
+                if not first_is_top:
+                    top_zone = f"zone{column_index+1+col_shift}"
+                    bottom_zone = f"zone{column_index+5+col_shift}"
+                    widgets_zone[top_zone] = widgets_zone[bottom_zone]
+                    widgets_zone[bottom_zone] = []
+                    continue
+
+        is_zone = np.array([(widgets_zone.get(zone) is not None) and (len(widgets_zone.get(zone)) > 0) for zone in all_zones])
+        is_zone_array = np.reshape(is_zone, (2,2))
+        original_zone_array = copy(is_zone_array)
+
+        # First we split horizontally any columns which are two rows long.
+        # For later, group the zones between these splits
+        all_groups = []
+        group = []
+        for col_index, zones in enumerate(all_zones_array):
+            col = col_index % 2
+            is_a_zone = original_zone_array[:,col]            
+            num_row_0, _ = get_size_top_row(0, col, is_zone_array, original_zone_array)
+            # this function affects is_zone_array so must be run
+            _, _ = get_size_bottom_row(1, col, is_zone_array, original_zone_array)
+            
+            if num_row_0 == 2:
+                if len(group) > 0:
+                    all_groups.append(group)
+                group = []
+                allowed_zones = zones[is_a_zone]
+                all_groups.append(allowed_zones)
+            else:
+                for zone in zones[is_a_zone]:
+                    group.append(zone)
+
+        if len(group) > 0:
+            all_groups.append(group)
+
+        if len(all_groups) == 0:
+            return
+
+        first_zone = all_groups[0][0]
+        first_dock = widgets_zone[first_zone][0]
+        dock = self.docks[first_dock]
+        self.addDockWidget(areas[side_of_window], dock)
+
+        for group in reversed(all_groups[1:]):             
+            digits = np.array([int(s[-1]) for s in group])
+            sorted_indices = np.argsort(digits)
+            sorted_arr = np.array(group)[sorted_indices]
+            view_name = widgets_zone[sorted_arr[0]][0]
+            dock = self.docks[view_name]
+            self.splitDockWidget(self.docks[first_dock], dock, orientations['horizontal'])
+
+        # Now take each sub-group, and split vertically if appropriate
+        new_all_groups = []
+        for group in all_groups:
+
+            if len(group) == 1:
+                # if only one in group, not need to split
+                continue
+
+            top_zones = [zone for zone in group if zone in ['zone1', 'zone2', 'zone3', 'zone4']]
+            bottom_zones = [zone for zone in group if zone in ['zone5', 'zone6', 'zone7', 'zone8']]
+            new_all_groups.append([top_zones, bottom_zones])
+
+            if len(top_zones) > 0 and len(bottom_zones) > 0:
+
+                top_view_name = widgets_zone[top_zones[0]][0]
+                top_dock = self.docks[top_view_name]
+
+                bottom_view_name = widgets_zone[bottom_zones[0]][0]
+                bottom_dock = self.docks[bottom_view_name]
+
+                self.splitDockWidget(top_dock, bottom_dock, orientations['vertical'])
+
+        # Finally, split all the sub-sub-groups horizontally
+        for top_bottom_groups in new_all_groups:
+            for group in top_bottom_groups:
+
+                if len(group) <= 1:
+                    # if only one in group, no need to split
+                    continue
+
+                first_zone_name = widgets_zone[group[0]][0]
+                for zone in reversed(group[1:]):
+                    zone_name = widgets_zone[zone][0]
+                    self.splitDockWidget(self.docks[first_zone_name], self.docks[zone_name], orientations['horizontal'])
+
+
+
     # used by to tell the launcher this is closed
     def closeEvent(self, event):
         self.main_window_closed.emit(self)
diff --git a/spikeinterface_gui/layout_presets.py b/spikeinterface_gui/layout_presets.py
@@ -1,15 +1,28 @@
 import json
 from spikeinterface_gui.viewlist import possible_class_views
+import numpy as np
 
 """
-A preset need 8 zones like this:
+A preset depends on eight zones, which are split into two sub-regions
 
-+-----------------+-----------------+
-| [zone1   zone2] | [zone3 | [zone4 |
-+-----------------+        |        +
-| [zone5   zone6] | zone7] | zone8] |
-+-----------------+-----------------+
++---------------+--------------+
+| zone1   zone2 | zone3  zone4 |
++               +              +
+| zone5   zone6 | zone7  zone8 |
++---------------+--------------+
 
+If a zone has free space below it or to the right of it, it will try to use it.
+Stretching downwards takes precedence over stretching rightwards.
+E.g. suppose your layout is only non-empty in zones 1, 4, 5, 6 and 7:
+
++---------------+--------------+
+| zone1         |        zone4 |
++               +              +
+| zone5   zone6 | zone7        |
++---------------+--------------+
+
+Then zone1 will stretch right-wards to make a three-zone view. Zone4 will stretch
+downwards to make a long two-zone view.
 """
 _presets = {}
 
@@ -38,7 +51,6 @@ def get_layout_description(preset_name, layout=None):
             preset_name = 'default'
         return _presets[preset_name]
 
-
 default_layout = dict(
     zone1=['curation', 'spikelist'],
     zone2=['unitlist', 'mergelist'],
diff --git a/spikeinterface_gui/main.py b/spikeinterface_gui/main.py
@@ -121,7 +121,7 @@ def run_mainwindow(
 
 
         app = mkQApp()
-        
+
         win = QtMainWindow(controller, layout_preset=layout_preset, layout=layout)
         win.setWindowTitle('SpikeInterface GUI')
         # Set window icon
@@ -273,7 +273,7 @@ def run_mainwindow_cli():
         if args.verbose:
             print('Loading analyzer...')
         assert check_folder_is_analyzer(analyzer_folder), f'The folder {analyzer_folder} is not a valid SortingAnalyzer folder'
-        analyzer = load_sorting_analyzer(analyzer_folder, load_extensions=not is_path_remote(analyzer_folder))
+        analyzer = load_sorting_analyzer(analyzer_folder, load_extensions=False)
         if args.verbose:
             print('Analyzer loaded')
 
@@ -312,3 +312,4 @@ def run_mainwindow_cli():
             layout=args.layout_file,
             curation_dict=curation_data,
         )
+
diff --git a/spikeinterface_gui/utils_global.py b/spikeinterface_gui/utils_global.py
