plotnine 0.15.2__py3-none-any.whl → 0.16.0a1__py3-none-any.whl

plotnine/_mpl/layout_manager/_layout_tree.py

@@ -1,23 +1,28 @@
 from __future__ import annotations
 
-import abc
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from functools import cached_property
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, Iterator, cast
 
 import numpy as np
 
-from plotnine.composition import Beside
-
-from ._spaces import LayoutSpaces
+from ._grid import Grid
+from ._plot_side_space import PlotSideSpaces
 
 if TYPE_CHECKING:
-    from typing import Sequence
+    from typing import Sequence, TypeAlias
 
-    from plotnine import ggplot
     from plotnine._mpl.gridspec import p9GridSpec
+    from plotnine._mpl.layout_manager._plot_side_space import (
+        bottom_space,
+        left_space,
+        right_space,
+        top_space,
+    )
     from plotnine.composition import Compose
 
+    Node: TypeAlias = "PlotSideSpaces | LayoutTree"
+
 
 @dataclass
 class LayoutTree:
@@ -25,9 +30,9 @@ class LayoutTree:
     A Tree representation of the composition
 
     The purpose of this class (and its subclasses) is to align and
-    and resize plots in a composition.
+    and resize plots in a composition. For example,
 
-    For example, this composition;
+    This composition:
 
         (p1 | p2) | (p3 / p4)
 
@@ -47,44 +52,108 @@ class LayoutTree:
 
     and the tree would have this structure;
 
-                         ColumnsTree
+
+                         LayoutTree (.nrow=1, .ncol=3)
                              |
                ----------------------------
               |              |             |
-        LayoutSpaces    LayoutSpaces   RowsTree
+        LayoutSpaces    LayoutSpaces   LayoutTree (.nrow=2, .ncol=1)
                                            |
                                       -------------
                                      |             |
                                LayoutSpaces  LayoutSpaces
 
+    This composition:
+
+        (p1 + p2 + p4 + p5 + p6) + plot_layout(ncol=3)
+
+    would look like this:
+
+         -----------------------------
+        |         |         |         |
+        |         |         |         |
+        |    p1   |    p2   |    p3   |
+        |         |         |         |
+        |---------|---------|---------|
+        |         |         |         |
+        |    p4   |    p5   |         |
+        |         |         |         |
+        |         |         |         |
+         -----------------------------
+
+    and have this structure
+
+
+                                    LayoutTree (.nrow=3, .ncol=2)
+                                          |
+               -------------------------------------------------------
+              |             |             |             |             |
+        LayoutSpaces  LayoutSpaces  LayoutSpaces  LayoutSpaces  LayoutSpaces
+
     Each composition is a tree or subtree
-    """
 
-    gridspec: p9GridSpec
-    """
-    Gridspec of the composition
+    ## How it works
 
-    Originally this gridspec occupies all the space available to it so the
-    subplots are of equal sizes. As each subplot contains full ggplot,
-    differences in texts and legend sizes may make the panels (panel area)
-    have unequal sizes. We can resize the panels, by changing the height
-    and width ratios of this (composition) gridspec.
+    Initially (and if the composition does not have annotation texts), the
+    sub_gridspec occupies all the space available to it with the contained
+    items (ggplot / Compose) having equal sizes.
+
+    But if the full plot / composition occupy the same space, their panels
+    may have different sizes because they have to share that space with the
+    texts (title, subtitle, caption, axis title, axis text, tag), legends
+    and plot margins that surround the panels.
+
+    We align the panels, axis titles and tags by adding *_alignment margins;
+    and resize the panels by
+
+    Taking the sizes of these elements into account, we align the panels
+    in the composition by changing the width and/or height of the gridspec.
 
     The information about the size (width & height) of the panels is in the
     LayoutSpaces.
     """
 
-    nodes: list[LayoutSpaces | LayoutTree]
+    cmp: Compose
+    """
+    Composition that this tree represents
+    """
+
+    nodes: list[PlotSideSpaces | LayoutTree]
     """
     The spaces or tree of spaces in the composition that the tree
     represents.
     """
 
+    sub_gridspec: p9GridSpec = field(init=False, repr=False)
+    """
+    Gridspec (nxn) that contains the composed items
+    """
+
+    def __post_init__(self):
+        self.sub_gridspec = self.cmp._sub_gridspec
+        self.grid = Grid["Node"](
+            self.nrow,
+            self.ncol,
+            self.nodes,
+            order="row_major" if self.cmp.layout.byrow else "col_major",
+        )
+
+    @property
+    def ncol(self) -> int:
+        """
+        Number of columns
+        """
+        return cast("int", self.cmp.layout.ncol)
+
+    @property
+    def nrow(self) -> int:
+        """
+        Number of rows
+        """
+        return cast("int", self.cmp.layout.nrow)
+
     @staticmethod
-    def create(
-        cmp: Compose,
-        lookup_spaces: dict[ggplot, LayoutSpaces],
-    ) -> LayoutTree:
+    def create(cmp: Compose) -> LayoutTree:
         """
         Create a LayoutTree for this composition
 
@@ -92,37 +161,41 @@ class LayoutTree:
         ----------
         cmp :
             Composition
-        lookup_spaces :
-            A table to lookup the LayoutSpaces for each plot.
-
-        Notes
-        -----
-        LayoutTree works by modifying the `.gridspec` of the compositions,
-        and the `LayoutSpaces` of the plots.
         """
         from plotnine import ggplot
 
-        nodes: list[LayoutSpaces | LayoutTree] = []
+        # Create subtree
+        nodes: list[PlotSideSpaces | LayoutTree] = []
         for item in cmp:
             if isinstance(item, ggplot):
-                nodes.append(lookup_spaces[item])
+                nodes.append(item._sidespaces)
             else:
-                nodes.append(LayoutTree.create(item, lookup_spaces))
+                nodes.append(LayoutTree.create(item))
+
+        return LayoutTree(cmp, nodes)
 
-        if isinstance(cmp, Beside):
-            return ColumnsTree(cmp.gridspec, nodes)
-        else:
-            return RowsTree(cmp.gridspec, nodes)
+    @cached_property
+    def sub_compositions(self) -> list[LayoutTree]:
+        """
+        LayoutTrees of the direct sub compositions of this one
+        """
+        return [item for item in self.nodes if isinstance(item, LayoutTree)]
 
-    def harmonise(self):
+    def arrange_layout(self):
         """
         Align and resize plots in composition to look good
+
+        Aligning changes the *_alignment attributes of the side_spaces.
+        Resizing, changes the parameters of the sub_gridspec.
+
+        Note that we expect that this method will be called only on the
+        tree for the top-level composition, and it is called for its
+        side-effects.
         """
         self.align_axis_titles()
         self.align()
         self.resize()
 
-    @abc.abstractmethod
     def align(self):
         """
         Align all the edges in this composition & contained compositions
@@ -130,8 +203,10 @@ class LayoutTree:
         This function mutates the layout spaces, specifically the
         margin_alignments along the sides of the plot.
         """
+        self.align_tags()
+        self.align_panels()
+        self.align_sub_compositions()
 
-    @abc.abstractmethod
     def resize(self):
         """
         Resize panels and the entire plots
@@ -139,6 +214,9 @@ class LayoutTree:
         This function mutates the composition gridspecs; specifically the
         width_ratios and height_ratios.
         """
+        self.resize_widths()
+        self.resize_heights()
+        self.resize_sub_compositions()
 
     def align_sub_compositions(self):
         """
@@ -148,20 +226,6 @@ class LayoutTree:
         for tree in self.sub_compositions:
             tree.align()
 
-    @abc.abstractmethod
-    def align_axis_titles(self):
-        """
-        Align the axis titles along the composing dimension
-
-        Since the alignment value used to for this purpose is one of
-        the fields in the _side_space, it affects the space created
-        for the panel.
-
-        We could align the titles within self.align but we would have
-        to store the value outside the _side_space and pick it up when
-        setting the position of the texts!
-        """
-
     def resize_sub_compositions(self):
         """
         Resize panels in the compositions contained in this one
@@ -170,907 +234,428 @@ class LayoutTree:
             tree.resize()
 
     @cached_property
-    def sub_compositions(self) -> list[LayoutTree]:
+    def bottom_most_spaces(self) -> list[bottom_space]:
         """
-        LayoutTrees of the direct sub compositions of this one
+        Bottom spaces of items in the last row
         """
-        return [item for item in self.nodes if isinstance(item, LayoutTree)]
+        return [s for s in self.bottom_spaces_in_row(self.nrow - 1)]
 
     @cached_property
-    @abc.abstractmethod
-    def panel_lefts(self) -> Sequence[float]:
+    def top_most_spaces(self) -> list[top_space]:
         """
-        Left values [figure space] of nodes in this tree
+        Top spaces of items in the top row
         """
+        return [s for s in self.top_spaces_in_row(0)]
 
     @cached_property
-    @abc.abstractmethod
-    def panel_rights(self) -> Sequence[float]:
+    def left_most_spaces(self) -> list[left_space]:
         """
-        Right values [figure space] of nodes in this tree
+        Left spaces of items in the last column
         """
+        return [s for s in self.left_spaces_in_col(0)]
 
     @cached_property
-    @abc.abstractmethod
-    def panel_bottoms(self) -> Sequence[float]:
+    def right_most_spaces(self) -> list[right_space]:
         """
-        Bottom values [figure space] of nodes in this tree
-        """
-
-    @cached_property
-    @abc.abstractmethod
-    def panel_tops(self) -> Sequence[float]:
-        """
-        Top values [figure space] of nodes in this tree
+        Right spaces of items the last column
         """
+        return [s for s in self.right_spaces_in_col(self.ncol - 1)]
 
     @property
-    def panel_lefts_align(self) -> bool:
-        """
-        Return True if panel lefts for the nodes are aligned
-        """
-        arr = np.array(self.panel_lefts)
-        return all(arr == arr[0])
-
-    @property
-    def panel_rights_align(self) -> bool:
-        """
-        Return True if panel rights for the nodes are aligned
-        """
-        arr = np.array(self.panel_rights)
-        return all(arr == arr[0])
-
-    @property
-    def panel_bottoms_align(self) -> bool:
-        """
-        Return True if panel bottoms for the nodes are aligned
-        """
-        arr = np.array(self.panel_bottoms)
-        return all(arr == arr[0])
-
-    @property
-    def panel_tops_align(self) -> bool:
-        """
-        Return True if panel tops for the nodes are aligned
-        """
-        arr = np.array(self.panel_tops)
-        return all(arr == arr[0])
-
-    @property
-    @abc.abstractmethod
     def panel_width(self) -> float:
         """
-        A representative width for panels of the nodes
+        A width of all panels in this composition
         """
+        return sum(self.panel_widths)
 
     @property
-    @abc.abstractmethod
     def panel_height(self) -> float:
         """
-        A representative height for panels of the nodes
+        A height of all panels in this composition
         """
+        return sum(self.panel_heights)
 
     @property
-    @abc.abstractmethod
     def plot_width(self) -> float:
         """
-        A representative width for plots of the nodes
+        A width of all plots in this tree/composition
         """
+        return self.sub_gridspec.width
 
     @property
-    @abc.abstractmethod
     def plot_height(self) -> float:
         """
-        A representative for height for plots of the nodes
+        A height of all plots in this tree/composition
         """
+        return self.sub_gridspec.height
 
     @property
-    def plot_widths(self) -> Sequence[float]:
+    def horizontal_space(self) -> float:
         """
-        Widths [figure space] of nodes in this tree
+        Horizontal non-panel space in this composition
         """
-        return [node.plot_width for node in self.nodes]
+        return sum(self.horizontal_spaces)
 
     @property
-    def plot_heights(self) -> Sequence[float]:
+    def vertical_space(self) -> float:
         """
-        Heights [figure space] of nodes in this tree
+        Vertical non-panel space in this composition
         """
-        return [node.plot_height for node in self.nodes]
+        return sum(self.vertical_spaces)
 
     @property
-    def panel_widths(self) -> Sequence[float]:
+    def horizontal_spaces(self) -> Sequence[float]:
         """
-        Widths [figure space] of the panels in this tree
+        Horizontal non-panel space by column
+
+        For each column, the representative number for the horizontal
+        space to left & right of the widest panel.
         """
-        return [node.panel_width for node in self.nodes]
+        return list(np.array(self.plot_widths) - self.panel_widths)
 
     @property
-    def panel_heights(self) -> Sequence[float]:
-        """
-        Heights [figure space] of the panels in this tree
+    def vertical_spaces(self) -> Sequence[float]:
         """
-        return [node.panel_height for node in self.nodes]
+        Vertical non-panel space by row
 
-    @cached_property
-    @abc.abstractmethod
-    def left_tag_width(self) -> float:
-        """
-        A representative width [figure space] for the left tags of the nodes
+        For each row, the representative number for the vertical
+        space is above & below the tallest panel.
         """
+        return list(np.array(self.plot_heights) - self.panel_heights)
 
-    @cached_property
-    @abc.abstractmethod
-    def right_tag_width(self) -> float:
-        """
-        A representative width [figure space] for the right tags of the nodes
+    @property
+    def panel_widths(self) -> Sequence[float]:
         """
+        Widths [figure space] of panels by column
 
-    @cached_property
-    @abc.abstractmethod
-    def bottom_tag_height(self) -> float:
-        """
-        A representative height [figure space] for the top tags of the nodes
+        For each column, the representative number for the panel width
+        is the maximum width among all panels in the column.
         """
+        # This method is used after aligning the panels. Therefore, the
+        # wides panel_width (i.e. max()) is the good representative width
+        # of the column.
+        w = self.plot_width / self.ncol
+        return [
+            max(node.panel_width for node in col if node) if any(col) else w
+            for col in self.grid.iter_cols()
+        ]
 
-    @cached_property
-    @abc.abstractmethod
-    def top_tag_height(self) -> float:
-        """
-        A representative height [figure space] for the top tags of the nodes
+    @property
+    def panel_heights(self) -> Sequence[float]:
         """
+        Heights [figure space] of panels by row
 
-    @cached_property
-    def left_tag_widths(self) -> list[float]:
+        For each row, the representative number for the panel height
+        is the maximum height among all panels in the row.
         """
-        The widths of the left tags in this tree
-        """
-        return [node.left_tag_width for node in self.nodes]
+        h = self.plot_height / self.nrow
+        return [
+            max([node.panel_height for node in row if node]) if any(row) else h
+            for row in self.grid.iter_rows()
+        ]
 
-    @cached_property
-    def right_tag_widths(self) -> list[float]:
-        """
-        The widths of the right tags in this tree
+    @property
+    def plot_widths(self) -> Sequence[float]:
         """
-        return [node.right_tag_width for node in self.nodes]
+        Widths [figure space] of the plots by column
 
-    @cached_property
-    def bottom_tag_heights(self) -> list[float]:
-        """
-        The heights of the bottom tags in this tree
+        For each column, the representative number is the width of
+        the widest plot.
         """
-        return [node.bottom_tag_height for node in self.nodes]
-
-    @cached_property
-    def top_tag_heights(self) -> list[float]:
-        """
-        The heights of the top tags in this tree
-        """
-        return [node.top_tag_height for node in self.nodes]
+        w = self.sub_gridspec.width / self.ncol
+        return [
+            max([node.plot_width if node else w for node in col])
+            for col in self.grid.iter_cols()
+        ]
 
     @property
-    def left_tags_align(self) -> bool:
-        """
-        Return True if the left tags for the nodes are aligned
+    def plot_heights(self) -> Sequence[float]:
         """
-        arr = np.array(self.left_tag_widths)
-        return all(arr == arr[0])
+        Heights [figure space] of the plots along vertical dimension
 
-    @property
-    def right_tags_align(self) -> bool:
+        For each row, the representative number is the height of
+        the tallest plot.
         """
-        Return True if the right tags for the nodes are aligned
-        """
-        arr = np.array(self.right_tag_widths)
-        return all(arr == arr[0])
+        h = self.sub_gridspec.height / self.nrow
+        return [
+            max([node.plot_height if node else h for node in row])
+            for row in self.grid.iter_rows()
+        ]
 
     @property
-    def bottom_tags_align(self) -> bool:
-        """
-        Return True if the bottom tags for the nodes are aligned
+    def panel_width_ratios(self) -> Sequence[float]:
         """
-        arr = np.array(self.bottom_tag_heights)
-        return all(arr == arr[0])
+        The relative widths of the panels in the composition
 
-    @property
-    def top_tags_align(self) -> bool:
+        These are normalised to have a mean = 1.
         """
-        Return True if the top tags for the nodes are aligned
-        """
-        arr = np.array(self.top_tag_heights)
-        return all(arr == arr[0])
+        return cast("Sequence[float]", self.cmp._layout.widths)
 
     @property
-    def left_axis_titles_align(self) -> bool:
-        """
-        Return True if the left axis titles align
+    def panel_height_ratios(self) -> Sequence[float]:
         """
-        arr = np.array(self.left_axis_title_clearances)
-        return all(arr == arr[0])
+        The relative heights of the panels in the composition
 
-    @property
-    def bottom_axis_titles_align(self) -> bool:
-        """
-        Return True if the bottom axis titles align
+        These are normalised to have a mean = 1.
         """
-        arr = np.array(self.bottom_axis_title_clearances)
-        return all(arr == arr[0])
+        return cast("Sequence[float]", self.cmp._layout.heights)
 
-    @cached_property
-    @abc.abstractmethod
-    def left_axis_title_clearance(self) -> float:
-        """
-        Distance between the left y-axis title and the panel
+    def bottom_spaces_in_row(self, r: int) -> list[bottom_space]:
         """
+        The bottom_spaces of plots in a given row
 
-    @cached_property
-    @abc.abstractmethod
-    def bottom_axis_title_clearance(self) -> float:
-        """
-        Distance between the left x-axis title and the panel
+        If an item in the row is a compositions, then it is the
+        bottom_spaces in the bottom row of that composition.
         """
+        spaces: list[bottom_space] = []
+        for node in self.grid[r, :]:
+            if isinstance(node, PlotSideSpaces):
+                spaces.append(node.b)
+            elif isinstance(node, LayoutTree):
+                spaces.extend(node.bottom_most_spaces)
+        return spaces
 
-    @cached_property
-    def left_axis_title_clearances(self) -> list[float]:
+    def top_spaces_in_row(self, r: int) -> list[top_space]:
         """
-        Distances between the left y-axis titles and the panels
-        """
-        return [node.left_axis_title_clearance for node in self.nodes]
+        The top_spaces of plots in a given row
 
-    @cached_property
-    def bottom_axis_title_clearances(self) -> list[float]:
+        If an item in the row is a compositions, then it is the
+        top_spaces in the top row of that composition.
         """
-        Distances between the bottom x-axis titles and the panels
-        """
-        return [node.bottom_axis_title_clearance for node in self.nodes]
+        spaces: list[top_space] = []
+        for node in self.grid[r, :]:
+            if isinstance(node, PlotSideSpaces):
+                spaces.append(node.t)
+            elif isinstance(node, LayoutTree):
+                spaces.extend(node.top_most_spaces)
+        return spaces
 
-    @abc.abstractmethod
-    def set_left_margin_alignment(self, value: float):
+    def left_spaces_in_col(self, c: int) -> list[left_space]:
         """
-        Set a margin to align the left of the panels in this composition
+        The left_spaces plots in a given column
 
-        In figure dimenstions
+        If an item in the column is a compositions, then it is the
+        left_spaces in the left most column of that composition.
         """
+        spaces: list[left_space] = []
+        for node in self.grid[:, c]:
+            if isinstance(node, PlotSideSpaces):
+                spaces.append(node.l)
+            elif isinstance(node, LayoutTree):
+                spaces.extend(node.left_most_spaces)
+        return spaces
 
-    @abc.abstractmethod
-    def set_right_margin_alignment(self, value: float):
+    def right_spaces_in_col(self, c: int) -> list[right_space]:
         """
-        Set a margin to align the right of the panels in this composition
+        The right_spaces of plots in a given column
 
-        In figure dimenstions
+        If an item in the column is a compositions, then it is the
+        right_spaces in the right most column of that composition.
         """
+        spaces: list[right_space] = []
+        for node in self.grid[:, c]:
+            if isinstance(node, PlotSideSpaces):
+                spaces.append(node.r)
+            elif isinstance(node, LayoutTree):
+                spaces.extend(node.right_most_spaces)
+        return spaces
 
-    @abc.abstractmethod
-    def set_bottom_margin_alignment(self, value: float):
+    def iter_left_spaces(self) -> Iterator[list[left_space]]:
         """
-        Set a margin to align the bottom of the panels in this composition
+        Left spaces for each non-empty column
 
-        In figure dimenstions
+        Will not return an empty list.
         """
+        for c in range(self.ncol):
+            spaces = self.left_spaces_in_col(c)
+            if spaces:
+                yield spaces
 
-    @abc.abstractmethod
-    def set_top_margin_alignment(self, value: float):
+    def iter_right_spaces(self) -> Iterator[list[right_space]]:
         """
-        Set a margin to align the top of the panels in this composition
+        Right spaces for each non-empty column
 
-        In figure dimenstions
+        Will not return an empty list.
         """
+        for c in range(self.ncol):
+            spaces = self.right_spaces_in_col(c)
+            if spaces:
+                yield spaces
 
-    @abc.abstractmethod
-    def set_left_tag_alignment(self, value: float):
+    def iter_bottom_spaces(self) -> Iterator[list[bottom_space]]:
         """
-        Set the space to align the left tags in this composition
+        Bottom spaces for each non-empty row
 
-        In figure dimenstions
+        Will not return an empty list.
         """
+        for r in range(self.nrow):
+            spaces = self.bottom_spaces_in_row(r)
+            if spaces:
+                yield spaces
 
-    @abc.abstractmethod
-    def set_right_tag_alignment(self, value: float):
+    def iter_top_spaces(self) -> Iterator[list[top_space]]:
         """
-        Set the space to align the right tags in this composition
+        Top spaces for each non-empty row
 
-        In figure dimenstions
+        Will not return an empty list.
         """
+        for r in range(self.nrow):
+            spaces = self.top_spaces_in_row(r)
+            if spaces:
+                yield spaces
 
-    @abc.abstractmethod
-    def set_bottom_tag_alignment(self, value: float):
+    def align_panels(self):
         """
-        Set the space to align the bottom tags in this composition
+        Align the edges of the panels in the composition
+        """
+        for spaces in self.iter_bottom_spaces():
+            bottoms = [space.panel_bottom for space in spaces]
+            high = max(bottoms)
+            diffs = [high - b for b in bottoms]
+            for space, diff in zip(spaces, diffs):
+                space.margin_alignment += diff
 
-        In figure dimenstions
-        """
+        for spaces in self.iter_top_spaces():
+            tops = [space.panel_top for space in spaces]
+            low = min(tops)
+            diffs = [b - low for b in tops]
+            for space, diff in zip(spaces, diffs):
+                space.margin_alignment += diff
 
-    @abc.abstractmethod
-    def set_top_tag_alignment(self, value: float):
-        """
-        Set the space to align the top tags in this composition
+        for spaces in self.iter_left_spaces():
+            lefts = [space.panel_left for space in spaces]
+            high = max(lefts)
+            diffs = [high - l for l in lefts]
+            for space, diff in zip(spaces, diffs):
+                space.margin_alignment += diff
 
-        In figure dimenstions
-        """
+        for spaces in self.iter_right_spaces():
+            rights = [space.panel_right for space in spaces]
+            low = min(rights)
+            diffs = [r - low for r in rights]
+            for space, diff in zip(spaces, diffs):
+                space.margin_alignment += diff
+
+    def align_tags(self):
+        """
+        Align the tags in the composition
+        """
+        for spaces in self.iter_bottom_spaces():
+            heights = [
+                space.tag_height + space.tag_alignment for space in spaces
+            ]
+            high = max(heights)
+            diffs = [high - h for h in heights]
+            for space, diff in zip(spaces, diffs):
+                space.tag_alignment += diff
+
+        for spaces in self.iter_top_spaces():
+            heights = [
+                space.tag_height + space.tag_alignment for space in spaces
+            ]
+            high = max(heights)
+            diffs = [high - h for h in heights]
+            for space, diff in zip(spaces, diffs):
+                space.tag_alignment += diff
 
-    @abc.abstractmethod
-    def set_left_axis_title_alignment(self, value: float):
-        """
-        Set the space to align the left axis titles in this composition
+        for spaces in self.iter_left_spaces():
+            widths = [
+                space.tag_width + space.tag_alignment for space in spaces
+            ]
+            high = max(widths)
+            diffs = [high - w for w in widths]
+            for space, diff in zip(spaces, diffs):
+                space.tag_alignment += diff
+
+        for spaces in self.iter_right_spaces():
+            widths = [
+                space.tag_width + space.tag_alignment for space in spaces
+            ]
+            high = max(widths)
+            diffs = [high - w for w in widths]
+            for space, diff in zip(spaces, diffs):
+                space.tag_alignment += diff
 
-        In figure dimenstions
+    def align_axis_titles(self):
         """
+        Align the axis titles along the composing dimension
 
-    @abc.abstractmethod
-    def set_bottom_axis_title_alignment(self, value: float):
-        """
-        Set the space to align the bottom axis titles in this composition
+        Since the alignment value used to for this purpose is one of
+        the fields in the _side_space, it affects the space created
+        for the panel.
 
-        In figure dimenstions
+        We could align the titles within self.align but we would have
+        to store the value outside the _side_space and pick it up when
+        setting the position of the texts!
         """
 
+        for spaces in self.iter_bottom_spaces():
+            clearances = [space.axis_title_clearance for space in spaces]
+            high = max(clearances)
+            diffs = [high - b for b in clearances]
+            for space, diff in zip(spaces, diffs):
+                space.axis_title_alignment += diff
 
-@dataclass
-class ColumnsTree(LayoutTree):
-    """
-    Tree with columns at the outermost level
-
-    e.g. p1 | (p2 / p3)
-
-
-         -------------------
-        |         |         |
-        |         |         |
-        |         |         |
-        |         |         |
-        |         |---------|
-        |         |         |
-        |         |         |
-        |         |         |
-        |         |         |
-         -------------------
-    """
-
-    def align(self):
-        self.align_top_tags()
-        self.align_bottom_tags()
-        self.align_panel_tops()
-        self.align_panel_bottoms()
-        self.align_sub_compositions()
+        for spaces in self.iter_left_spaces():
+            clearances = [space.axis_title_clearance for space in spaces]
+            high = max(clearances)
+            diffs = [high - l for l in clearances]
+            for space, diff in zip(spaces, diffs):
+                space.axis_title_alignment += diff
 
-    def align_axis_titles(self):
-        self.align_bottom_axis_titles()
         for tree in self.sub_compositions:
             tree.align_axis_titles()
 
-    def resize(self):
-        """
-        Resize the widths of gridspec so that panels have equal widths
-        """
-        # The new width of each panel is the average width of all
-        # the panels plus all the space to the left and right
-        # of the panels.
-        plot_widths = np.array(self.plot_widths)
-        panel_widths = np.array(self.panel_widths)
-        non_panel_space = plot_widths - panel_widths
-        new_plot_widths = panel_widths.mean() + non_panel_space
-        width_ratios = new_plot_widths / new_plot_widths.min()
-        self.gridspec.set_width_ratios(width_ratios)
-        self.resize_sub_compositions()
-
-    def align_panel_bottoms(self):
-        """
-        Align the immediate bottom edges this composition
-
-         -----------        -----------
-        |     |     |      |     |     |
-        |     |     |      |     |     |
-        |     |     |  ->  |     |     |
-        |     |#####|      |#####|#####|
-        |#####|     |      |     |     |
-         -----------        -----------
-        """
-        # If panels are aligned and have a non-zero margin_alignment,
-        # aligning them again will set that value to zero and undoes
-        # the alignment.
-        if self.panel_bottoms_align:
-            return
-
-        values = max(self.panel_bottoms) - np.array(self.panel_bottoms)
-        for item, value in zip(self.nodes, values):
-            if isinstance(item, LayoutSpaces):
-                item.b.margin_alignment = value
-            else:
-                item.set_bottom_margin_alignment(value)
-
-        del self.panel_bottoms
-
-    def align_panel_tops(self):
+    def resize_widths(self):
         """
-        Align the immediate top edges in this composition
-
-         -----------        -----------
-        |#####|     |      |     |     |
-        |     |#####|      |#####|#####|
-        |     |     |  ->  |     |     |
-        |     |     |      |     |     |
-        |     |     |      |     |     |
-         -----------        -----------
+        Resize the widths of the plots & panels in the composition
         """
-        if self.panel_tops_align:
-            return
-
-        values = np.array(self.panel_tops) - min(self.panel_tops)
-        for item, value in zip(self.nodes, values):
-            if isinstance(item, LayoutSpaces):
-                item.t.margin_alignment = value
-            else:
-                item.set_top_margin_alignment(value)
-
-        del self.panel_tops
-
-    def align_bottom_tags(self):
-        if self.bottom_tags_align:
-            return
-
-        values = cast(
-            "Sequence[float]",
-            max(self.bottom_tag_heights) - np.array(self.bottom_tag_heights),
+        # The scaling calculation to get the new panel width is
+        # straight-forward because the ratios have a mean of 1.
+        # So the multiplication preserves the total panel width.
+        new_panel_widths = np.mean(self.panel_widths) * np.array(
+            self.panel_width_ratios
         )
-        for item, value in zip(self.nodes, values):
-            if isinstance(item, LayoutSpaces):
-                item.l.tag_alignment = value
-            else:
-                item.set_bottom_tag_alignment(value)
-
-    def align_top_tags(self):
-        if self.top_tags_align:
-            return
-
-        values = cast(
-            "Sequence[float]",
-            max(self.top_tag_heights) - np.array(self.top_tag_heights),
-        )
-        for item, value in zip(self.nodes, values):
-            if isinstance(item, LayoutSpaces):
-                item.t.tag_alignment = value
-            else:
-                item.set_top_tag_alignment(value)
-
-    def align_bottom_axis_titles(self):
-        if self.bottom_axis_titles_align:
-            pass
-
-        values = max(self.bottom_axis_title_clearances) - np.array(
-            self.bottom_axis_title_clearances
-        )
-        # We ignore 0 values since they can undo values
-        # set to align this composition with an outer one.
-        for item, value in zip(self.nodes, values):
-            if value == 0:
-                continue
-            if isinstance(item, LayoutSpaces):
-                item.b.axis_title_alignment = value
-            else:
-                item.set_bottom_axis_title_alignment(value)
-
-    @cached_property
-    def panel_lefts(self):
-        left_item = self.nodes[0]
-        if isinstance(left_item, LayoutSpaces):
-            return [left_item.l.panel_left]
-        else:
-            return left_item.panel_lefts
-
-    @cached_property
-    def panel_rights(self):
-        right_item = self.nodes[-1]
-        if isinstance(right_item, LayoutSpaces):
-            return [right_item.r.panel_right]
-        else:
-            return right_item.panel_rights
-
-    @cached_property
-    def panel_bottoms(self):
-        values = []
-        for item in self.nodes:
-            if isinstance(item, LayoutSpaces):
-                values.append(item.b.panel_bottom)
-            else:
-                values.append(max(item.panel_bottoms))
-        return values
-
-    @cached_property
-    def panel_tops(self):
-        values = []
-        for item in self.nodes:
-            if isinstance(item, LayoutSpaces):
-                values.append(item.t.panel_top)
-            else:
-                values.append(min(item.panel_tops))
-        return values
-
-    @property
-    def panel_width(self) -> float:
-        return sum(self.panel_widths)
-
-    @property
-    def panel_height(self) -> float:
-        return float(np.mean(self.panel_heights))
-
-    @property
-    def plot_width(self) -> float:
-        return sum(self.plot_widths)
-
-    @property
-    def plot_height(self) -> float:
-        return max(self.plot_heights)
-
-    @cached_property
-    def left_tag_width(self) -> float:
-        return self.left_tag_widths[0]
-
-    @cached_property
-    def right_tag_width(self) -> float:
-        return self.right_tag_widths[-1]
-
-    @cached_property
-    def bottom_tag_height(self) -> float:
-        return max(self.bottom_tag_heights)
-
-    @cached_property
-    def top_tag_height(self) -> float:
-        return max(self.top_tag_heights)
-
-    @cached_property
-    def left_axis_title_clearance(self) -> float:
-        return self.left_axis_title_clearances[0]
-
-    @cached_property
-    def bottom_axis_title_clearance(self) -> float:
-        return max(self.bottom_axis_title_clearances)
-
-    def set_left_margin_alignment(self, value: float):
-        left_item = self.nodes[0]
-        if isinstance(left_item, LayoutSpaces):
-            left_item.l.margin_alignment = value
-        else:
-            left_item.set_left_margin_alignment(value)
-
-    def set_right_margin_alignment(self, value: float):
-        right_item = self.nodes[-1]
-        if isinstance(right_item, LayoutSpaces):
-            right_item.r.margin_alignment = value
-        else:
-            right_item.set_right_margin_alignment(value)
-
-    def set_bottom_margin_alignment(self, value: float):
-        for item in self.nodes:
-            if isinstance(item, LayoutSpaces):
-                item.b.margin_alignment = value
-            else:
-                item.set_bottom_margin_alignment(value)
-
-    def set_top_margin_alignment(self, value: float):
-        for item in self.nodes:
-            if isinstance(item, LayoutSpaces):
-                item.t.margin_alignment = value
-            else:
-                item.set_top_margin_alignment(value)
-
-    def set_bottom_tag_alignment(self, value: float):
-        for item in self.nodes:
-            if isinstance(item, LayoutSpaces):
-                item.l.tag_alignment = value
-            else:
-                item.set_bottom_tag_alignment(value)
-
-    def set_top_tag_alignment(self, value: float):
-        for item in self.nodes:
-            if isinstance(item, LayoutSpaces):
-                item.t.tag_alignment = value
-            else:
-                item.set_top_tag_alignment(value)
-
-    def set_bottom_axis_title_alignment(self, value: float):
-        for item in self.nodes:
-            if isinstance(item, LayoutSpaces):
-                item.b.axis_title_alignment = value
-            else:
-                item.set_bottom_axis_title_alignment(value)
-
-    def set_left_axis_title_alignment(self, value: float):
-        left_item = self.nodes[0]
-        if isinstance(left_item, LayoutSpaces):
-            left_item.l.axis_title_alignment = value
-        else:
-            left_item.set_left_axis_title_alignment(value)
-
-
-@dataclass
-class RowsTree(LayoutTree):
-    """
-    Tree with rows at the outermost level
-
-    e.g. p1 / (p2 | p3)
-
-         -------------------
-        |                   |
-        |                   |
-        |                   |
-        |-------------------|
-        |         |         |
-        |         |         |
-        |         |         |
-         -------------------
-    """
+        new_plot_widths = new_panel_widths + self.horizontal_spaces
+        width_ratios = new_plot_widths / new_plot_widths.max()
+        self.sub_gridspec.set_width_ratios(width_ratios)
 
-    def align(self):
-        self.align_left_tags()
-        self.align_right_tags()
-        self.align_panel_lefts()
-        self.align_panel_rights()
-        self.align_sub_compositions()
-
-    def align_axis_titles(self):
-        self.align_left_axis_titles()
-        for tree in self.sub_compositions:
-            tree.align_axis_titles()
-
-    def resize(self):
+    def resize_heights(self):
         """
-        Resize the heights of gridspec so that panels have equal heights
-
-        This method resizes (recursively) the contained compositions
+        Resize the heights of the plots & panels in the composition
         """
-        # The new height of each panel is the average width of all
-        # the panels plus all the space above and below the panels.
-        plot_heights = np.array(self.plot_heights)
-        panel_heights = np.array(self.panel_heights)
-        non_panel_space = plot_heights - panel_heights
-        new_plot_heights = panel_heights.mean() + non_panel_space
+        new_panel_heights = np.mean(self.panel_heights) * np.array(
+            self.panel_height_ratios
+        )
+        new_plot_heights = new_panel_heights + self.vertical_spaces
         height_ratios = new_plot_heights / new_plot_heights.max()
-        self.gridspec.set_height_ratios(height_ratios)
-        self.resize_sub_compositions()
-
-    def align_panel_lefts(self):
-        """
-        Align the immediate left edges in this composition
-
-         -----------        -----------
-        |#          |      |  #        |
-        |#          |      |  #        |
-        |#          |      |  #        |
-        |-----------|  ->  |-----------|
-        |  #        |      |  #        |
-        |  #        |      |  #        |
-        |  #        |      |  #        |
-         -----------        -----------
-        """
-        if self.panel_lefts_align:
-            return
+        self.sub_gridspec.set_height_ratios(height_ratios)
 
-        values = max(self.panel_lefts) - np.array(self.panel_lefts)
-        for item, value in zip(self.nodes, values):
-            if isinstance(item, LayoutSpaces):
-                item.l.margin_alignment = value
-            else:
-                item.set_left_margin_alignment(value)
-
-        del self.panel_lefts
 
-    def align_panel_rights(self):
-        """
-        Align the immediate right edges in this composition
-
-         -----------        -----------
-        |        #  |      |        #  |
-        |        #  |      |        #  |
-        |        #  |      |        #  |
-        |-----------|  ->  |-----------|
-        |          #|      |        #  |
-        |          #|      |        #  |
-        |          #|      |        #  |
-         -----------        -----------
-        """
-        if self.panel_rights_align:
-            return
+# For debugging
+def _draw_gridspecs(tree: LayoutTree):
+    from ..utils import draw_bbox
 
-        values = np.array(self.panel_rights) - min(self.panel_rights)
-        for item, value in zip(self.nodes, values):
-            if isinstance(item, LayoutSpaces):
-                item.r.margin_alignment = value
-            else:
-                item.set_right_margin_alignment(value)
-
-        del self.panel_rights
-
-    def align_left_tags(self):
-        """
-        Make all the left tags takeup the same amount of space
-
-
-        Given
-
-                      V
-         ------------------------------------
-        | plot_margin | tag | artists        |
-        |------------------------------------|
-        | plot_margin | A long tag | artists |
-         ------------------------------------
-
-                      V
-         ------------------------------------
-        | plot_margin | #######tag | artists |
-        |------------------------------------|
-        | plot_margin | A long tag | artists |
-         ------------------------------------
-        """
-        if self.left_tags_align:
-            return
-
-        values = cast(
-            "Sequence[float]",
-            max(self.left_tag_widths) - np.array(self.left_tag_widths),
+    def draw(t):
+        draw_bbox(
+            t.cmp._gridspec.bbox_relative,
+            t.cmp._gridspec.figure,
         )
-        for item, value in zip(self.nodes, values):
-            if isinstance(item, LayoutSpaces):
-                item.l.tag_alignment = value
-            else:
-                item.set_left_tag_alignment(value)
+        for subtree in t.sub_compositions:
+            draw(subtree)
 
-    def align_right_tags(self):
-        if self.right_tags_align:
-            return
+    draw(tree)
 
-        values = cast(
-            "Sequence[float]",
-            max(self.right_tag_widths) - np.array(self.right_tag_widths),
-        )
-        for item, value in zip(self.nodes, values):
-            if isinstance(item, LayoutSpaces):
-                item.r.tag_alignment = value
-            else:
-                item.set_right_tag_alignment(value)
 
-    def align_left_axis_titles(self):
-        if self.left_axis_titles_align:
-            pass
+def _draw_sub_gridspecs(tree: LayoutTree):
+    from ..utils import draw_bbox
 
-        values = max(self.left_axis_title_clearances) - np.array(
-            self.left_axis_title_clearances
+    def draw(t):
+        draw_bbox(
+            t.sub_gridspec.bbox_relative,
+            t.sub_gridspec.figure,
         )
-        for item, value in zip(self.nodes, values):
-            if value == 0:
-                continue
-            if isinstance(item, LayoutSpaces):
-                item.l.axis_title_alignment = value
-            else:
-                item.set_left_axis_title_alignment(value)
+        for subtree in t.sub_compositions:
+            draw(subtree)
 
-    @cached_property
-    def panel_lefts(self):
-        values = []
-        for item in self.nodes:
-            if isinstance(item, LayoutSpaces):
-                values.append(item.l.panel_left)
-            else:
-                values.append(max(item.panel_lefts))
-        return values
-
-    @cached_property
-    def panel_rights(self):
-        values = []
-        for item in self.nodes:
-            if isinstance(item, LayoutSpaces):
-                values.append(item.r.panel_right)
-            else:
-                values.append(min(item.panel_rights))
-        return values
-
-    @cached_property
-    def panel_bottoms(self):
-        bottom_item = self.nodes[-1]
-        if isinstance(bottom_item, LayoutSpaces):
-            return [bottom_item.b.panel_bottom]
-        else:
-            return bottom_item.panel_bottoms
-
-    @cached_property
-    def panel_tops(self):
-        top_item = self.nodes[0]
-        if isinstance(top_item, LayoutSpaces):
-            return [top_item.t.panel_top]
-        else:
-            return top_item.panel_tops
-
-    @property
-    def panel_width(self) -> float:
-        return float(np.mean(self.panel_widths))
-
-    @property
-    def panel_height(self) -> float:
-        return sum(self.panel_heights)
-
-    @property
-    def plot_width(self) -> float:
-        return max(self.plot_widths)
-
-    @property
-    def plot_height(self) -> float:
-        return sum(self.plot_heights)
-
-    @cached_property
-    def left_tag_width(self) -> float:
-        return max(self.left_tag_widths)
-
-    @cached_property
-    def right_tag_width(self) -> float:
-        return max(self.right_tag_widths)
-
-    @cached_property
-    def top_tag_height(self) -> float:
-        return self.top_tag_heights[0]
-
-    @cached_property
-    def bottom_tag_height(self) -> float:
-        return self.bottom_tag_heights[-1]
-
-    @cached_property
-    def left_axis_title_clearance(self) -> float:
-        return max(self.left_axis_title_clearances)
-
-    @cached_property
-    def bottom_axis_title_clearance(self) -> float:
-        return self.bottom_axis_title_clearances[-1]
-
-    def set_left_margin_alignment(self, value: float):
-        for item in self.nodes:
-            if isinstance(item, LayoutSpaces):
-                item.l.margin_alignment = value
-            else:
-                item.set_left_margin_alignment(value)
-
-    def set_right_margin_alignment(self, value: float):
-        for item in self.nodes:
-            if isinstance(item, LayoutSpaces):
-                item.r.margin_alignment = value
-            else:
-                item.set_right_margin_alignment(value)
-
-    def set_bottom_margin_alignment(self, value: float):
-        bottom_item = self.nodes[-1]
-        if isinstance(bottom_item, LayoutSpaces):
-            bottom_item.b.margin_alignment = value
-        else:
-            bottom_item.set_bottom_margin_alignment(value)
-
-    def set_top_margin_alignment(self, value: float):
-        top_item = self.nodes[0]
-        if isinstance(top_item, LayoutSpaces):
-            top_item.t.margin_alignment = value
-        else:
-            top_item.set_top_margin_alignment(value)
-
-    def set_left_tag_alignment(self, value: float):
-        for item in self.nodes:
-            if isinstance(item, LayoutSpaces):
-                item.l.tag_alignment = value
-            else:
-                item.set_left_tag_alignment(value)
-
-    def set_right_tag_alignment(self, value: float):
-        for item in self.nodes:
-            if isinstance(item, LayoutSpaces):
-                item.r.tag_alignment = value
-            else:
-                item.set_right_tag_alignment(value)
-
-    def set_left_axis_title_alignment(self, value: float):
-        for item in self.nodes:
-            if isinstance(item, LayoutSpaces):
-                item.l.axis_title_alignment = value
-            else:
-                item.set_left_axis_title_alignment(value)
-
-    def set_bottom_axis_title_alignment(self, value: float):
-        bottom_item = self.nodes[-1]
-        if isinstance(bottom_item, LayoutSpaces):
-            bottom_item.b.axis_title_alignment = value
-        else:
-            bottom_item.set_bottom_axis_title_alignment(value)
+    draw(tree)