codefig 0.17.0__py3-none-any.whl

codefig/solids.py

@@ -0,0 +1,514 @@
+"""Oblique 3-D solids and level diagrams (v0.7.0).
+
+* :class:`Cuboid` — a box drawn in oblique projection (front face + top + side face),
+  the usual "tensor" / "server" / "memory block" picture. Full :class:`~codefig.primitives.Box`
+  API (text, fill, border, category, …); the label sits on the front face, ports land on
+  the visible silhouette (``port("top")`` on the top face's back edge, ``port("right")`` on
+  the side face) and ``face_port("top" | "side" | "front")`` targets a face centre.
+  ``grid=(rows, cols)`` rules cells on the front face (a token map / tensor), and
+  ``layers=k`` rules ``k`` slices along the depth (a KV cache with layers).
+* :class:`SlabStack` — a row of thin cuboid slabs (feature maps, multi-scale token maps),
+  labels underneath, ``slab(i)`` for edges.
+* :class:`Pyramid` — N stacked levels (apex on top: a memory hierarchy), per-level labels,
+  side notes on either side and ``level_port(i, side)`` ports on the slanted edges.
+
+No coordinates: sizes come from the labels and theme lengths; ``depth`` / ``angle`` set
+the oblique projection (``direction="up-left"`` mirrors it).
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any, List, Optional, Sequence, Tuple, Union
+
+from .node import Node
+from .primitives import Box, Text
+from .shapes import Shape, _poly_d
+from .styles import shade, themed, tint
+
+Pt = Tuple[float, float]
+
+
+def _hex(c: Any) -> bool:
+    return isinstance(c, str) and c.startswith("#") and len(c) in (4, 7)
+
+
+class Cuboid(Shape):
+    """Box in oblique projection: ``Cuboid("KV cache", depth=10, angle=40)``.
+
+    depth:     receding edge length (theme length; default ≈ 6 pt paper).
+    angle:     receding angle in degrees (0 = flat to the right, 90 = straight up).
+    direction: ``up-right`` (default) or ``up-left``.
+    top_fill / side_fill: face colours (default: the front fill lightened / darkened).
+    grid:      ``(rows, cols)`` cell lines on the front face; ``layers``: slices in depth.
+    Width / height (``w=`` / ``h=``) are the *overall* bounding box, like every node.
+    """
+
+    cub_depth = themed(11.0)
+
+    def __init__(self, text: str = "", *, depth: Optional[float] = None, angle: float = 40.0,
+                 direction: str = "up-right", top_fill: Optional[str] = None,
+                 side_fill: Optional[str] = None, grid: Optional[Tuple[int, int]] = None,
+                 layers: int = 0, **kwargs: Any) -> None:
+        if direction not in ("up-right", "up-left"):
+            raise ValueError("direction must be up-right|up-left")
+        if not 0.0 <= float(angle) <= 90.0:
+            raise ValueError("angle must be within 0..90 degrees")
+        self.cub_depth = depth
+        self.angle = float(angle)
+        self.direction = direction
+        self.top_fill = top_fill
+        self.side_fill = side_fill
+        self.grid = tuple(int(v) for v in grid) if grid else None
+        self.layers = int(layers)
+        super().__init__(text, **kwargs)
+
+    # -- projection ----------------------------------------------------------------
+    def _dxdy(self) -> Tuple[float, float]:
+        d = float(self.cub_depth)
+        a = math.radians(self.angle)
+        return abs(d * math.cos(a)), abs(d * math.sin(a))
+
+    def _front(self, x: float, y: float, w: float, h: float) -> Tuple[float, float, float, float]:
+        dx, dy = self._dxdy()
+        fx = x if self.direction == "up-right" else x + dx
+        return fx, y + dy, max(1.0, w - dx), max(1.0, h - dy)
+
+    def _frame_size(self, iw: float, ih: float) -> Tuple[float, float]:
+        dx, dy = self._dxdy()
+        return iw + dx, ih + dy
+
+    def _text_rect(self, x: float, y: float, w: float, h: float):
+        return self._front(x, y, w, h)
+
+    def _faces(self, x: float, y: float, w: float, h: float):
+        """(front, top, side) polygons."""
+        dx, dy = self._dxdy()
+        fx, fy, fw, fh = self._front(x, y, w, h)
+        s = 1.0 if self.direction == "up-right" else -1.0
+        front = [(fx, fy), (fx + fw, fy), (fx + fw, fy + fh), (fx, fy + fh)]
+        top = [(fx, fy), (fx + s * dx, fy - dy), (fx + fw + s * dx, fy - dy), (fx + fw, fy)]
+        ex = fx + fw if s > 0 else fx
+        side = [(ex, fy), (ex + s * dx, fy - dy), (ex + s * dx, fy + fh - dy), (ex, fy + fh)]
+        return front, top, side
+
+    def _outline(self, x: float, y: float, w: float, h: float) -> List[Pt]:
+        dx, dy = self._dxdy()
+        fx, fy, fw, fh = self._front(x, y, w, h)
+        if self.direction == "up-right":
+            return [(fx, fy), (fx + dx, fy - dy), (fx + fw + dx, fy - dy),
+                    (fx + fw + dx, fy + fh - dy), (fx + fw, fy + fh), (fx, fy + fh)]
+        return [(fx - dx, fy - dy), (fx + fw - dx, fy - dy), (fx + fw, fy), (fx + fw, fy + fh),
+                (fx, fy + fh), (fx - dx, fy + fh - dy)]
+
+    # -- ports -----------------------------------------------------------------------
+    def face_port(self, face: str = "top", *, at: float = 0.5):
+        """Port at the centre of a visible face: ``top`` | ``side`` | ``front``."""
+        from .edges import Port
+
+        if face not in ("top", "side", "front"):
+            raise ValueError("face must be top|side|front")
+        return Port(self, kind="custom", side=face, at=at)
+
+    def resolve_custom_port(self, face: str, _i: int = 0, at: float = 0.5):
+        g = self.geom
+        front, top, side = self._faces(g.x, g.y, g.w, g.h)
+        poly = {"front": front, "top": top, "side": side}[face]
+        cx = sum(p[0] for p in poly) / 4
+        cy = sum(p[1] for p in poly) / 4
+        if face == "top":
+            return cx, cy, "up"
+        if face == "side":
+            return cx, cy, "right" if self.direction == "up-right" else "left"
+        return cx, cy, "down"
+
+    # -- drawing ---------------------------------------------------------------------
+    def _face_fills(self) -> Tuple[Any, Any, Any]:
+        f = self.fill if self.fill not in (None, "none") else "#FFFFFF"
+        top = self.top_fill or (tint(f, 0.45) if _hex(f) else f)
+        side = self.side_fill or (shade(f, 0.12) if _hex(f) else f)
+        return f, top, side
+
+    def _draw_frame(self, buf: List[str], x: float, y: float, w: float, h: float) -> None:
+        from .render_svg import draw_line, draw_path
+
+        front, top, side = self._faces(x, y, w, h)
+        ff, tf, sf = self._face_fills()
+        stroke = self._border_stroke(self.stroke)
+        sw = self.stroke_width
+        dash = self._dash(sw)
+        for poly, fill in ((top, tf), (side, sf)):
+            draw_path(buf, _poly_d(poly), fill=fill, stroke=stroke or "none", stroke_width=sw,
+                      dasharray=dash)
+        fx, fy, fw, fh = self._front(x, y, w, h)
+        thin = self.theme.stroke_width  # grid lines: same weight (lint: >= 0.5 pt)
+        if self.layers > 1:  # slices along the depth, drawn on top + side faces
+            dx, dy = self._dxdy()
+            s = 1.0 if self.direction == "up-right" else -1.0
+            ex = fx + fw if s > 0 else fx
+            for k in range(1, self.layers):
+                t = k / self.layers
+                ox, oy = s * dx * t, -dy * t
+                draw_line(buf, fx + ox, fy + oy, fx + fw + ox, fy + oy, stroke=stroke, stroke_width=thin)
+                draw_line(buf, ex + ox, fy + oy, ex + ox, fy + fh + oy, stroke=stroke, stroke_width=thin)
+        draw_path(buf, _poly_d(front), fill=ff, stroke="none", stroke_width=0)
+        if self.pattern is not None:
+            self._paint_pattern(buf, fx, fy, fw, fh)
+        if self.grid:
+            r, c = self.grid
+            # v0.12: grid lines stop short of the label instead of striking it through
+            hole = None
+            if getattr(self, "text", None) or getattr(self, "subtitle", None):
+                L = self.theme.L
+                tx, ty, tw, tht = self._text_rect(x, y, w, h)
+                cw, ch = self._content_size()
+                hole = (tx + (tw - cw) / 2 - L(2.0), ty + (tht - ch) / 2 - L(1.0),
+                        tx + (tw + cw) / 2 + L(2.0), ty + (tht + ch) / 2 + L(1.0))
+
+            def seg(a0: float, a1: float, lo: float, hi: float) -> List[Tuple[float, float]]:
+                if lo >= a1 or hi <= a0:
+                    return [(a0, a1)]
+                return [(p, q) for p, q in ((a0, lo), (hi, a1)) if q - p > 0.5]
+
+            for i in range(1, max(1, r)):
+                yy = fy + fh * i / r
+                parts = ([(fx, fx + fw)] if hole is None or not (hole[1] < yy < hole[3])
+                         else seg(fx, fx + fw, hole[0], hole[2]))
+                for p0, p1 in parts:
+                    draw_line(buf, p0, yy, p1, yy, stroke=stroke, stroke_width=thin)
+            for j in range(1, max(1, c)):
+                xx = fx + fw * j / c
+                parts = ([(fy, fy + fh)] if hole is None or not (hole[0] < xx < hole[2])
+                         else seg(fy, fy + fh, hole[1], hole[3]))
+                for p0, p1 in parts:
+                    draw_line(buf, xx, p0, xx, p1, stroke=stroke, stroke_width=thin)
+        if stroke not in (None, "none") and sw > 0:
+            draw_path(buf, _poly_d(front), fill="none", stroke=stroke, stroke_width=sw, dasharray=dash)
+
+
+class SlabStack(Node):
+    """A row of thin oblique slabs — feature maps, multi-scale token maps, layer stacks.
+
+    ``SlabStack(4, labels=["r1", "r2", "r3", "r4"], heights=[10, 16, 22, 28])``.
+    n / heights: number of slabs, or one front height per slab (growing / shrinking maps).
+    thickness: slab front width; depth / angle: oblique projection (as :class:`Cuboid`).
+    fills: one colour, or one per slab (default: the theme's first palette colour).
+    grid: ``(rows, cols)`` ruled on every slab's *side* (the large face) when it is a
+    token map. ``slab(i)`` is the i-th :class:`Cuboid` (for edges / ports).
+    """
+
+    slab_thickness = themed(7.0)
+    slab_gap = themed(9.0)
+    slab_height = themed(46.0)
+    slab_depth = themed(26.0)
+
+    def __init__(self, n: Optional[int] = None, *, heights: Optional[Sequence[float]] = None,
+                 labels: Optional[Sequence[str]] = None, fills: Union[None, str, Sequence[str]] = None,
+                 thickness: Optional[float] = None, depth: Optional[float] = None,
+                 angle: float = 40.0, gap: Optional[float] = None,
+                 align: str = "bottom", **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        if heights is None and n is None:
+            raise ValueError("SlabStack needs n or heights")
+        self._heights = list(heights) if heights is not None else None
+        self.n = len(self._heights) if self._heights is not None else int(n)  # type: ignore[arg-type]
+        if self.n < 1:
+            raise ValueError("SlabStack needs at least one slab")
+        if align not in ("bottom", "center", "top"):
+            raise ValueError("align must be bottom|center|top")
+        self.labels = list(labels) if labels else []
+        self.slab_thickness = thickness
+        self.slab_depth = depth
+        self.slab_gap = gap
+        self.angle = float(angle)
+        self.v_align = align
+        if fills is None or isinstance(fills, str):
+            fl: List[Optional[str]] = [fills] * self.n  # type: ignore[list-item]
+        else:
+            fl = list(fills) + [None] * self.n
+        self._slabs = [Cuboid("", fill=fl[i] or self.theme.palette[0], depth=None, angle=self.angle)
+                       for i in range(self.n)]
+        self._texts = [Text(t, font_size=self.theme.small_size) for t in self.labels[: self.n]]
+        for k in self._slabs + self._texts:
+            k.parent = self
+
+    def children(self) -> Sequence[Node]:
+        return tuple(self._slabs) + tuple(self._texts)
+
+    def slab(self, i: int) -> Cuboid:
+        """The i-th slab (a :class:`Cuboid`)."""
+        return self._slabs[i]
+
+    def _slab_size(self, i: int) -> Tuple[float, float]:
+        c = self._slabs[i]
+        c.cub_depth = self.slab_depth
+        dx, dy = c._dxdy()
+        h = float(self._heights[i]) if self._heights is not None else float(self.slab_height)
+        return self.slab_thickness + dx, h + dy
+
+    def _measure(self) -> Tuple[float, float]:
+        sizes = [self._slab_size(i) for i in range(self.n)]
+        tw = [t.measure() for t in self._texts]
+        cols = [max(sizes[i][0], tw[i][0] if i < len(tw) else 0.0) for i in range(self.n)]
+        lab_h = max((h for _, h in tw), default=0.0)
+        gap_t = self.theme.L(3.0) if self._texts else 0.0
+        return (sum(cols) + self.slab_gap * (self.n - 1),
+                max(h for _, h in sizes) + gap_t + lab_h)
+
+    def _layout_children(self) -> None:
+        g = self.geom
+        sizes = [self._slab_size(i) for i in range(self.n)]
+        tw = [t.measure() for t in self._texts]
+        cols = [max(sizes[i][0], tw[i][0] if i < len(tw) else 0.0) for i in range(self.n)]
+        hmax = max(h for _, h in sizes)
+        gap_t = self.theme.L(3.0) if self._texts else 0.0
+        x = g.x + max(0.0, (g.w - self._measure()[0]) / 2)
+        for i in range(self.n):
+            w, h = sizes[i]
+            if self.v_align == "bottom":
+                y = g.y + hmax - h
+            elif self.v_align == "top":
+                y = g.y
+            else:
+                y = g.y + (hmax - h) / 2
+            self._slabs[i].layout(x + (cols[i] - w) / 2, y, w, h)
+            if i < len(self._texts):
+                lw, lh = tw[i]
+                self._texts[i].layout(x + (cols[i] - lw) / 2, g.y + hmax + gap_t, lw, lh)
+            x += cols[i] + self.slab_gap
+
+    def draw(self, buf: List[str], ox: float = 0.0, oy: float = 0.0) -> None:
+        for k in self.children():
+            k.draw(buf, ox, oy)
+
+
+class Pyramid(Node):
+    """N stacked levels, apex on top — memory hierarchies, data pyramids.
+
+    ``Pyramid(["SRAM", "HBM", "DRAM"], notes_right=["19 TB/s", "1.5 TB/s", "12.8 GB/s"])``
+    levels:  labels top → bottom (the top level is the apex triangle unless ``top_width``).
+    fills:   colours per level (default: theme palette, top → bottom).
+    notes_left / notes_right: side annotations, one per level (``None`` skips), vertically
+    centred on their level and aligned in a column beside the pyramid.
+    top_width: width of the cut apex as a fraction of the base (0 = sharp apex).
+    ``level(i)`` → the level's bounding rect, ``level_port(i, side)`` → a port on the
+    slanted edge (left / right) or the level's top / bottom edge, ``note_port(i, side)``
+    → the port of a side note (for leader edges).
+    A label too wide for its band is placed beside the pyramid (towards ``notes_left``'s
+    side) instead of overflowing.
+    """
+
+    level_h = themed(26.0)
+    base_min = themed(150.0)
+    note_gap = themed(8.0)
+
+    def __init__(self, levels: Sequence[str], *, fills: Optional[Sequence[str]] = None,
+                 notes_left: Optional[Sequence[Optional[str]]] = None,
+                 notes_right: Optional[Sequence[Optional[str]]] = None,
+                 top_width: float = 0.0, level_height: Optional[float] = None,
+                 width: Optional[float] = None, stroke: Optional[str] = None,
+                 stroke_width: Optional[float] = None, text_color: Optional[str] = None,
+                 gap: float = 0.0, leaders: bool = False, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        if not levels:
+            raise ValueError("Pyramid needs at least one level")
+        if not 0.0 <= top_width < 1.0:
+            raise ValueError("top_width must be within [0, 1)")
+        self.levels = [str(t) for t in levels]
+        n = len(self.levels)
+        pal = list(self.theme.palette)
+        self.fills = list(fills) if fills else [pal[i % len(pal)] for i in range(n)]
+        self.top_width = float(top_width)
+        self.level_h = level_height
+        self.base_w = width
+        self.stroke = stroke
+        self.stroke_width = stroke_width
+        self.text_color = text_color
+        self.band_gap = float(gap)
+        self.leaders = bool(leaders)
+        fs = self.theme.font_size
+        self._labels = [Text(t, font_size=fs, color=text_color) for t in self.levels]
+
+        self._nl = [None if t is None else Text(t, font_size=self.theme.small_size, align="right")
+                    for t in (list(notes_left or []) + [None] * n)[:n]]
+        self._nr = [None if t is None else Text(t, font_size=self.theme.small_size, align="left")
+                    for t in (list(notes_right or []) + [None] * n)[:n]]
+        for k in self.children():
+            k.parent = self
+        self._outside: List[bool] = [False] * n
+
+    def children(self) -> Sequence[Node]:
+        return tuple(self._labels) + tuple(t for t in self._nl + self._nr if t is not None)
+
+    # -- geometry ----------------------------------------------------------------------
+    def _lh(self) -> float:
+        th = max(t.measure()[1] for t in self._labels)
+        return max(float(self.level_h), th + self.theme.L(8.0))
+
+    def _width_at(self, W: float, H: float, y: float) -> float:
+        """Pyramid width at height ``y`` from its top (0..H)."""
+        t = self.top_width
+        return W * (t + (1 - t) * max(0.0, min(1.0, y / H)))
+
+    def _base(self) -> float:
+        if self.base_w is not None:
+            return float(self.base_w)
+        n = len(self.levels)
+        lh = self._lh()
+        H = n * lh
+        pad = self.theme.L(6.0)
+        W = float(self.base_min)
+        for i, lab in enumerate(self._labels):
+            if i == 0 and self.top_width == 0.0 and n > 1:
+                continue  # the apex label may drop low in its band or go outside
+            need = lab.measure()[0] + 2 * pad
+            frac = self.top_width + (1 - self.top_width) * ((i + 0.5) * lh / H)
+            W = max(W, need / max(frac, 1e-6))
+        return W
+
+    def _note_cols(self) -> Tuple[float, float]:
+        wl = max((t.measure()[0] for t in self._nl if t is not None), default=0.0)
+        wr = max((t.measure()[0] for t in self._nr if t is not None), default=0.0)
+        return wl, wr
+
+    def _apex_out(self) -> bool:
+        """True when the apex label does not fit inside the apex band."""
+        n = len(self.levels)
+        W, lh = self._base(), self._lh()
+        H = n * lh
+        lw, lab_h = self._labels[0].measure()
+        pad = self.theme.L(3.0)
+        y_low = lh - lab_h / 2 - pad  # lowest label centre inside band 0
+        # the label's *top* edge is where the triangle is narrowest
+        return self._width_at(W, H, y_low - lab_h / 2) < lw + 2 * pad and n > 1
+
+    def _measure(self) -> Tuple[float, float]:
+        n = len(self.levels)
+        W = self._base()
+        H = n * self._lh() + self.band_gap * (n - 1)
+        wl, wr = self._note_cols()
+        g = self.note_gap
+        left = wl + g if wl else 0.0
+        if self._apex_out() and not wl:
+            left = max(left, self._labels[0].measure()[0] + g)
+        return W + left + (wr + g if wr else 0.0), H
+
+    def _origin(self) -> Tuple[float, float, float, float]:
+        """(x0, y0, W, H) of the pyramid body inside the node box."""
+        g = self.geom
+        n = len(self.levels)
+        W = self._base()
+        H = n * self._lh() + self.band_gap * (n - 1)
+        wl, _wr = self._note_cols()
+        left = wl + self.note_gap if wl else 0.0
+        if self._apex_out() and not wl:
+            left = max(left, self._labels[0].measure()[0] + self.note_gap)
+        mw = self._measure()[0]
+        return g.x + (g.w - mw) / 2 + left, g.y + (g.h - H) / 2, W, H
+
+    def _band(self, i: int) -> Tuple[float, float]:
+        lh = self._lh()
+        y0 = i * (lh + self.band_gap)
+        return y0, y0 + lh
+
+    def _poly(self, i: int) -> List[Pt]:
+        x0, y0, W, H = self._origin()
+        a, b = self._band(i)
+        cx = x0 + W / 2
+        wa, wb = self._width_at(W, H, a), self._width_at(W, H, b)
+        return [(cx - wa / 2, y0 + a), (cx + wa / 2, y0 + a), (cx + wb / 2, y0 + b), (cx - wb / 2, y0 + b)]
+
+    def level(self, i: int) -> Tuple[float, float, float, float]:
+        """(x, y, w, h) bounding rect of level ``i`` (0 = top)."""
+        p = self._poly(i)
+        xs = [q[0] for q in p]
+        ys = [q[1] for q in p]
+        return min(xs), min(ys), max(xs) - min(xs), max(ys) - min(ys)
+
+    def level_port(self, i: int, side: str = "right", *, at: float = 0.5):
+        """Port on level ``i``: left / right on the slanted edge, top / bottom on the level edge."""
+        from .edges import Port
+
+        if not 0 <= i < len(self.levels):
+            raise IndexError(f"level {i} out of range")
+        if side not in ("left", "right", "top", "bottom"):
+            raise ValueError("side must be left|right|top|bottom")
+        return Port(self, kind="custom", side=side, index=i, at=at)
+
+    def note_port(self, i: int, side: str = "right"):
+        """Port of the side note of level ``i`` (``side`` = which note: left | right)."""
+        t = (self._nr if side == "right" else self._nl)[i]
+        if t is None:
+            raise ValueError(f"level {i} has no {side} note")
+        return t.port("left" if side == "right" else "right")
+
+    def resolve_custom_port(self, side: str, i: int = 0, at: float = 0.5):
+        (lx, ly), (rx, ry), (rbx, rby), (lbx, lby) = self._poly(i)
+        if side == "top":
+            return lx + (rx - lx) * at, ly, "up"
+        if side == "bottom":
+            return lbx + (rbx - lbx) * at, lby, "down"
+        if side == "left":
+            return lx + (lbx - lx) * at, ly + (lby - ly) * at, "left"
+        return rx + (rbx - rx) * at, ry + (rby - ry) * at, "right"
+
+    def _layout_children(self) -> None:
+        x0, y0, W, H = self._origin()
+        g = self.geom
+        pad = self.theme.L(3.0)
+        n = len(self.levels)
+        self._outside = [False] * n
+        wl, wr = self._note_cols()
+        for i, lab in enumerate(self._labels):
+            lw, lh_ = lab.measure()
+            a, b = self._band(i)
+            cy = (a + b) / 2
+            if i == 0 and n > 1 and self.top_width == 0.0:
+                # drop the apex label as low as needed for it to fit
+                need_y = H * (lw + 2 * pad) / W  # width(y) = W * y / H at the label's top
+                cy = min(max(cy, need_y + lh_ / 2), b - lh_ / 2 - pad)
+                if self._apex_out():
+                    self._outside[0] = True
+                    cy = (a + b) / 2
+                    nx = x0 + W / 2 - self._width_at(W, H, cy) / 2 - self.note_gap - lw
+                    lab.layout(nx, y0 + cy - lh_ / 2, lw, lh_)
+                    continue
+            lab.layout(x0 + W / 2 - lw / 2, y0 + cy - lh_ / 2, lw, lh_)
+        for i in range(n):
+            a, b = self._band(i)
+            cy = y0 + (a + b) / 2
+            t = self._nl[i]
+            if t is not None:
+                w_, h_ = t.measure()
+                t.layout(x0 - self.note_gap - w_, cy - h_ / 2, w_, h_)
+            t = self._nr[i]
+            if t is not None:
+                w_, h_ = t.measure()
+                t.layout(x0 + W + self.note_gap, cy - h_ / 2, w_, h_)
+
+    def draw(self, buf: List[str], ox: float = 0.0, oy: float = 0.0) -> None:
+        from .render_svg import draw_path
+
+        stroke = self.stroke or self.theme.stroke
+        sw = self.stroke_width if self.stroke_width is not None else self.theme.stroke_width
+        for i in range(len(self.levels)):
+            pts = [(x + ox, y + oy) for x, y in self._poly(i)]
+            draw_path(buf, _poly_d(pts), fill=self.fills[i % len(self.fills)], stroke=stroke,
+                      stroke_width=sw)
+        if self.leaders:
+            from .render_svg import draw_line
+
+            th = self.theme
+            for i in range(len(self.levels)):
+                for side, t in (("left", self._nl[i]), ("right", self._nr[i])):
+                    if t is None:
+                        continue
+                    px, py, _d = self.resolve_custom_port(side, i, 0.5)
+                    g = t.geom
+                    tx = g.x - th.L(2.0) if side == "right" else g.right + th.L(2.0)
+                    gap = th.L(2.0) if side == "right" else -th.L(2.0)
+                    draw_line(buf, px + gap + ox, py + oy, tx + ox, py + oy,
+                              stroke=th.muted_color, stroke_width=th.stroke_width,
+                              dasharray=f"{th.L(1.0):.2f} {th.L(2.0):.2f}")
+        for k in self.children():
+            k.draw(buf, ox, oy)