plot-io 0.12.0__py3-none-win_arm64.whl

plot_io/boxes.py

@@ -0,0 +1,1156 @@
+"""The box tree of a plot: what surrounds its axes, side by side, as ordered nodes.
+
+Each side of a plot's axes is a stack of nodes, from the axes outward, in the order
+:func:`nodes` declares once: the axis (tick marks, tick labels, the label row; on a genome
+axis with ``scale_bar``, the scale bar in place of the ticks and their labels), the
+mirrored ticks, the twin axes (the first on a side drawn at the axes edge, over the
+mirrored ticks, a further one past it), the ×10ᵏ
+offsets of the y axes (on top, the plot's then its twins'), labels drawn past the axes
+(pies), the room text decorations take past the axes, the outside legend, the lines of
+attached colorbars, the titles and, on top, the plot's ``space_above``.  :func:`measure` asks every node for its band (``measure``: a
+thickness, how far it passes the ends of its side, its pad and extent) and stacks them:
+a band's offset is the sum of the sizes before it, except a band at the edge (offset 0).
+:func:`place_plot` places every node from the offset its band was measured at
+(``place``); it keeps no running sums of its own, so what is placed is what was measured.
+The row label and group bands (:func:`plot_io.rows.bands`) are added outermost on the
+left per grid column.
+"""
+
+import dataclasses
+import math
+from typing import Any
+
+from . import rows
+from .geometry import AxisGeometry, Band, Bands, PlotGeometry, Rect, Segment, TitleGeometry
+from .layers.context import DrawContext
+from .guides import place_inside
+from .spec import set_boxes, warn
+from .states import label_content, offset_content
+from .labels import run_quad
+from .text import box, lines_box, lines_run, run, wrap
+from .titles import Block, along, block, rotation_of, rule_extent, rule_inside, rule_rect
+
+__all__ = ["Node", "nodes", "prepare", "measure", "place_plot", "plot_titles", "title_font",
+           "bar_lines", "line_size", "AXIS_KINDS", "tick_label_extent", "tick_label_runs"]
+
+SIDES = ("left", "right", "top", "bottom")
+#: The bands of the axes themselves: what a title spanning the plot (``over="plot"``)
+#: covers beside the axes.
+AXIS_KINDS = ("x_ticks", "x_tick_labels", "x_scale_bar", "x_label", "x_mirror", "y_ticks",
+              "y_tick_labels", "y_label", "y_mirror", "twin", "y_offset", "twin_offset")
+_OPPOSITE = {"left": "right", "right": "left", "top": "bottom", "bottom": "top"}
+
+
+# ---------------------------------------------------------------------------
+# Measuring and placing contexts
+# ---------------------------------------------------------------------------
+
+class Measuring:
+    """A plot measured for axes ``w`` × ``h``: the bands so far per side and how far the
+    content passes the ends of each side (``over``: left, right, top, bottom)."""
+
+    def __init__(self, ps: Any, fonts: Any, w: float, h: float) -> None:
+        self.ps, self.fonts, self.w, self.h = ps, fonts, w, h
+        self.sides: dict[str, list[Band]] = {s: [] for s in SIDES}
+        self.over = {s: 0.0 for s in SIDES}
+        self.twins: list[Any] = []                  # the twins' measures, in order
+
+    def overhang(self, side: str, lo: float, hi: float) -> None:
+        """Content of a band on ``side`` passing the start (``lo``) and end (``hi``) of the
+        side: left and right of a top or bottom side, above and below a left or right one."""
+        a, b = ("left", "right") if side in ("top", "bottom") else ("top", "bottom")
+        self.over[a] = max(self.over[a], lo)
+        self.over[b] = max(self.over[b], hi)
+
+    def stack(self, side: str) -> float:
+        """The size of the bands on ``side`` so far."""
+        return sum((b.size for b in self.sides[side]), 0.0)
+
+    def axis_reach(self, side: str) -> float:
+        return sum((b.size for b in self.sides[side] if b.kind in AXIS_KINDS), 0.0)
+
+    def bands(self) -> Bands:
+        s = self.sides
+        left, right, top, bottom = (self.stack(k) for k in SIDES)
+        gap = float(self.ps.plot.resolve("space_above"))
+        top = max(top, self.over["top"])
+        if gap:
+            s["top"].append(Band("space_above", top, gap))
+        return Bands((self.w, self.h), tuple(s["left"]), tuple(s["right"]), tuple(s["top"]),
+                     tuple(s["bottom"]), (max(left, self.over["left"]),
+                                          max(right, self.over["right"]), top + gap,
+                                          max(bottom, self.over["bottom"])),
+                     tuple(t.bands() for t in self.twins))
+
+
+class Placing:
+    """A plot placed with its axes at ``rect``: the parts its nodes make."""
+
+    def __init__(self, ps: Any, fonts: Any, rect: Rect, bands: Bands) -> None:
+        self.ps, self.fonts, self.rect, self.bands = ps, fonts, rect, bands
+        self.ctx = DrawContext(None, ps.plot, rect, ps.x, ps.y, ps.cycle)
+        self.offsets: dict[int, Any] = {}           # id(plot state) → its y offset run
+        self.legend_at: dict[str, float] = {}
+        self.bars: list[Any] = []
+        self.titles: list[tuple[int, TitleGeometry]] = []
+        self.main_title: TitleGeometry | None = None
+        self.lane_names: tuple[Any, ...] = ()
+
+
+class Node:
+    """A band of a side stack: :meth:`measure` gives its band (its offset is set by the
+    stack: the sizes before it, or 0 at the edge), :meth:`place` makes its part of the
+    plot's geometry from the band as measured.  ``None``: nothing on that side."""
+
+    kind = ""
+    edge = False
+
+    def measure(self, m: Measuring, side: str) -> Band | None:
+        raise NotImplementedError
+
+    def place(self, p: Placing, side: str, band: Band) -> None:
+        """Most bands are placed with the axis (or plot) they belong to."""
+
+
+# ---------------------------------------------------------------------------
+# Axes
+# ---------------------------------------------------------------------------
+
+def prepare(ps: Any, fonts: Any, w: float, h: float,
+            span: tuple[float, float] | None = None) -> None:
+    """The ticks of a plot (and its twins) for axes ``w`` × ``h``: the axis lengths fix the
+    tick count, ``snap`` and px padding, hence the labels the bands measure.  The y axes
+    run over the value lane (``span``: a twin's, its plot's)."""
+    w, h = max(w, 1.0), max(h, 1.0)
+    set_boxes(ps.plot, axes_width=w, axes_height=h)
+    if span is None:
+        span = _y_span(ps, h)
+    ps.y.span = span
+    ps.x.compute_ticks(fonts, w, True)
+    ps.y.compute_ticks(fonts, max(h - span[0] - span[1], 1.0), False)
+    for t in ps.twins:
+        prepare(t, fonts, w, h, span)
+
+
+def _y_span(ps: Any, h: float) -> tuple[float, float]:
+    """The px a plot's y axis leaves below and above its value lane (a plot with interval
+    lanes, :mod:`plot_io.genome.lanes`)."""
+    if not any(getattr(c, "lane", None) is not None for c in ps.calls):
+        return 0.0, 0.0
+    from .genome.lanes import y_span
+    return y_span(ps.plot, h)
+
+
+def _labels(state: Any, hidden: bool = False) -> list[tuple[Any, Any]]:
+    """The labelled major ticks (none when the labels are hidden, unless ``hidden``)."""
+    return [(t, t.label) for t in state.ticks if t.major and t.label is not None
+            and (hidden or not state.hide_labels)]
+
+
+def _anchor(state: Any, far: bool) -> tuple[str, str]:
+    """How an x axis' tick label is anchored at its tick: rotated labels by the corner
+    nearest the axis, so that they extend away from it (down-left for a positive angle
+    under the axes, down-right for a negative one; mirrored above)."""
+    if not state.rotation:
+        return "center", "bottom" if far else "top"
+    up = state.rotation > 0
+    if far:
+        return ("left" if up else "right"), "bottom"
+    return ("right" if up else "left"), "top"
+
+
+class Ticks(Node):
+    def __init__(self, state: Any) -> None:
+        self.state, self.kind = state, f"{state.axis.role}_ticks"
+
+    def measure(self, m: Measuring, side: str) -> Band:
+        out, _ = self.state.tick_out()
+        off = self.state.axis.resolve("spine_offset")
+        return Band(self.kind, 0.0, out + off, pad=off, extent=out)
+
+
+class TickLabels(Node):
+    def __init__(self, state: Any) -> None:
+        self.state, self.kind = state, f"{state.axis.role}_tick_labels"
+
+    def measure(self, m: Measuring, side: str) -> Band | None:
+        state = self.state
+        horizontal = state.axis.role == "x"
+        got = tick_label_extent(state, m.fonts, m.w if horizontal else m.h, horizontal,
+                                state.on_far_side())
+        if got is None:
+            return None
+        across, lo, hi = got
+        if state.crowded is not None and not state.hide_labels:
+            warn(f"{state.axis.role} axis: its tick labels do not fit along it, even at "
+                 f"{state.crowded:g} px; one is drawn (lengthen the axis or set fewer ticks)",
+                 key=("tick labels", state.axis.role))
+        pad = state.axis.resolve("tick_pad")
+        return Band(self.kind, 0.0, pad + across, lo, hi, pad, across)
+
+
+def tick_label_extent(state: Any, fonts: Any, length: float, horizontal: bool, far: bool
+                      ) -> tuple[float, float, float] | None:
+    """The tick labels of an axis (or colorbar) ``length`` px long, measured as placed
+    (:func:`tick_label_runs` at the axis' edge): their size across it and how far they pass
+    its start and end; ``None`` without labels.  ``horizontal``: labels side by side;
+    ``far``: on the top (right) side."""
+    mapper = state.mapper(0.0, length) if horizontal else state.mapper(length, 0.0)
+    quads = [q for q in (run_quad(fonts, r) for r in
+                         tick_label_runs(state, fonts, mapper, 0.0, horizontal, far))
+             if q is not None]
+    if not quads:
+        return None
+    along = [p[0 if horizontal else 1] for q in quads for p in q]
+    sign = -1.0 if far == horizontal else 1.0       # away from the axes: up, or left
+    away = [sign * p[1 if horizontal else 0] for q in quads for p in q]
+    return max(max(away), 0.0), max(0.0, -min(along)), max(0.0, max(along) - length)
+
+
+def _moved(r: Any, dx: float, dy: float) -> Any:
+    """A run (or tuple of runs) moved by ``(dx, dy)``."""
+    if isinstance(r, tuple):
+        return tuple(_moved(x, dx, dy) for x in r)
+    return None if r is None else dataclasses.replace(r, x=r.x + dx, y=r.y + dy)
+
+
+def _bounds(fonts: Any, r: Any) -> tuple[float, float, float, float] | None:
+    q = run_quad(fonts, r)
+    if q is None:
+        return None
+    xs, ys = [p[0] for p in q], [p[1] for p in q]
+    return min(xs), min(ys), max(xs), max(ys)
+
+
+def tick_label_runs(state: Any, fonts: Any, mapper: Any, at: float, horizontal: bool,
+                    far: bool, hidden: bool = False) -> list[Any]:
+    """The tick labels of an axis (or colorbar) placed ``at`` across it (the edge of their
+    box nearest it), each at its tick along it (``mapper``): an x label anchored at its
+    tick (a rotated one by its corner nearest the axis), a y label by the middle of its
+    box's edge nearest the axis (unrotated: of its cap height; rotated: moved along the
+    axis to stay within its ends when it fits).  ``hidden``: hidden labels too (an inner
+    plot's, fitted for the plots sharing its ticks)."""
+    font = state.tick_font()
+    ha, va = _anchor(state, far)
+    runs = []
+    for t, lab in _labels(state, hidden):
+        p = mapper(t.value)
+        if horizontal:
+            runs.append(lines_run(fonts, lab, p, at, font, ha, va, state.rotation))
+        elif not state.rotation:
+            runs.append(lines_run(fonts, lab, at, p, font, "left" if far else "right",
+                                  "center"))
+        else:
+            r = lines_run(fonts, lab, 0.0, 0.0, font, "center", "center", state.rotation)
+            b = _bounds(fonts, r)
+            if b is None:
+                continue
+            lo, hi = sorted((mapper.position(mapper.flo), mapper.position(mapper.fhi)))
+            half = (b[3] - b[1]) / 2           # kept within the axes' length when it fits
+            mid = min(max(p, lo + half), hi - half) if 2 * half <= hi - lo else p
+            dx = at - b[0] if far else at - b[2]
+            runs.append(_moved(r, dx, mid - (b[1] + b[3]) / 2))
+    return runs
+
+
+def scale_bar_on(state: Any) -> bool:
+    """Whether an axis state draws scale bars (:func:`plot_io.genome.scale.scale_bar_on`)."""
+    if not state.genome:
+        return False
+    from .genome.scale import scale_bar_on as on
+    return on(state)
+
+
+class ScaleBar(Node):
+    """The scale bars of a genome x axis (:func:`plot_io.genome.scale.scale_bars`), in
+    place of its ticks and tick labels: each bar with its length written left of it, the
+    bar across the middle of the text, ``tick_pad`` from the axes (past the spine)."""
+
+    def __init__(self, state: Any) -> None:
+        self.state, self.kind = state, f"{state.axis.role}_scale_bar"
+
+    def measure(self, m: Measuring, side: str) -> Band | None:
+        st = self.state
+        bars = scale_bar_runs(st, m.fonts, st.mapper(0.0, m.w), 0.0)
+        if not bars:
+            return None
+        across = max(max(r[4] for r in bars), float(st.axis.resolve("tick_width")))
+        lo = max(0.0, max(-r[3] for r in bars))          # texts past the axes' left end
+        pad = st.axis.resolve("tick_pad") + st.axis.resolve("spine_offset")
+        return Band(self.kind, 0.0, pad + across, lo, 0.0, pad, across)
+
+
+def scale_bar_runs(state: Any, fonts: Any, mapper: Any, mid: float
+                   ) -> list[tuple[Segment, Any, float, float, float]]:
+    """The scale bars of an axis state with the bar across ``mid``: ``(bar, text run,
+    bar left, text left, text height)`` (none for an inner plot of a shared group, whose
+    labels are hidden)."""
+    from .genome.scale import scale_bars
+    if state.hide_labels:
+        return []
+    font = state.tick_font()
+    gap = 0.4 * font.size
+    out = []
+    room = lambda text: gap + lines_box(fonts, text, font)[0]    # noqa: E731
+    for a, b, text in scale_bars(state, mapper, room):
+        w, h = lines_box(fonts, text, font)
+        r = lines_run(fonts, text, a - gap, mid, font, "right", "center")
+        out.append(((a, mid, b, mid), r, a, a - gap - w, h))
+    return out
+
+
+class AxisLabel(Node):
+    """The axis label's row (an x axis: the ×10ᵏ offset at its end too, or in a row of
+    its own between the tick labels and the label when the label would reach it)."""
+
+    def __init__(self, state: Any) -> None:
+        self.state, self.kind = state, f"{state.axis.role}_label"
+
+    def measure(self, m: Measuring, side: str) -> Band | None:
+        st = self.state
+        horizontal = st.axis.role == "x"
+        length = m.w if horizontal else m.h
+        other = "y" if horizontal else "x"     # the other axis' ticks and labels beside
+        reach = sum(b.size for s in SIDES for b in m.sides[s]
+                    if b.kind in (f"{other}_ticks", f"{other}_tick_labels", f"{other}_mirror"))
+        b = st.title_block = _label_block(st, m.fonts, length + reach)
+        row = b.height if b is not None else 0.0
+        st.offset_row = 0.0
+        if horizontal:
+            offset = None if st.hide_labels else offset_content(st)
+            if offset is not None:
+                ow, oh = box(m.fonts, offset, st.tick_font(), 0.0)
+                gap = st.axis.resolve("tick_label_gap")
+                if b is not None and (length + b.width) / 2 + gap > length - ow:
+                    st.offset_row = oh               # beside the label it would meet: its
+                    row += oh                        # own row, nearer the axes
+                else:
+                    row = max(row, oh)
+        if b is not None and b.width > length:       # a label longer than the axes
+            m.overhang(side, (b.width - length) / 2, (b.width - length) / 2)
+        if not row:
+            return None
+        pad = st.axis.resolve("label_pad")
+        return Band(self.kind, 0.0, pad + row, pad=pad, extent=row)
+
+
+class Mirror(Node):
+    """An axis' ticks mirrored on the other side of the axes."""
+
+    edge = True
+
+    def __init__(self, state: Any) -> None:
+        self.state, self.kind = state, f"{state.axis.role}_mirror"
+
+    def measure(self, m: Measuring, side: str) -> Band | None:
+        st = self.state
+        if not (st.axis.resolve("mirror") and st.ticks) or scale_bar_on(st):
+            return None
+        reach = st.tick_out()[0] + st.axis.resolve("spine_offset")
+        return Band(self.kind, 0.0, reach) if reach else None
+
+
+def _label_block(state: Any, fonts: Any, room: float) -> Block | None:
+    """The axis label's lines (a y label: only beside the axis, ``label_position="axis"``),
+    a string wrapped at spaces to ``room`` px: the plot's box along the axis, without the
+    axis labels.  Over several regions, each region's label is wrapped to its share; one
+    wider than its share is the chromosome alone, and labels that would meet are thinned
+    as tick labels are."""
+    if state.hide_labels:
+        return None
+    if state.axis.role == "y" and state.axis.resolve("label_position") != "axis":
+        return None
+    font = state.label_font()
+    if state.segments is not None:            # a label per region, wrapped to its share
+        from .genome.scale import segment_labels
+        total = state.segments.total or 1.0
+        gap = state.axis.resolve("tick_label_gap")
+        state.segment_titles = []
+        end = -math.inf
+        for c, seg in segment_labels(state):
+            share = room * (seg.u1 - seg.u0) / total
+            b = block(fonts, wrap(fonts, c, font, share), font)
+            if b.width > share:               # the chromosome alone
+                b = block(fonts, seg.region.chr, font)
+            mid = room * (seg.u0 + seg.u1) / 2 / total
+            if mid - b.width / 2 < max(0.0, end + gap) or mid + b.width / 2 > room:
+                continue                      # thinned, as tick labels
+            end = mid + b.width / 2
+            state.segment_titles.append((b, seg))
+        return max((b for b, _ in state.segment_titles), key=lambda b: b.height,
+                   default=None)
+    content = label_content(state)
+    if content is None:
+        return None
+    return block(fonts, wrap(fonts, content, font, room), font)
+
+
+class LaneNames(Node):
+    """The names of a plot's interval lanes (:func:`plot_io.genome.lanes.names`) left of
+    the axes, each right-aligned and centred on its lane, in the y axis' tick font."""
+
+    kind = "lane_names"
+
+    def __init__(self, ps: Any) -> None:
+        self.ps = ps
+
+    def _names(self, fonts: Any, h: float) -> list[tuple[Any, float, float, float]]:
+        from .genome.lanes import names
+        font = self.ps.y.tick_font()
+        out = []
+        for name, top, bottom in names(self.ps.plot, h):
+            bw, bh = lines_box(fonts, name, font)
+            out.append((name, (top + bottom) / 2, bw, bh))
+        return out
+
+    def measure(self, m: Measuring, side: str) -> Band | None:
+        got = self._names(m.fonts, m.h)
+        if not got:
+            return None
+        across = max(bw for _, _, bw, _ in got)
+        lo = max(max(0.0, bh / 2 - mid) for _, mid, _, bh in got)        # past the top
+        hi = max(max(0.0, mid + bh / 2 - m.h) for _, mid, _, bh in got)   # past the bottom
+        pad = self.ps.y.axis.resolve("tick_pad")
+        return Band(self.kind, 0.0, pad + across, lo, hi, pad, across)
+
+    def place(self, p: Placing, side: str, band: Band) -> None:
+        x0, y0, _, y1 = p.rect
+        font = self.ps.y.tick_font()
+        right = x0 - band.offset - band.pad
+        p.lane_names = tuple(lines_run(p.fonts, name, right, y0 + mid, font, "right", "center")
+                             for name, mid, _, _ in self._names(p.fonts, y1 - y0))
+
+
+class Twin(Node):
+    """A twin plot's axes, drawn at the axes edge: on each side, the twin's own stack; its
+    content passing the side's ends counts as overhang only."""
+
+    kind = "twin"
+    edge = True
+
+    def __init__(self, twin: Any) -> None:
+        self.twin = twin
+        self.m: Measuring | None = None
+        twin.shift = {}                 # per side: the earlier twins' bands it is past
+
+    def measure(self, m: Measuring, side: str) -> Band:
+        if self.m is None:
+            self.m = _measure(self.twin, m.fonts, m.w, m.h, twin=True)
+            m.twins.append(self.m)
+        t = self.m
+        size = t.stack(side)
+        lo = hi = 0.0
+        if side == ("right" if self.twin.plot.twin_of[1] == "y" else "bottom"):
+            a, b = ("top", "bottom") if side == "right" else ("left", "right")
+            lo, hi = t.over[a], t.over[b]
+        return Band("twin", 0.0, size, lo, hi)
+
+
+class Offset(Node):
+    """The ×10ᵏ offset of a y axis (the plot's, then each twin's), above the axes and what
+    is on top of them, beside its axis' side."""
+
+    def __init__(self, state: Any, own: bool) -> None:
+        self.state, self.own = state, own
+        self.kind = "y_offset" if own else "twin_offset"
+
+    def content(self) -> Any:
+        y = self.state.y
+        if not (self.state.axes_on and self.state.shows("y")) or y.hide_labels:
+            return None
+        return offset_content(y)
+
+    def measure(self, m: Measuring, side: str) -> Band | None:
+        oc = self.content()
+        if oc is None:
+            return None
+        y = self.state.y
+        ow, oh = box(m.fonts, oc, y.tick_font(), 0.0)
+        pad = self.state.plot.y_axis.resolve("tick_pad")
+        far = y.on_far_side()
+        bands = m.sides if self.own else _twin_sides(m, self.state)
+        yw = sum(b.size for b in bands["right" if far else "left"] if b.kind.startswith("y_"))
+        return Band(self.kind, 0.0, pad + oh, 0.0 if far else ow - yw,
+                    ow - yw if far else 0.0, pad, oh)
+
+    def place(self, p: Placing, side: str, band: Band) -> None:
+        x0, y0, x1, _ = p.rect
+        y = self.state.y
+        right = y.on_far_side()
+        off = self.state.plot.y_axis.resolve("spine_offset") + getattr(
+            self.state, "shift", {}).get("right" if right else "left", 0.0)
+        base = x1 + off if right else x0 - off
+        p.offsets[id(self.state)] = run(p.fonts, self.content(), base,
+                                        y0 - band.offset - band.pad, y.tick_font(),
+                                        "right" if right else "left", "bottom")
+
+
+def _twin_sides(m: Measuring, twin: Any) -> dict[str, list[Band]]:
+    for t in m.twins:
+        if t.ps is twin:
+            return t.sides
+    return {s: [] for s in SIDES}
+
+
+class Labels(Node):
+    """Labels a call draws past the axes (pie names): no band, only their overhang."""
+
+    kind = "labels"
+    edge = True
+
+    def __init__(self, call: Any) -> None:
+        self.call = call
+
+    def measure(self, m: Measuring, side: str) -> Band:
+        lo, hi = self.call.overhang(m.fonts, m.w, m.h)
+        return Band("labels", 0.0, 0.0, lo, hi)
+
+
+class Reach(Node):
+    """Text decorations drawn past the axes (``text``, ``annotate``): the margin grows to
+    hold them beyond what is already on the side; the text itself is never moved."""
+
+    kind = "text"
+
+    def __init__(self, texts: list[Any]) -> None:
+        self.texts = texts
+
+    def measure(self, m: Measuring, side: str) -> Band | None:
+        ctx = DrawContext(None, m.ps.plot, (0.0, 0.0, m.w, m.h), m.ps.x, m.ps.y,
+                          m.ps.cycle)
+        k = SIDES.index(side)
+        need = max((d.reach(m.fonts, ctx)[k] for d in self.texts), default=0.0)
+        size = need - m.stack(side)
+        return Band("text", 0.0, size) if size > 0 else None
+
+
+# ---------------------------------------------------------------------------
+# Legend and colorbars
+# ---------------------------------------------------------------------------
+
+class Legend(Node):
+    """The plot's legend outside its axes (measured on every side: an inside legend takes
+    no band)."""
+
+    kind = "legend"
+
+    def __init__(self) -> None:
+        self.size: tuple[str, float, float] | None = None
+
+    def measure(self, m: Measuring, side: str) -> Band | None:
+        ps = m.ps
+        if self.size is None:
+            leg = ps.legend
+            size = leg.measure(m.fonts, m.w, m.h)   # inside: wrapped within the axes, or moved
+            self.size = (leg.position(), *size)
+        pos, lw, lh = self.size
+        lg = ps.plot.legend
+        if pos != "outside_" + side:
+            return None
+        if side in ("right", "left") and lw:
+            pad = lg.resolve("pad", of=m.w)
+            lo, hi = _overhang(lh, m.h, ps.legend.align())
+            return Band("legend", 0.0, pad + lw, lo, hi, pad, lw)
+        if side in ("top", "bottom") and lh:
+            pad = lg.resolve("pad", of=m.h)
+            lo, hi = _overhang(lw, m.w, ps.legend.align())   # longer than the axes
+            return Band("legend", 0.0, pad + lh, lo, hi, pad, lh)
+        return None
+
+    def place(self, p: Placing, side: str, band: Band) -> None:
+        p.legend_at[side] = band.offset
+
+
+def _overhang(length: float, axes: float, align: float) -> tuple[float, float]:
+    """How far a legend ``length`` long, aligned at ``align`` (0 start, 0.5 centre, 1 end)
+    along axes ``axes`` long, reaches past their start and their end."""
+    if length <= axes:
+        return 0.0, 0.0
+    lo = 0.0 if align == 0.0 else length - axes if align == 1.0 else (length - axes) / 2
+    return lo, length - axes - lo
+
+
+def _line_gap(line: list[Any]) -> float:
+    """Gap between keys on one line: twice the first one's ``label_gap``."""
+    return 2.0 * line[0].cb.resolve("label_gap")
+
+
+def line_size(fonts: Any, line: list[Any], w: float, h: float) -> tuple[float, float]:
+    """A line of attached colorbars: how far its keys' common middle line is from where
+    it starts, and its size across (a single colorbar: its own band)."""
+    if len(line) == 1:
+        return 0.0, line[0].measure(fonts, w, h)
+    reach = [b.key_reach(fonts, w, h) for b in line]
+    mid = max(n for n, _ in reach)
+    return mid, mid + max(f for _, f in reach)
+
+
+def bar_lines(fonts: Any, bars: list[Any], w: float, h: float) -> list[list[Any]]:
+    """The attached colorbars in lines, in order: a horizontal key on top or bottom joins
+    the line of the keys before it on its side when the line still fits the axes width
+    (a color key and a size key side by side); every other colorbar is a line of its
+    own."""
+    lines: list[list[Any]] = []
+    last: dict[str, list[Any]] = {}
+    for b in bars:
+        line = last.get(b.side)
+        if line is not None and b.key and not b.vertical and b.side in ("top", "bottom") \
+                and all(x.key and not x.vertical for x in line):
+            widths = [x.key_width(fonts, w, h) for x in [*line, b]]
+            if sum(widths) + _line_gap(line) * len(line) <= w:
+                line.append(b)
+                continue
+        lines.append([b])
+        last[b.side] = lines[-1]
+    return lines
+
+
+class Colorbars(Node):
+    """A line of attached colorbars (one bar, or keys side by side)."""
+
+    kind = "colorbar"
+
+    def __init__(self, line: list[Any]) -> None:
+        self.line = line
+
+    def measure(self, m: Measuring, side: str) -> Band:
+        bar = self.line[0]
+        extent = line_size(m.fonts, self.line, m.w, m.h)[1]
+        lo, hi = bar.over if len(self.line) == 1 else (0.0, 0.0)
+        return Band("colorbar", 0.0, extent, lo, hi, bar.pad, extent - bar.pad)
+
+    def place(self, p: Placing, side: str, band: Band) -> None:
+        fonts, rect, line = p.fonts, p.rect, self.line
+        if len(line) == 1:
+            p.bars.append(line[0].place(fonts, rect, offsets={side: band.offset}))
+            return
+        w, h = rect[2] - rect[0], rect[3] - rect[1]
+        widths = [b.key_width(fonts, w, h) for b in line]
+        gap = _line_gap(line)
+        mid = line_size(fonts, line, w, h)[0]
+        at = line[0]._start(rect[0], rect[2], sum(widths) + gap * (len(line) - 1))
+        for b, bw in zip(line, widths):
+            p.bars.append(b.place(fonts, rect, offsets={side: band.offset}, span=(at, at + bw),
+                                  line=mid))
+            at += bw + gap
+
+
+# ---------------------------------------------------------------------------
+# Titles
+# ---------------------------------------------------------------------------
+
+def plot_titles(plot: Any) -> dict[str, list[Any]]:
+    """The plot's titles with text, by side, each side's from the axes outward: by
+    ``order`` (unset: the main title, then the others in creation order)."""
+    out: dict[str, list[Any]] = {}
+    ranked = []
+    for k, t in enumerate(plot.titles):
+        if t.resolve("text") is None:
+            continue
+        order = t.resolve("order")
+        ranked.append((k if order is None else order, k, t))
+    for _, _, t in sorted(ranked, key=lambda r: (r[0], r[1])):
+        out.setdefault(t.resolve("side"), []).append(t)
+    return out
+
+
+def title_font(t: Any) -> Any:
+    """The font of title ``t``."""
+    from .text import font_of
+    return font_of(t, t.resolve("font_size"), t.resolve("font_weight"),
+                   t.resolve("font_style"), t.resolve("color"))
+
+
+def _across(side: str, rotation: float) -> bool:
+    """Whether the lines of a title on ``side`` run along it (their height across it)."""
+    return (rotation == 0) == (side in ("top", "bottom"))
+
+
+def title_need(t: Any, b: Any, side: str) -> tuple[float, float]:
+    """The band a title takes on its side (its pad, its text across the side, its rule)
+    and the text's extent across the side."""
+    pad = t.resolve("pad")
+    if _across(side, rotation_of(t)):
+        n = len(b.lines)
+        need = pad + b.ascents[0] + (n - 1) * b.pitch + b.descents[-1]
+        extent = b.height
+    else:
+        need = pad + b.width
+        extent = b.width
+    return need + rule_extent(t), extent
+
+
+def _starts_high(side: str, rotation: float) -> bool:
+    """Whether ``start`` is the high end of the side's coordinate (the bottom of a left
+    or right side, for text reading upward)."""
+    return side in ("left", "right") and rotation == 90
+
+
+def _title_overhang(t: Any, b: Any, side: str, w: float, h: float,
+                    used: tuple[float, float, float, float]) -> tuple[float, float]:
+    """How far a title passes the start and the end of the axes side (left and right of a
+    top or bottom side, above and below a left or right side): an end of its span it is
+    aligned to lies within the plot's bands, so it passes only the other one."""
+    rotation = rotation_of(t)
+    size = b.width if _across(side, rotation) else b.height
+    plot_span = t.resolve("over") == "plot"
+    if side in ("top", "bottom"):
+        length, s0, s1 = w, (-used[0] if plot_span else 0.0), w
+    else:
+        length, s0, s1 = h, 0.0, h + (used[3] if plot_span else 0.0)
+    high = _starts_high(side, rotation)
+    if high:                               # measured from the bottom up, then swapped
+        s0, s1 = length - s1, length - s0
+    a = along(t)                           # aligned to an end of its span (within the
+    if a == "start":                       # plot's bands), it passes only the other one
+        lo, hi = 0.0, size - (length - s0)
+    elif a == "end":
+        lo, hi = size - s1, 0.0
+    else:
+        lo, hi = (size - (s0 + s1)) / 2, (size - (2 * length - s0 - s1)) / 2
+    return (hi, lo) if high else (lo, hi)
+
+
+class Title(Node):
+    kind = "title"
+
+    def __init__(self, title: Any) -> None:
+        self.title = title
+
+    def _block(self, fonts: Any) -> tuple[Block, Any]:
+        font = title_font(self.title)
+        return block(fonts, self.title.resolve("text"), font), font
+
+    def measure(self, m: Measuring, side: str) -> Band:
+        t = self.title
+        b, _ = self._block(m.fonts)
+        need, across = title_need(t, b, side)
+        left, right, top, bottom = (m.axis_reach(s) for s in SIDES)
+        lo, hi = _title_overhang(t, b, side, m.w, m.h, (left, right, top, bottom))
+        pad = t.resolve("pad")
+        if lo > 0 or hi > 0:            # past the side's ends: past what overhangs them too
+            pad += max(0.0, m.over[side] - m.stack(side))
+        return Band("title", 0.0, need - t.resolve("pad") + pad, lo, hi, pad, across)
+
+    def place(self, p: Placing, side: str, band: Band) -> None:
+        t = self.title
+        x0, y0, x1, y1 = p.rect
+        b, font = self._block(p.fonts)
+        need = title_need(t, b, side)[0]
+        pad = t.resolve("pad")
+        inner = rule_inside(t)
+        span = t.resolve("over") == "plot"
+        if side in ("top", "bottom"):
+            s0, s1 = (x0 - p.bands.extent("left", AXIS_KINDS) if span else x0), x1
+        else:
+            s0, s1 = y0, (y1 + p.bands.extent("bottom", AXIS_KINDS) if span else y1)
+        reach = band.offset + band.pad + inner
+        near = {"top": y0 - reach, "bottom": y1 + reach, "left": x0 - reach,
+                "right": x1 + reach}[side]
+        runs, box_ = title_runs(p.fonts, b, font, side, rotation_of(t), along(t), near, s0, s1)
+        rule = rule_rect(t, side, near, need - pad - rule_extent(t), s0, s1)
+        lane = sum(1 for k in p.bands.side(side) if k.kind == "title" and k.offset < band.offset)
+        g = TitleGeometry(t, side, lane, box_, runs, rule)
+        if t is p.ps.plot.title:
+            p.main_title = g
+        else:
+            p.titles.append((p.ps.plot.titles.index(t), g))
+
+
+_HA = {"start": "left", "center": "center", "end": "right"}
+
+
+def title_runs(fonts: Any, b: Block, font: Any, side: str, rotation: float, align: str,
+               near: float, s0: float, s1: float) -> tuple[tuple[Any, ...], Rect]:
+    """The runs of a title's lines and its box: the block's edge facing what the title
+    covers at ``near`` (across the side), aligned within ``s0``–``s1`` along it."""
+    out = []
+    if _across(side, rotation) and side in ("top", "bottom"):        # lines along x
+        ha = _HA[align]
+        x = {"start": s0, "center": (s0 + s1) / 2, "end": s1}[align]
+        for k, ln in enumerate(b.lines):
+            if side == "top":
+                out.append(run(fonts, ln, x, near - b.bottom(k), font, ha, "bottom"))
+            else:
+                out.append(run(fonts, ln, x, near + b.top(k), font, ha, "top"))
+        bx = x - {"left": 0.0, "center": b.width / 2, "right": b.width}[ha]
+        by = near - b.height if side == "top" else near
+        return tuple(out), (bx, by, b.width, b.height)
+    if _across(side, rotation):                                       # lines along y
+        high = _starts_high(side, rotation)
+        ha = _HA[align]
+        start, end = (s1, s0) if high else (s0, s1)
+        y = {"start": start, "center": (s0 + s1) / 2, "end": end}[align]
+        bottom_faces = (side == "left") == (rotation == 90)
+        sign = -1.0 if side == "left" else 1.0
+        for k, ln in enumerate(b.lines):
+            if bottom_faces:
+                out.append(run(fonts, ln, near + sign * b.bottom(k), y, font, ha, "bottom",
+                               rotation))
+            else:
+                out.append(run(fonts, ln, near + sign * b.top(k), y, font, ha, "top",
+                               rotation))
+        reach = {"left": 0.0, "center": b.width / 2, "right": b.width}[ha]
+        by = (y - b.width + reach) if high else (y - reach)
+        bx = near - b.height if side == "left" else near
+        return tuple(out), (bx, by, b.height, b.width)
+    if side in ("left", "right"):                       # horizontal lines beside the side
+        by = {"start": s0, "center": (s0 + s1 - b.height) / 2, "end": s1 - b.height}[align]
+        ha = "right" if side == "left" else "left"
+        for k, ln in enumerate(b.lines):
+            out.append(run(fonts, ln, near, by + b.top(k), font, ha, "top"))
+        bx = near - b.width if side == "left" else near
+        return tuple(out), (bx, by, b.width, b.height)
+    # vertical lines on top or bottom: each line reads across the side, from ``near``
+    bx = {"start": s0, "center": (s0 + s1 - b.height) / 2, "end": s1 - b.height}[align]
+    reads_away = (side == "top") == (rotation == 90)
+    ha = "left" if reads_away else "right"
+    for k, ln in enumerate(b.lines):
+        depth = b.height - b.bottom(k)              # line k's bottom from the block's top
+        x = bx + depth if rotation == 90 else bx + b.height - depth
+        out.append(run(fonts, ln, x, near, font, ha, "bottom", rotation))
+    by = near - b.width if side == "top" else near
+    return tuple(out), (bx, by, b.height, b.width)
+
+
+# ---------------------------------------------------------------------------
+# The tree: declared once, measured, placed
+# ---------------------------------------------------------------------------
+
+def nodes(ps: Any, fonts: Any, w: float, h: float, twin: bool = False
+          ) -> dict[str, list[Node]]:
+    """The nodes of each side of plot ``ps``'s axes ``w`` × ``h``, from the axes outward.
+    A twin's y offset is a node of the plot it is a twin of (``twin``)."""
+    sides: dict[str, list[Node]] = {s: [] for s in SIDES}
+    for role, st in (("x", ps.x), ("y", ps.y)):
+        if not (ps.axes_on and ps.shows(role)):
+            continue
+        near, far = ("bottom", "top") if role == "x" else ("left", "right")
+        side = far if st.on_far_side() else near
+        sides[side] += ([ScaleBar(st)] if scale_bar_on(st) else [Ticks(st), TickLabels(st)]) \
+            + [AxisLabel(st)]
+        sides[_OPPOSITE[side]].append(Mirror(st))
+    if any(getattr(c, "lane", None) is not None for c in ps.calls):
+        sides["left"].append(LaneNames(ps))
+    for t in ps.twins:
+        node = Twin(t)
+        for s in (("left", "right") if t.plot.twin_of[1] == "y" else ("top", "bottom")):
+            sides[s].append(node)
+    if not twin:
+        sides["top"] += [Offset(ps, True), *(Offset(t, False) for t in ps.twins)]
+    for call in ps.calls:
+        if call.overhang is not None:
+            sides["bottom"].append(Labels(call))
+    texts = [d for d in ps.decorations if hasattr(d, "reach") and d.counts()]
+    if texts:
+        reach = Reach(texts)
+        for s in SIDES:
+            sides[s].append(reach)
+    legend = Legend()
+    for s in SIDES:
+        sides[s].append(legend)
+    for line in bar_lines(fonts, [b for b in ps.bars if b.inside is None], w, h):
+        sides[line[0].side].append(Colorbars(line))
+    for side, on_side in plot_titles(ps.plot).items():
+        sides[side] += [Title(t) for t in on_side]
+    return sides
+
+
+#: The order in which node kinds are measured across the sides: the axes of every side
+#: before what is past them (a title spanning the plot covers the axes' bands beside it).
+_RANK = (Ticks, TickLabels, ScaleBar, Mirror, AxisLabel, LaneNames, Twin, Offset, Labels, Reach, Legend,
+         Colorbars, Title)
+
+
+def _measure(ps: Any, fonts: Any, w: float, h: float, twin: bool = False) -> Measuring:
+    """Every node of the plot's tree measured and stacked (on one side the rank order is
+    the declared order); the nodes with their bands are kept on the state (``tree``) for
+    :func:`place_plot`."""
+    m = Measuring(ps, fonts, max(w, 1.0), max(h, 1.0))
+    tree = nodes(ps, fonts, m.w, m.h, twin)
+    placed = []
+    for cls in _RANK:
+        for side in SIDES:
+            for node in tree[side]:
+                if type(node) is not cls:
+                    continue
+                b = node.measure(m, side)
+                if b is None:
+                    continue
+                if isinstance(node, Twin):      # past the earlier twins on that side
+                    at = sum((t.size for t in m.sides[side] if t.kind == "twin"), 0.0)
+                    node.twin.shift[side] = at
+                    b = dataclasses.replace(b, offset=at)
+                else:
+                    b = dataclasses.replace(b, offset=0.0 if node.edge else m.stack(side))
+                m.sides[side].append(b)
+                m.overhang(side, b.lo, b.hi)
+                placed.append((side, node, b))
+    ps.tree = placed
+    return m
+
+
+def measure(ps: Any, fonts: Any, w: float, h: float) -> Bands:
+    """The bands around the axes ``w`` × ``h`` of a plot whose ticks are prepared for that
+    size (:func:`prepare`): its axes', its twins', its title's, its legend's and its
+    colorbars' (which keep their measured sizes on their states)."""
+    return _measure(ps, fonts, w, h).bands()
+
+
+# ---------------------------------------------------------------------------
+# Placing: geometry records from the bands as measured
+# ---------------------------------------------------------------------------
+
+def _tick_marks(state: Any, mapper: Any, horizontal: bool, base: float,
+                flip: bool = False) -> tuple[Segment, ...]:
+    """Tick mark segments; ``base`` is the axis line coordinate (y for x axes, x for y
+    axes); ``flip``: on the opposite side of the axes (``mirror``)."""
+    axis = state.axis
+    out, inside = state.tick_out(marks=True)
+    if not state.ticks or not (out or inside):
+        return ()
+    if flip:
+        out, inside = -out, -inside
+    ml = axis.resolve("minor_tick_length") * (-1.0 if flip else 1.0)
+    m_out, m_in = (ml if out else 0.0), (ml if inside else 0.0)
+    marks = []
+    for t in state.ticks:
+        p = mapper(t.value)
+        o, i = (out, inside) if t.major else (m_out, m_in)
+        if horizontal:
+            marks.append((p, base - i, p, base + o))
+        else:
+            marks.append((base + i, p, base - o, p))
+    return tuple(marks)
+
+
+def _band(bands: Bands, side: str, kind: str) -> Band | None:
+    return next((b for b in bands.side(side) if b.kind == kind), None)
+
+
+def _axis(ps: Any, fonts: Any, ctx: DrawContext, bands: Bands, role: str,
+          shift: float = 0.0) -> AxisGeometry:
+    """Axis ``role`` placed from its bands: tick marks (and the mirrored ones), tick
+    labels, the label (and an x axis' ×10ᵏ offset at its end), each at its band's offset
+    from the axes edge; ``shift``: the axis line moved out by that much (a twin past
+    earlier twins, whose ``bands`` are shifted with it)."""
+    horizontal = role == "x"
+    if not (ps.axes_on and ps.shows(role)):
+        return AxisGeometry(role)
+    axis = ps.plot.x_axis if horizontal else ps.plot.y_axis
+    x0, y0, x1, y1 = ctx.rect
+    state = ps.x if horizontal else ps.y
+    far = state.on_far_side()
+    side = ("top" if far else "bottom") if horizontal else ("right" if far else "left")
+    sign = -1.0 if side in ("top", "left") else 1.0          # away from the axes
+    off = axis.resolve("spine_offset")
+    lo_edge, hi_edge = (y0, y1) if horizontal else (x0, x1)
+    edge, other = (lo_edge, hi_edge) if side in ("top", "left") else (hi_edge, lo_edge)
+    mapper = ctx.xmap if horizontal else ctx.ymap
+    font = state.tick_font()
+    runs: list[Any] = []
+    sb = _band(bands, side, f"{role}_scale_bar")
+    if scale_bar_on(state):
+        groups: list[Any] = []
+        if sb is not None:
+            mid = edge + sign * (sb.offset + sb.pad + sb.extent / 2)
+            bars = scale_bar_runs(state, fonts, mapper, mid)
+            groups.append(tuple(bar for bar, _, _, _, _ in bars))
+            runs = [r for _, r, _, _, _ in bars]
+    else:
+        groups = [_tick_marks(state, mapper, horizontal, edge + sign * (off + shift),
+                              flip=far)]
+        if axis.resolve("mirror"):
+            groups.append(_tick_marks(state, mapper, horizontal, other - sign * off,
+                                      flip=not far))
+    lb = _band(bands, side, f"{role}_tick_labels")
+    if lb is not None:
+        runs = tick_label_runs(state, fonts, mapper, edge + sign * (lb.offset + lb.pad),
+                               horizontal, far)
+    title: Any = None
+    offset = None
+    tb = _band(bands, side, f"{role}_label")
+    if tb is not None:
+        at = edge + sign * (tb.offset + tb.pad)
+        oc = None if not horizontal or state.hide_labels else offset_content(state)
+        if oc is not None:
+            offset = run(fonts, oc, x1, at, font, "right", "bottom" if far else "top")
+            at += sign * state.offset_row
+        b = state.title_block
+        if b is not None:
+            s0, s1 = (x0, x1) if horizontal else (y0 + state.span[1], y1 - state.span[0])
+            parts = [(b, s0, s1)]
+            if state.segments is not None:
+                parts = [(sb, mapper(seg.u0), mapper(seg.u1))
+                         for sb, seg in state.segment_titles]
+            got = tuple(r for pb, p0, p1 in parts
+                        for r in title_runs(fonts, pb, state.label_font(), side,
+                                            0.0 if horizontal else 90.0, "center", at,
+                                            p0, p1)[0])
+            title = got[0] if len(got) == 1 else got
+    return AxisGeometry(role, True, tuple(g for g in groups if g), tuple(runs), title, offset)
+
+
+def _axis_shift(state: Any, role: str, shift: dict[str, float]) -> float:
+    """How far a twin's axis ``role`` is moved out on its side (``shift``: per side)."""
+    far = state.on_far_side()
+    side = ("top" if far else "bottom") if role == "x" else ("right" if far else "left")
+    return shift.get(side, 0.0)
+
+
+def _clear_corner(fonts: Any, y: AxisGeometry, xs: list[AxisGeometry]) -> AxisGeometry:
+    """A y axis without its tick labels that meet an x axis' (the plot's or a twin's: an
+    end label at a corner of the axes); their ticks stay."""
+    from .axis import _shrunk
+    from .labels import _overlap
+    xq = [_shrunk(q, 0.5) for x in xs for q in (run_quad(fonts, r) for r in x.labels)
+          if q is not None]
+    if not xq or not y.labels:
+        return y
+    keep = []
+    for r in y.labels:
+        q = run_quad(fonts, r)
+        if q is None or not any(_overlap(_shrunk(q, 0.5), o) for o in xq):
+            keep.append(r)
+    return y if len(keep) == len(y.labels) else dataclasses.replace(y, labels=tuple(keep))
+
+
+def _grid_lines(ps: Any, ctx: DrawContext) -> tuple[tuple[Any, str, bool, tuple[float, ...]], ...]:
+    """Grid lines ``(axis, setting prefix, horizontal, page positions)`` in drawing order:
+    minor and major grids of x then y, then zero lines."""
+    out = []
+    for state, horizontal in ((ps.x, False), (ps.y, True)):
+        axis = state.axis
+        mapper = ctx.ymap if horizontal else ctx.xmap
+        if axis.resolve("minor_grid"):
+            out.append((axis, "minor_grid", horizontal,
+                        tuple(mapper(v) for v in state.minor_grid_positions())))
+        if axis.resolve("grid"):
+            out.append((axis, "grid", horizontal,
+                        tuple(mapper(t.value) for t in state.ticks if t.major)))
+    for state, horizontal in ((ps.x, False), (ps.y, True)):
+        axis = state.axis
+        if (axis.resolve("zero_line") and state.scale is not None
+                and min(state.lo, state.hi) <= 0.0 <= max(state.lo, state.hi)
+                and math.isfinite(state.f(0.0))):
+            mapper = ctx.ymap if horizontal else ctx.xmap
+            out.append((axis, "zero_line", horizontal, (mapper(0.0),)))
+    return tuple(out)
+
+
+def _trim(state: Any, axis: Any, p0: float, p1: float, horizontal: bool) -> tuple[float, float]:
+    """Extent of an axis line: the axes side, or (``spine_trim``) first to last major
+    tick."""
+    if not axis.resolve("spine_trim"):
+        return p0, p1
+    majors = [t.value for t in state.ticks if t.major]
+    if not majors:
+        return p0, p1
+    m = state.mapper(p0, p1) if horizontal else state.mapper(p1, p0)
+    ps = [m(v) for v in majors]
+    return min(ps), max(ps)
+
+
+def _spines(ps: Any, rect: Rect, shift: dict[str, float] | None = None
+            ) -> tuple[tuple[Any, Segment], ...]:
+    """The axis lines; ``shift``: per side, a line moved out by that much."""
+    x0, y0, x1, y1 = rect
+    sh = shift or {}
+    spines = set(ps.plot.resolve("spines"))
+    swap = {"left": "right", "right": "left", "top": "bottom", "bottom": "top"}
+    if ps.x.on_far_side():
+        spines = {swap[s] if s in ("top", "bottom") else s for s in spines}
+    if ps.y.on_far_side():
+        spines = {swap[s] if s in ("left", "right") else s for s in spines}
+    xa, ya = ps.plot.x_axis, ps.plot.y_axis
+    ox, oy = xa.resolve("spine_offset"), ya.resolve("spine_offset")
+    xs0, xs1 = _trim(ps.x, xa, x0, x1, True)
+    lo, hi = ps.y.span                              # the value lane
+    ys0, ys1 = _trim(ps.y, ya, y0 + hi, y1 - lo, False)
+    lo_, ri, bo, to = (x0 - oy - sh.get("left", 0.0), x1 + oy + sh.get("right", 0.0),
+                       y1 + ox + sh.get("bottom", 0.0), y0 - ox - sh.get("top", 0.0))
+    lines = {"left": (ya, (lo_, ys0, lo_, ys1)),
+             "right": (ya, (ri, ys0, ri, ys1)),
+             "bottom": (xa, (xs0, bo, xs1, bo)),
+             "top": (xa, (xs0, to, xs1, to))}
+    out = tuple(lines[s] for s in ("left", "right", "bottom", "top") if s in spines)
+    if ps.x.segments is None:
+        return out
+    m = ps.x.mapper(x0, x1)                         # x lines broken at the regions' gaps
+    return tuple(piece for axis, (a, b, c, d) in out for piece in (
+        [(axis, (a, b, c, d))] if axis is ya else
+        [(axis, (m(g.u0), b, m(g.u1), d)) for g in ps.x.segments]))
+
+
+def _bands_at(ps: Any, fonts: Any, w: float, h: float) -> Bands:
+    """The bands for axes ``w`` × ``h``: those measured last when within 0.01 px of that
+    size (their ticks too), else the ticks and bands again (the row bands kept)."""
+    b = ps.bands
+    if b is not None and abs(b.size[0] - w) <= 0.01 and abs(b.size[1] - h) <= 0.01:
+        return b
+    prepare(ps, fonts, w, h)
+    new = measure(ps, fonts, w, h)
+    if b is not None:
+        extra = tuple(k for k in b.left if k.kind in ("row_label", "group"))
+        if extra:
+            new = rows.with_bands(new, extra)
+    ps.bands = new
+    return new
+
+
+def _legend(state: Any, fonts: Any, ctx: DrawContext, at: dict[str, float]) -> Any:
+    return state.legend.place(fonts, ctx.rect, ctx=ctx, offsets=at) \
+        if state.legend.active() else None
+
+
+def place_plot(ps: Any, fonts: Any, rect: Rect, figure_size: tuple[float, float]) -> PlotGeometry:
+    """A plot's geometry with its axes at ``rect``: every node of its tree placed from its
+    band (the axes and the twins' axes from the axes edges, the offsets, legend,
+    colorbars and titles at their bands' offsets), the row label at its band."""
+    plot = ps.plot
+    w, h = rect[2] - rect[0], rect[3] - rect[1]
+    bands = _bands_at(ps, fonts, w, h)         # its ticks may set the boxes at ≥ 1 px
+    set_boxes(plot, axes_width=w, axes_height=h)
+    p = Placing(ps, fonts, rect, bands)
+    for side, node, band in ps.tree:
+        node.place(p, side, band)
+    ctx = p.ctx
+    grid = _grid_lines(ps, ctx) if ps.axes_on else ()
+    spines = _spines(ps, rect) if ps.axes_on else ()
+    xg, yg = _axis(ps, fonts, ctx, bands, "x"), _axis(ps, fonts, ctx, bands, "y")
+    if id(ps) in p.offsets:
+        yg = dataclasses.replace(yg, offset=p.offsets[id(ps)])
+    twins = []
+    for t, tb in zip(ps.twins, bands.twins):
+        tctx = DrawContext(None, t.plot, rect, t.x, t.y, ps.cycle)
+        shift = {s: v for s, v in getattr(t, "shift", {}).items() if v}
+        if shift:
+            moved = {s: tuple(dataclasses.replace(b, offset=b.offset + shift.get(s, 0.0))
+                              for b in tb.side(s)) for s in SIDES}
+            tb = dataclasses.replace(tb, left=moved["left"], right=moved["right"],
+                                     top=moved["top"], bottom=moved["bottom"])
+        ty = _axis(t, fonts, tctx, tb, "y", _axis_shift(t.y, "y", shift))
+        if id(t) in p.offsets:
+            ty = dataclasses.replace(ty, offset=p.offsets[id(t)])
+        at = {s: b.offset for s in SIDES for b in tb.side(s) if b.kind == "legend"}
+        twins.append(PlotGeometry(t, rect, tb, figure_size, _grid_lines(t, tctx),
+                                  _spines(t, rect, shift),
+                                  _axis(t, fonts, tctx, tb, "x", _axis_shift(t.x, "x", shift)),
+                                  ty,
+                                  legend=_legend(t, fonts, tctx, at)))
+    xs = [xg, *(t.x for t in twins)]
+    yg = _clear_corner(fonts, yg, xs)
+    twins = [dataclasses.replace(t, y=_clear_corner(fonts, t.y, xs)) for t in twins]
+    reach = sum((b.size for b in bands.left if b.kind not in ("row_label", "group")), 0.0)
+    label = rows.place_label(ps, fonts, rect, bands, reach)
+    title = title_rule = None
+    if p.main_title is not None:
+        runs = p.main_title.runs
+        title = runs[0] if len(runs) == 1 else runs
+        title_rule = p.main_title.rule
+    p.bars.extend(place_inside(ps, fonts, ctx))
+    legend = ps.legend.place(fonts, rect, ctx=ctx, offsets=p.legend_at)
+    return PlotGeometry(ps, rect, bands, figure_size, grid, spines, xg, yg, tuple(twins),
+                        label, title, legend, tuple(p.bars), title_rule,
+                        tuple(g for _, g in sorted(p.titles, key=lambda e: e[0])),
+                        p.lane_names)