plot-io 0.12.0__py3-none-win_amd64.whl

plot_io/layers/geoms.py

@@ -0,0 +1,1362 @@
+"""The eight geoms: how columns become marks.
+
+Each geom implements, once for every plot type that uses it:
+
+* ``extent(layer, role, scale)`` and ``values(layer, role)``: the data the axes see, per
+  axis of the layer's frame;
+* ``draw(ctx, layer)``: vec_io calls, with the layer's frame mappers (a flipped layer's x
+  is the plot's y: orientation is this one swap);
+* ``part(layer)``: its part of the call's legend symbol, as data (``glyph`` draws it);
+* ``occupy(ctx, layer, occ)``: the cells it covers, for legend placement;
+* ``hit(ctx, layer, px, py)``: the index of the item under a page point, or ``None``.
+
+Columns are in data units, except those a layer computes once the axes are placed (slot
+widths in px, wedges, labels), which are page units and named so (``page_*``).
+"""
+
+import array
+import contextlib
+import math
+from typing import Any
+
+import vec_io
+from vec_io.arrays import doubles
+
+from ..canvas import Canvas
+from .. import kernels
+from ..lines import dash_of
+
+__all__ = ["Geom", "Points", "Path", "Band", "Rects", "Polygons", "Segments", "Cells",
+           "Text", "GEOMS", "LAYER_OPTIONS", "RECTS", "Marks", "split_band", "with_crossings"]
+
+_nan = math.nan
+
+
+def _is_const(v: Any) -> bool:
+    return isinstance(v, (int, float)) and not isinstance(v, bool)
+
+
+def _many(mapper: Any, v: Any) -> Any:
+    """A column (or a constant) through a mapper."""
+    if _is_const(v):
+        return mapper(float(v))
+    return mapper.many(v)
+
+
+def _ends(mapper: Any, v: Any) -> Any:
+    """A column (or a constant) of shape ends through a mapper: values outside the scale's
+    domain at the axes' edge (see ``Mapper.ends``)."""
+    if _is_const(v):
+        return mapper.ends(array.array("d", [float(v)]))[0]
+    return mapper.ends(v)
+
+
+def _map(mapper: Any, v: Any, f_space: bool) -> Any:
+    """A column through a mapper; ``f_space``: values already through the scale function
+    (contours computed in the axes' scale space)."""
+    if f_space:
+        return mapper.position(float(v)) if _is_const(v) else kernels.scaled(v, mapper.a,
+                                                                              mapper.b)
+    return _many(mapper, v)
+
+
+def _columns(v: Any) -> list[Any]:
+    """The arrays of a channel: one, several (a list of arrays), or a constant."""
+    if v is None:
+        return []
+    if _is_const(v):
+        return [array.array("d", [float(v)])]
+    if isinstance(v, list) and v and not _is_const(v[0]) and v[0] is not None:
+        return v
+    return [v]
+
+
+class Geom:
+    """Base of the geoms: the extent of the channels on each axis of the frame."""
+
+    #: frame axis → channels whose values are on it
+    CHANNELS: dict[str, tuple[str, ...]] = {"x": ("x",), "y": ("y",)}
+    #: channels that are ends of shapes (baselines, band edges, segment ends): values
+    #: outside the scale's domain are drawn at the axes' edge, not dropped
+    ENDS: tuple[str, ...] = ()
+    #: the layer options the geom reads (with :data:`LAYER_OPTIONS`, read for every geom)
+    OPTIONS: tuple[str, ...] = ()
+
+    def mapped(self, mapper: Any, v: Any, channel: str) -> Any:
+        """A channel's column (or constant) through a mapper, as an end when it is one."""
+        return _ends(mapper, v) if channel in self.ENDS else _many(mapper, v)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}()"
+
+    def extent(self, layer: Any, role: str, scale: Any) -> tuple[int, float, float]:
+        """``(count, low, high)`` of the channels on ``role``; on a log scale, shapes with
+        an end at or below 0 (drawn from the axes' edge) lower ``low`` to the power of the
+        base below it, so that the smallest of them keeps a height."""
+        count, lo, hi = 0, math.inf, -math.inf
+        edge = False
+        for ch in self.CHANNELS.get(role, ()):
+            for c in _columns(layer.col(ch)):
+                n, a, b = kernels.extent(c, scale.function)
+                if n:
+                    count += n
+                    lo, hi = min(lo, a), max(hi, b)
+                if scale.base is not None and ch in self.ENDS and not edge:
+                    m, a0, _ = kernels.extent(c, None)
+                    edge = bool(m) and a0 <= 0
+        if not count:
+            return 0, math.nan, math.nan
+        if edge and lo > 0:
+            lo = scale.base ** math.floor(math.log(lo, scale.base) - 1e-9)
+        return count, lo, hi
+
+    def dropped(self, layer: Any, role: str, scale: Any) -> int:
+        """Shapes whose every end on ``role`` is outside the scale's domain (not drawn)."""
+        chans = self.CHANNELS.get(role, ())
+        if len(chans) < 2 or any(ch not in self.ENDS for ch in chans):
+            return 0
+        cols = [layer.col(ch) for ch in chans]
+        if any(c is None for c in cols):
+            return 0
+        n = max((len(c) for c in cols if not _is_const(c)), default=1)
+        outside = [[not scale.contains(float(c)) and math.isfinite(float(c))] * n
+                   if _is_const(c) else
+                   [not scale.contains(v) and math.isfinite(v) for v in c] for c in cols]
+        return sum(all(o[i] for o in outside) for i in range(n))
+
+    def values(self, layer: Any, role: str) -> Any:
+        out = array.array("d")
+        for ch in self.CHANNELS.get(role, ()):
+            for c in _columns(layer.col(ch)):
+                out.extend(doubles(c))
+        return out
+
+    def draw(self, ctx: Any, layer: Any) -> None:
+        raise NotImplementedError
+
+    def part(self, layer: Any) -> tuple[str, Any] | None:
+        """The layer's part of a legend symbol, ``(kind, options)`` (see
+        :func:`~plot_io.layers.core.draw_part`); ``None`` by default."""
+        return None
+
+    def occupy(self, ctx: Any, layer: Any, occ: Any) -> None:
+        """Nothing by default."""
+
+    def hit(self, ctx: Any, layer: Any, px: float, py: float) -> int | None:
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Points
+# ---------------------------------------------------------------------------
+
+class Marks:
+    """Marker arguments of a ``Points`` layer that are not a call's marker settings."""
+
+    def __init__(self, marker: Any = None, size: Any = 6.0, fill: Any = None,
+                 stroke: Any = None, line_width: Any = None, opacity: Any = 1.0,
+                 simplify: Any = None) -> None:
+        self.marker, self.size, self.fill, self.stroke = marker, size, fill, stroke
+        self.line_width, self.opacity, self.simplify = line_width, opacity, simplify
+        self.order = None
+
+    def draw(self, canvas: Canvas, xs: Any, ys: Any, simplify: Any) -> None:
+        canvas.draw_markers(xs, ys, marker=self.marker, size=self.size, fill=self.fill,
+                            stroke=self.stroke, stroke_width=self.line_width,
+                            opacity=self.opacity, simplify=simplify)
+
+
+class Points(Geom):
+    """Markers at ``(x, y)``: equal-area shapes (scatter, strip, swarm, outliers, line and
+    regression markers).  Paint: a :class:`~plot_io.layers.paint.MarkerStyle` (or
+    :class:`Marks`), called with ``glyph=True`` for the legend symbol.  Options:
+    ``glyph_at`` (fraction of the symbol box height), ``glyph_max`` (largest marker, ×
+    the height), ``radius`` (px marked around each point for legend placement)."""
+
+    OPTIONS = ("glyph_at", "glyph_max", "radius")
+
+    def _xy(self, ctx: Any, layer: Any) -> tuple[Any, Any]:
+        f = ctx.frame(layer)
+        return f.page(_many(f.u, layer.col("x")), _many(f.v, layer.col("y")))
+
+    def draw(self, ctx: Any, layer: Any) -> None:
+        style = layer.style(ctx)
+        if not style:
+            return
+        px, py = self._xy(ctx, layer)
+        if isinstance(px, float):
+            px, py = [px], [py]
+        order = getattr(style, "order", None)
+        if order is not None:
+            from .paint import permuted
+            px, py = permuted(px, order), permuted(py, order)
+        if style.fill is None and style.stroke is None:
+            return
+        style.draw(ctx.canvas, px, py, getattr(style, "simplify", None))
+
+    def part(self, layer: Any) -> tuple[str, Any] | None:
+        o = layer.options
+        return "marker", (("at", o.get("glyph_at", 0.5)), ("max", o.get("glyph_max", 1.1)))
+
+    def occupy(self, ctx: Any, layer: Any, occ: Any) -> None:
+        from ..occupancy import thin
+        xs, ys = layer.col("x"), layer.col("y")
+        if xs is None or ys is None:
+            return
+        f = ctx.frame(layer)
+        a, b = thin(doubles(xs), doubles(ys))
+        px, py = f.page(f.u.many(a), f.v.many(b))
+        # an unpainted layer stands in for a curve or a density: not markers
+        occ.points(px, py, layer.options.get("radius", 0.0), marker=layer.paint is not None)
+
+    def hit(self, ctx: Any, layer: Any, px: float, py: float) -> int | None:
+        xs, ys = self._xy(ctx, layer)
+        r = max(layer.options.get("radius", 0.0), 3.0)
+        best, best_d = None, r * r
+        for i, (a, b) in enumerate(zip(xs, ys)):
+            d = (a - px) ** 2 + (b - py) ** 2
+            if d <= best_d:
+                best, best_d = i, d
+        return best
+
+
+_MARKER_ARGS = ("marker", "size", "fill", "stroke", "line_width", "opacity")
+
+
+def _per_point(v: Any) -> bool:
+    return isinstance(v, (list, array.array)) or (isinstance(v, memoryview) and v.ndim >= 1)
+
+
+def _rgba_rows(v: Any, n: int) -> Any:
+    """A paint as ``n`` flat RGBA rows (``array('d')``), or ``None`` when it is not RGBA."""
+    from ..color.values import CMYK, rgba_of
+    if isinstance(v, memoryview) and v.ndim == 2:
+        m: Any = v
+        return array.array("d", m.cast("B").cast("d")) if m.shape[1] == 4 else None
+    if isinstance(v, array.array) and len(v) == 4 * n:
+        return v
+    if isinstance(v, list):
+        out = array.array("d")
+        for c in v:
+            if c is None or isinstance(c, CMYK) or (got := rgba_of(c)) is None:
+                return None
+            out.extend(got)
+        return out
+    if isinstance(v, CMYK) or (got := rgba_of(v)) is None:
+        return None
+    return array.array("d", got) * n
+
+
+def _joined(name: str, values: list[Any], sizes: list[int]) -> Any:
+    """One per-point column of the members' ``values`` (each one value or ``sizes[k]``)."""
+    if all(not _per_point(v) for v in values) and all(v == values[0] for v in values):
+        return values[0]
+    if name == "marker":
+        out: list[Any] = []
+        for v, k in zip(values, sizes):
+            out.extend(v if isinstance(v, list) else [v] * k)
+        return out
+    if name in ("fill", "stroke"):
+        rows = [_rgba_rows(v, k) for v, k in zip(values, sizes)]
+        if all(r is not None for r in rows):
+            flat = array.array("d")
+            for r in rows:
+                flat.extend(r)
+            return memoryview(flat).cast("B").cast("d", (len(flat) // 4, 4))
+        colors: list[Any] = []
+        for v, k in zip(values, sizes):
+            colors.extend(_colors_list(v, k))
+        return colors
+    num = array.array("d")
+    for v, k in zip(values, sizes):
+        num.extend(doubles(v) if _per_point(v) else array.array("d", [float(v)]) * k)
+    return num
+
+
+def _colors_list(v: Any, n: int) -> list[Any]:
+    if isinstance(v, list):
+        return v
+    if isinstance(v, memoryview) and v.ndim == 2:
+        rows: Any = v.tolist()
+        return [tuple(r) for r in rows]
+    if isinstance(v, array.array):
+        return [tuple(v[4 * i:4 * i + 4]) for i in range(n)]
+    return [v] * n
+
+
+def _slice(v: Any, a: int, b: int, n: int) -> Any:
+    """Items ``a:b`` of a per-point column of ``n``; one value unchanged."""
+    if isinstance(v, memoryview) and v.ndim == 2:
+        m: Any = v
+        k = m.shape[1]
+        return m.cast("B").cast("d")[a * k:b * k].cast("B").cast("d", (b - a, k))
+    if isinstance(v, array.array) and len(v) == 4 * n and n != len(v):
+        return v[4 * a:4 * b]
+    if _per_point(v):
+        return v[a:b]
+    return v
+
+
+def draw_in_order(ctx: Any, calls: list[Any]) -> bool:
+    """Draw the point layers of the members of one call (``group=`` members, level
+    members: ``series._rows``) in data order: one ``draw_markers`` when the members differ
+    only in what it takes per point, else one per run of consecutive points of a member.
+    ``False`` (nothing drawn) when a member is not one ``Points`` layer, or its points do
+    not match its rows (a member's ``draw_order``)."""
+    members: list[Any] = []
+    for call in calls:
+        layers = [ly for ly in call.layers if not ly.overlay]
+        if len(layers) != 1 or not isinstance(layers[0].geom, Points) \
+                or layers[0].options.get("segment") is not None:
+            return False
+        c = ctx.for_call(call)
+        lay = layers[0].columns(c)
+        style = lay.style(c)
+        rows = call.series.__dict__["_order_rows"][1]
+        if not style or style.fill is None and style.stroke is None:
+            members.append(None)
+            continue
+        if getattr(style, "order", None) is not None:
+            return False
+        px, py = Points()._xy(c, lay)
+        if isinstance(px, float):
+            px, py = [px], [py]
+        if len(px) != len(rows):
+            return False
+        members.append((style, px, py, rows))
+    drawn = [m for m in members if m is not None]
+    if not drawn:
+        return True
+    keys = array.array("d")
+    for m in drawn:
+        keys.extend(doubles(m[3]))
+    order = kernels.argsort(keys)
+    sizes = [len(m[1]) for m in drawn]
+    styles = [m[0] for m in drawn]
+
+    def kind(st: Any) -> tuple[Any, ...]:
+        return (st.fill is None, st.stroke is None, st.line_width is None,
+                getattr(st, "simplify", None))
+    canvas = ctx.canvas
+    if all(kind(st) == kind(styles[0]) for st in styles):
+        from .paint import permuted
+        xs = array.array("d")
+        ys = array.array("d")
+        for m in drawn:
+            xs.extend(doubles(m[1]))
+            ys.extend(doubles(m[2]))
+        args = {a: _joined(a, [getattr(st, a) for st in styles], sizes) for a in _MARKER_ARGS}
+        if args["fill"] is None and args["stroke"] is None:
+            return True
+        args = {a: permuted(v, order) if _per_point(v) else v for a, v in args.items()}
+        canvas.draw_markers(permuted(xs, order), permuted(ys, order), marker=args["marker"],
+                            size=args["size"], fill=args["fill"], stroke=args["stroke"],
+                            stroke_width=args["line_width"], opacity=args["opacity"],
+                            simplify=getattr(styles[0], "simplify", None))
+        return True
+    owner = array.array("q")
+    for k, n in enumerate(sizes):
+        owner.extend([k] * n)
+    start = [0] * len(drawn)
+    i, total = 0, len(order)
+    while i < total:                                  # runs of one member, in data order
+        k = owner[order[i]]
+        j = i + 1
+        while j < total and owner[order[j]] == k:
+            j += 1
+        a, b, n = start[k], start[k] + (j - i), sizes[k]
+        st, px, py, _ = drawn[k]
+        part = Marks(*(_slice(getattr(st, name), a, b, n) for name in _MARKER_ARGS))
+        if st.fill is not None or st.stroke is not None:
+            part.draw(canvas, _slice(px, a, b, n), _slice(py, a, b, n),
+                      getattr(st, "simplify", None))
+        start[k] = b
+        i = j
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Paths and bands
+# ---------------------------------------------------------------------------
+
+#: Steps keep their shape when x and y are swapped by swapping the step kind.
+_SWAPPED_STEPS = {"linear": "linear", "step-pre": "step-post", "step-post": "step-pre"}
+
+
+def _swapped(canvas: Canvas, flip: bool, interpolation: str) -> tuple[bool, str]:
+    """Whether a flipped curve is drawn under the x↔y transform (curves along y: steps at
+    midpoints, monotone, splines), and the interpolation to pass."""
+    if not flip:
+        return False, interpolation
+    if interpolation in _SWAPPED_STEPS:
+        return False, _SWAPPED_STEPS[interpolation]
+    return True, interpolation
+
+
+def _step_points(x: Any, y: Any, interpolation: str) -> tuple[list[float], list[float]]:
+    """The vertices of a step line (for legend placement)."""
+    xs, ys = list(x), list(y)
+    if interpolation not in ("step-pre", "step-post", "step-mid") or len(xs) < 2:
+        return xs, ys
+    ox, oy = [xs[0]], [ys[0]]
+    for i in range(1, len(xs)):
+        if interpolation == "step-post":
+            ox += [xs[i], xs[i]]
+            oy += [ys[i - 1], ys[i]]
+        elif interpolation == "step-pre":
+            ox += [xs[i - 1], xs[i]]
+            oy += [ys[i], ys[i]]
+        else:
+            m = (xs[i - 1] + xs[i]) / 2
+            ox += [m, m, xs[i]]
+            oy += [ys[i - 1], ys[i], ys[i]]
+    return ox, oy
+
+
+class Path(Geom):
+    """Polylines through ``(x, y)`` with interpolation and missing values (lines, densities,
+    ECDFs, regression curves, contour lines, steps).  ``x`` and ``y`` are one array each,
+    ``y`` several arrays sharing ``x``, or both lists of arrays.  Paint: ``color``,
+    ``width``, ``dash``, ``opacity``, ``cap``/``join`` (set on the canvas, as line styles
+    are), ``interpolation``, ``missing``, ``simplify``.  ``page_lines``: polylines in page
+    units with their own color and width (gene models placed once the axes are known).
+    Options: ``glyph`` (``"line"`` across the symbol box, ``"top"`` along the top of a
+    filled swatch), ``ends`` (``y`` values are ends: outlines of fills, see
+    :attr:`Geom.ENDS`)."""
+
+    OPTIONS = ("ends", "f_space", "lists", "glyph", "interpolation")
+
+    def _v(self, layer: Any, f: Any, b: Any, f_space: bool) -> Any:
+        """``y`` values through the frame's v mapper (as ends with the ``ends`` option)."""
+        return _ends(f.v, b) if layer.options.get("ends") else _map(f.v, b, f_space)
+
+    def _paths(self, layer: Any) -> list[tuple[Any, Any]]:
+        x, y = layer.col("x"), layer.col("y")
+        if isinstance(x, list) and x and not _is_const(x[0]):
+            return list(zip(x, y))
+        ys = _columns(y)
+        return [(x, r) for r in ys]
+
+    def draw(self, ctx: Any, layer: Any) -> None:
+        lines = layer.col("page_lines")
+        if lines is not None:                     # page polylines, each with its paint
+            for xs, ys, c, w in lines:
+                ctx.canvas.draw_lines(xs, ys, stroke=c, stroke_width=w)
+            return
+        p = layer.style(ctx)
+        c, w = p.get("color"), p.get("width")
+        if c is None or not w:
+            return
+        paths = self._paths(layer)
+        if not paths:
+            return
+        f = ctx.frame(layer)
+        canvas = ctx.canvas
+        interp = p.get("interpolation", "linear")
+        transformed, interp = _swapped(canvas, f.flip, interp)
+        fs = layer.options.get("f_space", False)
+        us = [_map(f.u, a, fs) for a, _ in paths]
+        vs = [self._v(layer, f, b, fs) for _, b in paths]
+        scope = contextlib.ExitStack()
+        if transformed:
+            xs, ys = us, vs
+            scope.enter_context(canvas.state())
+            canvas.transform(0.0, 1.0, 1.0, 0.0, 0.0, 0.0)
+        else:
+            xs, ys = (vs, us) if f.flip else (us, vs)
+        if p.get("cap") is not None:
+            canvas.stroke_linecap = p["cap"]
+        if p.get("join") is not None:
+            canvas.stroke_linejoin = p["join"]
+        kw: dict[str, Any] = {}
+        if "opacity" in p:
+            kw["opacity"] = p["opacity"]
+        if "dash" in p:
+            kw["stroke_dasharray"] = p["dash"]
+        if "line_cap" in p:
+            kw["stroke_linecap"] = p["line_cap"]
+        if "simplify" in p:
+            kw["simplify"] = p["simplify"]
+        if "interpolation" in p:
+            kw["interpolation"] = interp
+        if "missing" in p:
+            kw["missing"] = p["missing"]
+        single = len(paths) == 1 and not layer.options.get("lists")
+        try:
+            canvas.draw_lines(xs[0] if single else xs, ys[0] if single else ys, stroke=c,
+                              stroke_width=w, **kw)
+        finally:
+            scope.close()
+
+    def part(self, layer: Any) -> tuple[str, Any] | None:
+        return "line", (("top", layer.options.get("glyph", "line") == "top"),)
+
+    def occupy(self, ctx: Any, layer: Any, occ: Any) -> None:
+        from ..occupancy import extremes
+        f = ctx.frame(layer)
+        interp = (layer.paint if isinstance(layer.paint, dict) else {}).get(
+            "interpolation", layer.options.get("interpolation", "linear"))
+        for a, b in self._paths(layer):
+            if a is None or b is None:
+                continue
+            if _is_const(b):
+                b = array.array("d", [float(b)] * len(a))
+            if interp.startswith("step"):
+                a, b = _step_points(a, b, interp)
+            a, b = extremes(doubles(a), doubles(b))   # spikes kept
+            fs = layer.options.get("f_space", False)
+            px, py = f.page(_map(f.u, a, fs), self._v(layer, f, b, fs))
+            occ.lines(px, py)
+
+    def hit(self, ctx: Any, layer: Any, px: float, py: float) -> int | None:
+        f = ctx.frame(layer)
+        p = layer.style(ctx)
+        width = p.get("width")
+        tol = (width if width else 1.0) / 2 + 2.0
+        for i, (a, b) in enumerate(self._paths(layer)):
+            xs, ys = f.page(_many(f.u, a), self._v(layer, f, b, False))
+            for k in range(len(xs) - 1):
+                if _near_segment(px, py, xs[k], ys[k], xs[k + 1], ys[k + 1], tol):
+                    return i
+        return None
+
+
+def _near_segment(px: float, py: float, x0: float, y0: float, x1: float, y1: float,
+                  tol: float) -> bool:
+    dx, dy = x1 - x0, y1 - y0
+    d2 = dx * dx + dy * dy
+    t = 0.0 if not d2 else max(0.0, min(1.0, ((px - x0) * dx + (py - y0) * dy) / d2))
+    ex, ey = x0 + t * dx - px, y0 + t * dy - py
+    return ex * ex + ey * ey <= tol * tol
+
+
+def split_band(x: Any, y1: Any, y2: Any,
+               crossings: bool) -> tuple[array.array, array.array, array.array, array.array]:
+    """``(x, y1, y2, low)`` with ``low`` the smaller of the curves at each point: filling
+    between ``y1`` and ``low`` covers where ``y1`` is above, ``y2`` and ``low`` where it is
+    below.  ``crossings``: points where the curves cross are added (straight segments;
+    steps need none).  ``y2`` may be a constant."""
+    ox, oc = with_crossings(list(x), [list(y1), [y2] * len(x) if _is_const(y2) else list(y2)],
+                            crossings)
+    a, b = oc
+    lo = array.array("d", (min(u, v) if math.isfinite(u) and math.isfinite(v) else _nan
+                           for u, v in zip(a, b)))
+    return array.array("d", ox), array.array("d", a), array.array("d", b), lo
+
+
+def with_crossings(xs: list[float], curves: list[list[float]],
+                   crossings: bool = True) -> tuple[list[float], list[list[float]]]:
+    """Points added where any two straight-segment curves cross (with ``crossings``), so
+    that the order of the curves is constant between points: the band splitting of
+    ``Band`` (below colors) and of genome signals filled between each other."""
+    ox: list[float] = []
+    oc: list[list[float]] = [[] for _ in curves]
+    for i, x in enumerate(xs):
+        if i and crossings:
+            a, b = xs[i - 1], x
+            ts = set()
+            for p in range(len(curves)):
+                for q in range(p + 1, len(curves)):
+                    d0 = curves[p][i - 1] - curves[q][i - 1]
+                    d1 = curves[p][i] - curves[q][i]
+                    if d0 * d1 < 0 and math.isfinite(a) and math.isfinite(b):
+                        ts.add(d0 / (d0 - d1))
+            for t in sorted(ts):
+                ox.append(a + t * (b - a))
+                for c, o in zip(curves, oc):
+                    o.append(c[i - 1] + t * (c[i] - c[i - 1]))
+        ox.append(x)
+        for c, o in zip(curves, oc):
+            o.append(c[i])
+    return ox, oc
+
+
+#: Band paint keys that may hold one value per band.
+_PER_BAND = ("color", "opacity", "stroke", "below", "below_opacity", "edge")
+
+
+class Band(Geom):
+    """The area between two curves ``y1`` and ``y2`` along ``x`` (``y2`` may be a constant):
+    fills, stacked areas, density fills, violin halves, confidence bands, genome signal
+    fills.  ``x`` and ``y1``/``y2`` may be lists of arrays (several bands: violins).
+    Paint: ``color``, ``opacity``, ``below`` (the color where ``y1`` is under ``y2``, the
+    curves split where they cross), ``below_opacity``, ``stroke``/``width`` (outline of
+    the area), ``edge``/``edge_width`` (both curves as lines), ``interpolation``,
+    ``missing``, ``simplify``.  Options: ``glyph`` (``"swatch"``: a filled swatch, with
+    ``edge`` its outline; ``"band"``: 0.6 of the symbol box's height)."""
+
+    OPTIONS = ("glyph",)
+
+    CHANNELS = {"x": ("x",), "y": ("y1", "y2")}
+    ENDS = ("y1", "y2")
+
+    def _bands(self, layer: Any) -> list[tuple[Any, Any, Any]]:
+        x, a, b = layer.col("x"), layer.col("y1"), layer.col("y2")
+        if isinstance(x, list) and x and not _is_const(x[0]):
+            return list(zip(x, a, b))
+        return [(x, a, b)]
+
+    def draw(self, ctx: Any, layer: Any) -> None:
+        p = layer.style(ctx)
+        f = ctx.frame(layer)
+        canvas = ctx.canvas
+        interp = p.get("interpolation", "linear")
+        bands = self._bands(layer)
+        if len(bands) > 1 and interp == "linear" and p.get("below") is None \
+                and p.get("edge") is None:
+            self._polygons(canvas, f, p, bands)
+            return
+        transformed = f.flip
+        kw: dict[str, Any] = {}
+        for k in ("simplify", "missing"):
+            if k in p:
+                kw[k] = p[k]
+        if "interpolation" in p:
+            kw["interpolation"] = interp
+        with canvas.state() if transformed else contextlib.nullcontext():
+            if transformed:
+                canvas.transform(0.0, 1.0, 1.0, 0.0, 0.0, 0.0)
+            for i, (t, y1, y2) in enumerate(self._bands(layer)):
+                pi = {k: (v[i] if isinstance(v, list) and k in _PER_BAND else v)
+                      for k, v in p.items()}
+                self._one(canvas, f, pi, t, y1, y2, interp, kw)
+
+    def _polygons(self, canvas: Canvas, f: Any, p: dict[str, Any], bands: list[Any]) -> None:
+        """Several straight bands in one call (violins), each a polygon: ``y1`` forward,
+        ``y2`` back."""
+        from ..shapes import draw_polygons
+        polys = []
+        for t, y1, y2 in bands:
+            pu = f.u.many(t)
+            ru = array.array("d", pu)
+            ru.extend(reversed(pu))
+            a, b = self.mapped(f.v, y1, "y1"), self.mapped(f.v, y2, "y2")
+            rv = array.array("d", [a] * len(t) if isinstance(a, float) else a)
+            low = [b] * len(t) if isinstance(b, float) else b
+            rv.extend(reversed(low))
+            polys.append([f.page(ru, rv)])
+        kw: dict[str, Any] = {}
+        if p.get("stroke") is not None:
+            kw["stroke"] = p["stroke"]
+            kw["stroke_width"] = p.get("width")
+        if "simplify" in p:
+            kw["simplify"] = p["simplify"]
+        draw_polygons(canvas, polys, fill=p.get("color"), **kw)
+
+    def _one(self, canvas: Canvas, f: Any, p: dict[str, Any], t: Any, y1: Any, y2: Any,
+             interp: str, kw: dict[str, Any]) -> None:
+        c = p.get("color")
+        below = p.get("below")
+        opacity = p.get("opacity", 1.0)
+        xs = f.u.many(t)
+        if c is not None and below is not None:
+            a = y1 if not _is_const(y1) else array.array("d", [float(y1)] * len(t))
+            st, sa, sb, lo = split_band(t, a, y2, not interp.startswith("step"))
+            tx, low = f.u.many(st), f.v.ends(lo)
+            canvas.draw_area(tx, f.v.ends(sa), low, fill=c, opacity=opacity, **kw)
+            canvas.draw_area(tx, f.v.ends(sb), low, fill=below,
+                                opacity=p.get("below_opacity", opacity), **kw)
+        elif c is not None:
+            extra = {}
+            if "stroke" in p:
+                extra["stroke"] = p["stroke"]
+                if p.get("width") is not None:
+                    extra["stroke_width"] = p["width"]
+            canvas.draw_area(xs, _ends(f.v, y1), _ends(f.v, y2), fill=c, opacity=opacity,
+                                **extra, **kw)
+        edge, ew = p.get("edge"), p.get("edge_width")
+        if edge is not None and ew:
+            ekw = {k: v for k, v in kw.items() if k in ("interpolation", "missing")}
+            for y in (y1, y2):
+                if _is_const(y):
+                    if len(xs):
+                        yv = _ends(f.v, y)
+                        canvas.draw_lines([min(xs), max(xs)], [yv, yv], stroke=edge, stroke_width=ew)
+                else:
+                    canvas.draw_lines(xs, f.v.ends(y), stroke=edge, stroke_width=ew, **ekw)
+
+    def part(self, layer: Any) -> tuple[str, Any] | None:
+        return "band", (("form", layer.options.get("glyph", "swatch")),)
+
+    def occupy(self, ctx: Any, layer: Any, occ: Any) -> None:
+        from ..occupancy import MAX_VERTICES, thin
+        f = ctx.frame(layer)
+        for t, a, b in self._bands(layer):
+            n = len(t)
+            a, b = ([float(v)] * n if _is_const(v) else v for v in (a, b))
+            t, a, b = thin(t, a, b, limit=MAX_VERTICES)
+            if f.flip:
+                occ.band(f.u.many(t), f.v.ends(a), f.v.ends(b), True)
+            else:
+                occ.band(f.u.many(t), f.v.ends(a), f.v.ends(b))
+
+    def hit(self, ctx: Any, layer: Any, px: float, py: float) -> int | None:
+        f = ctx.frame(layer)
+        u, v = (py, px) if f.flip else (px, py)
+        for i, (t, a, b) in enumerate(self._bands(layer)):
+            pt = f.u.many(t)
+            pa, pb = _ends(f.v, a), _ends(f.v, b)
+            for k in range(len(pt) - 1):
+                lo_t, hi_t = sorted((pt[k], pt[k + 1]))
+                if lo_t <= u <= hi_t:
+                    ya = pa if isinstance(pa, float) else pa[k]
+                    yb = pb if isinstance(pb, float) else pb[k]
+                    if min(ya, yb) <= v <= max(ya, yb):
+                        return i
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Rectangles
+# ---------------------------------------------------------------------------
+
+def _touches(rect: Any, width: float, box: Any) -> bool:
+    """Whether the outline of ``rect`` (``width``) reaches into ``box``."""
+    h = width / 2
+    return (box[0] < rect[2] + h and box[2] > rect[0] - h
+            and box[1] < rect[3] + h and box[3] > rect[1] - h)
+
+
+class _Boxes:
+    """Seam boxes indexed by their left edge, for the rectangles' outlines they cut."""
+
+    def __init__(self, boxes: list[Any]) -> None:
+        import bisect
+        self.boxes = sorted(boxes)
+        self.x0 = [b[0] for b in self.boxes]
+        self.wide = max((b[2] - b[0] for b in self.boxes), default=0.0)
+        self._bisect = bisect
+
+    def near(self, rect: Any, width: float) -> list[Any]:
+        """The boxes the outline of ``rect`` may reach (``_touches`` decides)."""
+        h = width / 2
+        lo = self._bisect.bisect_left(self.x0, rect[0] - h - self.wide)
+        hi = self._bisect.bisect_right(self.x0, rect[2] + h)
+        return [b for b in self.boxes[lo:hi] if _touches(rect, width, b)]
+
+
+class Rects(Geom):
+    """Rectangles ``[x0, x1] × [y0, y1]`` (bars, histogram bins, box bodies, interval
+    features, genome signal bars).  Paint: ``fill`` (one or per item), ``stroke``,
+    ``line_width``, ``simplify``; with ``seams`` (bars) ``seam`` (the color where outlined
+    rectangles touch) and ``stack``.  Options: ``seams`` (outlines of all the plot's seamed
+    layers cut where they touch), ``min_width`` (px along x), ``inset`` (outlines inside
+    the rectangles), ``each`` (one path per rectangle: box bodies, whose colors keep full
+    precision), ``drop_empty`` (rectangles without height left out), ``glyph``
+    (``"swatch"``)."""
+
+    OPTIONS = ("min_width", "drop_empty", "seams", "each", "inset")
+
+    CHANNELS = {"x": ("x0", "x1"), "y": ("y0", "y1")}
+    ENDS = ("x0", "x1", "y0", "y1")
+
+    def page_rects(self, ctx: Any, layer: Any) -> list[tuple[float, float, float, float, bool]]:
+        """Page rectangles ``(x0, y0, x1, y1, negative)``: ``negative`` when ``y1 < y0``."""
+        f = ctx.frame(layer)
+        x0, x1, y0, y1 = (layer.col(c) for c in ("x0", "x1", "y0", "y1"))
+        if x0 is None or not len(x0):
+            return []
+        a0, a1 = self.mapped(f.u, x0, "x0"), self.mapped(f.u, x1, "x1")
+        v0, v1 = self.mapped(f.v, y0, "y0"), self.mapped(f.v, y1, "y1")
+        n = len(x0)
+
+        def at(c: Any, i: int) -> float:
+            return c if isinstance(c, float) else c[i]
+
+        mw = layer.options.get("min_width", 0.0)
+        ys0 = y0 if not _is_const(y0) else None
+        ys1 = y1 if not _is_const(y1) else None
+        out = []
+        for i in range(n):
+            pa, pb = at(a0, i), at(a1, i)
+            if mw:
+                pa, pb = min(pa, pb), max(pa, pb)
+                if pb - pa < mw:
+                    c = (pa + pb) / 2
+                    pa, pb = c - mw / 2, c + mw / 2
+            qa, qb = at(v0, i), at(v1, i)
+            neg = (ys1[i] if ys1 is not None else y1) < (ys0[i] if ys0 is not None else y0)
+            if f.flip:
+                out.append((min(qa, qb), min(pa, pb), max(qa, qb), max(pa, pb), neg))
+            else:
+                out.append((min(pa, pb), min(qa, qb), max(pa, pb), max(qa, qb), neg))
+        return out
+
+    def kept(self, layer: Any, rects: list[Any]) -> list[int]:
+        """The rectangles drawn: finite ones, and with ``drop_empty`` those of some height
+        (histogram bins without values are left out)."""
+        keep = [i for i, r in enumerate(rects) if all(math.isfinite(v) for v in r[:4])]
+        if layer.options.get("drop_empty"):
+            y0, y1 = layer.col("y0"), layer.col("y1")
+            keep = [i for i in keep if y0[i] != y1[i]]
+        return keep
+
+    def draw(self, ctx: Any, layer: Any) -> None:
+        p = layer.style(ctx)
+        if layer.options.get("seams"):
+            _, _, pages = self._seam_plan(ctx)
+            rects = pages.get(layer.table.origin)
+            self._draw_seamed(ctx, layer, p, rects if rects is not None
+                              else self.page_rects(ctx, layer))
+            return
+        rects = self.page_rects(ctx, layer)
+        keep = self.kept(layer, rects)
+        fill, stroke = p.get("fill"), p.get("stroke")
+        lw = p.get("line_width")
+        if not keep or (fill is None and stroke is None and "stroke" in p):
+            return
+        xs = array.array("d", (rects[i][0] for i in keep))
+        ys = array.array("d", (rects[i][1] for i in keep))
+        ws = array.array("d", (rects[i][2] - rects[i][0] for i in keep))
+        hs = array.array("d", (rects[i][3] - rects[i][1] for i in keep))
+        if len(keep) != len(rects):
+            fill = [fill[i] for i in keep] if isinstance(fill, list) else fill
+            stroke = [stroke[i] for i in keep] if isinstance(stroke, list) else stroke
+        if layer.options.get("each"):
+            # one path per rectangle, filled then outlined (colors at full precision:
+            # vec_io's draw_rects writes 4 decimals)
+            canvas = ctx.canvas
+            for k in range(len(xs)):
+                f = fill[k] if isinstance(fill, list) else fill
+                c = stroke[k] if isinstance(stroke, list) else stroke
+                path = vec_io.Path().rect(xs[k], ys[k], ws[k], hs[k])
+                if f is not None:
+                    canvas.draw_path(path, fill=f, stroke=None)
+                if c is not None and lw:
+                    canvas.stroke_width = lw
+                    canvas.draw_path(path, fill=None, stroke=c)
+            return
+        if layer.options.get("inset") and stroke is not None:
+            # the outline inside the rectangle: one narrower than two borders is one line
+            # of `line_width`, its left and right borders overlapping
+            h = lw / 2
+            xs = array.array("d", [x + min(h, w / 2) for x, w in zip(xs, ws)])
+            ys = array.array("d", [y + min(h, v / 2) for y, v in zip(ys, hs)])
+            ws = array.array("d", [max(0.0, w - lw) for w in ws])
+            hs = array.array("d", [max(0.0, v - lw) for v in hs])
+        kw: dict[str, Any] = {}
+        for name in ("simplify", "opacity"):
+            if name in p:
+                kw[name] = p[name]
+        if "stroke" in p:                   # else the canvas' stroke style
+            kw["stroke"] = stroke
+            kw["stroke_width"] = lw
+        ctx.canvas.draw_rects(xs, ys, ws, hs, fill=fill, **kw)
+
+    # -- seams (bars) ------------------------------------------------------------------
+
+    @staticmethod
+    def _seam_plan(ctx: Any) -> tuple[dict[int, tuple[list[Any], list[Any]]], Any,
+                                      dict[int, list[Any]]]:
+        """The seams and the lines between stacked parts ``(segment, color)`` each seamed
+        layer of the plot draws (by ``id`` of its table), and the boxes all of them cover,
+        which outlines leave out.  Rectangles whose outlines have different widths get no
+        seam.  Layers in drawing order; computed once per context."""
+        from ..seams import rect_contacts, seam_box
+        root = ctx.root
+        cache = root.__dict__.get("_seams")
+        if cache is not None:
+            return cache
+        from .pipeline import drawn_layers
+        lines: dict[int, tuple[list[Any], list[Any]]] = {}
+        known: dict[int, set[Any]] = {}                    # the seams of each table, as a set
+        pages: dict[int, list[Any]] = {}                   # page rectangles of each table
+        boxes: list[Any] = []
+        drawn: list[Any] = []                              # outlined rectangles so far
+        colors: list[Any] = []                             # their outline colors
+        for call, layer in drawn_layers(ctx.plot):
+            if not layer.options.get("seams"):
+                continue
+            c = root.for_call(call)
+            lay = layer.columns(c)
+            p = lay.style(c)
+            lc, lw = p.get("stroke"), p.get("line_width")
+            if lc is None or not lw:
+                continue
+            rects = RECTS.page_rects(c, lay)
+            pages[layer.table.origin] = rects
+            keep = [i for i, r in enumerate(rects) if all(math.isfinite(v) for v in r[:4])]
+            mine = [(*rects[i][:4], lw) for i in keep]
+            seam = p.get("seam")
+            stack = bool(p.get("stack"))
+            seams, ends = lines.setdefault(layer.table.origin, ([], []))
+            seen = known.setdefault(layer.table.origin, set())
+            for seg, j in rect_contacts(mine, drawn):
+                if (drawn[j] if j < len(drawn) else mine[j - len(drawn)])[4] != lw:
+                    continue        # outlines of another width: both stay whole
+                if stack and j < len(drawn) and (seg[0] == seg[2]) == layer.flip:
+                    # on an earlier part of the stack: the line between keeps its color
+                    if colors[j] is not None:
+                        ends.append((seg, colors[j]))
+                        boxes.append(seam_box(seg, square=True))
+                elif seg not in seen:
+                    seen.add(seg)
+                    seams.append(seg)
+                    if seam is not None:
+                        boxes.append(seam_box(seg))
+            drawn.extend(mine)
+            colors.extend([lc[i] for i in keep] if isinstance(lc, list) else [lc] * len(keep))
+        out = (lines, _Boxes(boxes), pages)
+        root.__dict__["_seams"] = out
+        return out
+
+    def _draw_seamed(self, ctx: Any, layer: Any, p: dict[str, Any], rects: list[Any]) -> None:
+        from ..seams import draw_seams, outline_pieces
+        from ..shapes import draw_rects, draw_polygons
+        fills: Any = p.get("fill")
+        lc: Any = p.get("stroke")
+        width = p.get("line_width")
+        lw: float = width if width else 0.0
+        simplify = p.get("simplify")
+        keep = [i for i, r in enumerate(rects) if all(math.isfinite(v) for v in r[:4])]
+        lines, boxes, _ = self._seam_plan(ctx)
+        seams, ends = lines.get(layer.table.origin, ([], []))
+        canvas = ctx.canvas
+        stroke = [lc[i] for i in keep] if isinstance(lc, list) else [lc] * len(keep)
+        rs = [rects[i][:4] for i in keep]
+        near = [boxes.near(r, lw) if lc is not None and lw else [] for r in rs]
+        cut = [k for k in range(len(rs)) if near[k]]
+        cut_set = set(cut)
+        whole = [k for k in range(len(rs)) if k not in cut_set]
+        draw_rects(canvas, [rs[k][0] for k in whole], [rs[k][1] for k in whole],
+                   [rs[k][2] - rs[k][0] for k in whole], [rs[k][3] - rs[k][1] for k in whole],
+                   fill=[fills[keep[k]] for k in whole],
+                   stroke=[stroke[k] for k in whole] if lc is not None else None,
+                   stroke_width=lw or None, simplify=simplify)
+        if cut:
+            # outlines under seams are left out of the geometry, one path per rectangle
+            draw_rects(canvas, [rs[k][0] for k in cut], [rs[k][1] for k in cut],
+                       [rs[k][2] - rs[k][0] for k in cut], [rs[k][3] - rs[k][1] for k in cut],
+                       fill=[fills[keep[k]] for k in cut], simplify=simplify)
+            polys, colors = [], []
+            for k in cut:
+                pieces = outline_pieces(rs[k], lw, near[k])
+                if pieces and stroke[k] is not None:
+                    polys.append([([q[0], q[2], q[2], q[0]], [q[1], q[1], q[3], q[3]])
+                                  for q in pieces])
+                    colors.append(stroke[k])
+            draw_polygons(canvas, polys, fill=colors, simplify=simplify)
+        draw_seams(canvas, seams, p.get("seam"))
+        if ends:
+            canvas.draw_segments(*([s[k] for s, _ in ends] for k in range(4)),
+                                 stroke=[c for _, c in ends],
+                                 stroke_width=[s[4] for s, _ in ends], stroke_linecap="square")
+
+    def part(self, layer: Any) -> tuple[str, Any] | None:
+        return "rect", ()
+
+    def occupy(self, ctx: Any, layer: Any, occ: Any) -> None:
+        rects = [r for r in self.page_rects(ctx, layer) if all(math.isfinite(v) for v in r[:4])]
+        if rects:
+            occ.rects([r[0] for r in rects], [r[1] for r in rects], [r[2] for r in rects],
+                      [r[3] for r in rects])
+
+    def hit(self, ctx: Any, layer: Any, px: float, py: float) -> int | None:
+        for i, (x0, y0, x1, y1, _) in enumerate(self.page_rects(ctx, layer)):
+            if x0 <= px <= x1 and y0 <= py <= y1:
+                return i
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Polygons
+# ---------------------------------------------------------------------------
+
+class Polygons(Geom):
+    """Filled polygons: ``rings`` (per polygon, a list of rings ``(xs, ys)`` in data
+    units, filled together), ``ring_sets`` (per polygon, vec_io ring arrays ``(xs, ys,
+    ring_starts)`` after the axis scale functions), ``page_paths`` (vec_io ``Path``
+    objects in page units: wedges), or one ``shape`` repeated at ``x``/``y`` page centres
+    (hexagons, drawn as markers).  Paint: ``fill``, ``stroke``, ``line_width``,
+    ``opacity``, ``simplify``; with ``outlines`` (paths stroked instead of the polygons'
+    outlines) and ``seams`` (segments in ``seam`` color).  Options: ``glyph``
+    (``"swatch"``, ``"hexagon"``)."""
+
+    OPTIONS = ("glyph",)
+
+    CHANNELS = {"x": ("x",), "y": ("y",)}
+
+    def extent(self, layer: Any, role: str, scale: Any) -> tuple[int, float, float]:
+        rings = layer.col("rings")
+        if rings is None:
+            return 0, math.nan, math.nan
+        count, lo, hi = 0, math.inf, -math.inf
+        k = 0 if role == "x" else 1
+        for poly in rings:
+            for ring in poly:
+                n, a, b = kernels.extent(ring[k], scale.function)
+                if n:
+                    count += n
+                    lo, hi = min(lo, a), max(hi, b)
+        return (count, lo, hi) if count else (0, math.nan, math.nan)
+
+    def values(self, layer: Any, role: str) -> Any:
+        return None
+
+    def draw(self, ctx: Any, layer: Any) -> None:
+        p = layer.style(ctx)
+        canvas = ctx.canvas
+        kw: dict[str, Any] = {}
+        if "simplify" in p:
+            kw["simplify"] = p["simplify"]
+        shape = layer.col("shape")
+        if shape is not None:
+            xs, ys = layer.col("x"), layer.col("y")
+            if not len(xs):
+                return
+            canvas.draw_markers(xs, ys, marker=shape, size=layer.col("size"),
+                                fill=p.get("fill"), stroke=p.get("stroke"),
+                                stroke_width=p.get("line_width"), opacity=p.get("opacity", 1.0),
+                                **kw)
+            return
+        paths = layer.col("page_paths")
+        if paths is not None:
+            self._paths(canvas, p, paths, kw)
+            return
+        sets = layer.col("ring_sets")
+        if sets is not None:
+            from ..shapes import fill_ring_sets
+            f = ctx.frame(layer)
+            xm, ym = f.u, f.v
+            mapped = [(kernels.scaled(xs, xm.a, xm.b), kernels.scaled(ys, ym.a, ym.b), st)
+                      for xs, ys, st in sets]
+            fill_ring_sets(canvas, mapped, p.get("fill"), **kw)
+            return
+        rings = layer.col("rings")
+        if not rings:
+            return
+        from ..shapes import draw_polygons
+        f = ctx.frame(layer)
+        polys = [[f.page(f.u.many(rx), f.v.many(ry)) for rx, ry in poly] for poly in rings]
+        if p.get("stroke") is not None:
+            kw["stroke"] = p["stroke"]
+            kw["stroke_width"] = p.get("line_width")
+        draw_polygons(canvas, polys, fill=p.get("fill"), **kw)
+
+    @staticmethod
+    def _paths(canvas: Canvas, p: dict[str, Any], paths: list[Any], kw: dict[str, Any]) -> None:
+        from ..seams import draw_seams
+        fills: Any = p.get("fill")
+        strokes: Any = p.get("stroke")
+        lw: Any = p.get("line_width")
+        outlines = p.get("outlines")
+        if outlines is None:
+            if paths:
+                canvas.draw_polygons(paths, fill=fills, stroke=strokes if lw else None,
+                                     stroke_width=lw or None, **kw)
+            return
+        # outlines under seams are left out of the geometry (not painted over), so none
+        # shows through a seam's anti-aliased edges
+        canvas.draw_polygons(paths, fill=fills, stroke=None, **kw)
+        with canvas.state():
+            canvas.stroke_width = lw
+            for path, stroke in zip(outlines, strokes):
+                if stroke is not None:
+                    canvas.draw_path(path, fill=None, stroke=stroke)
+        draw_seams(canvas, p.get("seams") or [], p.get("seam"))
+
+    def part(self, layer: Any) -> tuple[str, Any] | None:
+        return "polygon", (("form", layer.options.get("glyph")),)
+
+    def occupy(self, ctx: Any, layer: Any, occ: Any) -> None:
+        if layer.col("shape") is not None:
+            hw, hh = layer.col("half")
+            xs, ys = layer.col("x"), layer.col("y")
+            occ.rects([x - hw for x in xs], [y - hh for y in ys], [x + hw for x in xs],
+                      [y + hh for y in ys])
+            return
+        rings = layer.col("rings")
+        if not rings:
+            return
+        f = ctx.frame(layer)
+        for poly in rings:
+            for rx, ry in poly:
+                px, py = f.page(f.u.many(rx), f.v.many(ry))
+                occ.rects([min(px)], [min(py)], [max(px)], [max(py)])
+
+    def hit(self, ctx: Any, layer: Any, px: float, py: float) -> int | None:
+        rings = layer.col("rings")
+        if not rings:
+            return None
+        f = ctx.frame(layer)
+        for i, poly in enumerate(rings):
+            inside = False
+            for rx, ry in poly:
+                xs, ys = f.page(f.u.many(rx), f.v.many(ry))
+                n = len(xs)
+                for k in range(n):
+                    x0, y0, x1, y1 = xs[k], ys[k], xs[(k + 1) % n], ys[(k + 1) % n]
+                    if (y0 > py) != (y1 > py) and px < x0 + (py - y0) * (x1 - x0) / (y1 - y0):
+                        inside = not inside
+            if inside:
+                return i
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Segments
+# ---------------------------------------------------------------------------
+
+class Segments(Geom):
+    """Segments ``(x0, y0)–(x1, y1)`` (error bars, stems, whiskers, caps, medians), or
+    ticks: segments ``tick`` px long across each point ``(x0, y0)`` (caps of error bars,
+    rugs).  Paint: ``color`` and ``width`` (one or per item), ``opacity``, ``cap``,
+    ``simplify``, ``dash`` (per item: dashed items are drawn as lines, by color, after the
+    solid ones).  Options: ``tick`` (``"u"`` or ``"v"``: the frame axis the ticks run
+    along), ``glyph`` (``"errorbar"``, ``"stem"``)."""
+
+    OPTIONS = ("tick", "glyph")
+
+    CHANNELS = {"x": ("x0", "x1"), "y": ("y0", "y1")}
+    ENDS = ("x0", "x1", "y0", "y1")         # ticks are points: theirs are not ends
+
+    def _ends(self, f: Any, layer: Any) -> tuple[Any, Any, Any, Any]:
+        """Page coordinates of the segments' ends."""
+        a0, b0 = f.page(self.mapped(f.u, layer.col("x0"), "x0"),
+                        self.mapped(f.v, layer.col("y0"), "y0"))
+        a1, b1 = f.page(self.mapped(f.u, layer.col("x1"), "x1"),
+                        self.mapped(f.v, layer.col("y1"), "y1"))
+        return a0, b0, a1, b1
+
+    def draw(self, ctx: Any, layer: Any) -> None:
+        p = layer.style(ctx)
+        if not p or p.get("color") is None:
+            return
+        f = ctx.frame(layer)
+        canvas = ctx.canvas
+        x0 = layer.col("x0")
+        if x0 is None or not len(x0):
+            return
+        tick = layer.options.get("tick")
+        kw: dict[str, Any] = {}
+        for k, name in (("opacity", "opacity"), ("simplify", "simplify"),
+                        ("cap", "stroke_linecap")):
+            if k in p:
+                kw[name] = p[k]
+        if tick is not None:
+            pu, pv = _many(f.u, x0), _many(f.v, layer.col("y0"))
+            h = p["tick"] / 2
+            if tick == "u":
+                a0, b0 = f.page(kernels.scaled(pu, 1.0, -h), pv)
+                a1, b1 = f.page(kernels.scaled(pu, 1.0, h), pv)
+            else:
+                a0, b0 = f.page(pu, kernels.scaled(pv, 1.0, -h))
+                a1, b1 = f.page(pu, kernels.scaled(pv, 1.0, h))
+            canvas.draw_segments(a0, b0, a1, b1, stroke=p.get("color"), stroke_width=p.get("width"),
+                                 **kw)
+            return
+        a0, b0, a1, b1 = self._ends(f, layer)
+        dash = p.get("dash")
+        color, width = p.get("color"), p.get("width")
+        if not isinstance(dash, list) and not isinstance(color, list) \
+                and not isinstance(width, list):
+            canvas.draw_segments(a0, b0, a1, b1, stroke=color, stroke_width=width, **kw)
+            return
+        n = len(x0)
+
+        def at(v: Any, i: int) -> Any:
+            return v[i] if isinstance(v, list) else v
+
+        def item(v: Any, i: int) -> float:
+            return v if isinstance(v, float) else v[i]
+
+        solid = [i for i in range(n) if at(dash, i) is None and at(color, i) is not None
+                 and at(width, i)]
+        if solid:
+            canvas.draw_segments([item(a0, i) for i in solid], [item(b0, i) for i in solid],
+                                 [item(a1, i) for i in solid], [item(b1, i) for i in solid],
+                                 stroke=[at(color, i) for i in solid],
+                                 stroke_width=[at(width, i) for i in solid], **kw)
+        dashed: dict[Any, tuple[list[float], list[float], Any, Any]] = {}
+        for i in range(n):
+            d, c, w = at(dash, i), at(color, i), at(width, i)
+            if d is None or c is None or not w:
+                continue
+            xs_, ys_, _, _ = dashed.setdefault(c, ([], [], w, d))
+            xs_ += [item(a0, i), item(a1, i), _nan]
+            ys_ += [item(b0, i), item(b1, i), _nan]
+        for c, (xs_, ys_, w, d) in dashed.items():
+            canvas.draw_lines(xs_, ys_, stroke=c, stroke_width=w, stroke_dasharray=dash_of(d, w), stroke_linecap="butt")
+
+    def part(self, layer: Any) -> tuple[str, Any] | None:
+        return "rule", (("form", layer.options.get("glyph")),)
+
+    def occupy(self, ctx: Any, layer: Any, occ: Any) -> None:
+        x0 = layer.col("x0")
+        if x0 is None or not len(x0) or layer.options.get("tick") is not None:
+            return
+        f = ctx.frame(layer)
+        a0, b0, a1, b1 = self._ends(f, layer)
+        xs, ys = array.array("d"), array.array("d")
+        for i in range(len(x0)):
+            xs.extend((a0 if isinstance(a0, float) else a0[i], a1 if isinstance(a1, float)
+                       else a1[i], _nan))
+            ys.extend((b0 if isinstance(b0, float) else b0[i], b1 if isinstance(b1, float)
+                       else b1[i], _nan))
+        occ.lines(xs, ys)
+
+    def hit(self, ctx: Any, layer: Any, px: float, py: float) -> int | None:
+        x0 = layer.col("x0")
+        if x0 is None or layer.options.get("tick") is not None:
+            return None
+        f = ctx.frame(layer)
+        a0, b0, a1, b1 = self._ends(f, layer)
+
+        def item(v: Any, i: int) -> float:
+            return v if isinstance(v, float) else v[i]
+
+        for i in range(len(x0)):
+            if _near_segment(px, py, item(a0, i), item(b0, i), item(a1, i), item(b1, i), 3.0):
+                return i
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Cells
+# ---------------------------------------------------------------------------
+
+class Cells(Geom):
+    """A grid of cells colored by value or given as colors (heatmaps, 2-D histograms,
+    Hi-C).  Paint: the arguments of vec_io's ``draw_cells`` (``x_edges``/``y_edges`` in
+    page units, ``fill``, ``palette``, ``bounds``, ``bad``, ``mode``, ``opacity``), with
+    ``even`` (edges evenly spaced within 1e-6 of a cell: drawn as exactly even cells) or a
+    ``transform`` placing the grid ``(0, 0)–(columns, rows)`` (Hi-C's rotated triangle).
+    The extent is the call's (cell edges through the scale)."""
+
+    CHANNELS: dict[str, tuple[str, ...]] = {}
+
+    def draw(self, ctx: Any, layer: Any) -> None:
+        p = layer.style(ctx)
+        if p is None:
+            return
+        canvas = ctx.canvas
+        transform = p.pop("transform", None)
+        if transform is not None:
+            with canvas.state():
+                canvas.transform(*transform)
+                canvas.draw_cells(**p)
+            return
+        if p.pop("even"):
+            p["x_edges"], p["y_edges"] = _even_edges(p["x_edges"]), _even_edges(p["y_edges"])
+        elif p.get("mode") == "image":
+            p["mode"] = "cells"
+        canvas.draw_cells(**p)
+
+    def occupy(self, ctx: Any, layer: Any, occ: Any) -> None:
+        x0, y0, x1, y1 = ctx.rect
+        occ.rects([x0], [y0], [x1], [y1])
+
+    def hit(self, ctx: Any, layer: Any, px: float, py: float) -> int | None:
+        p = layer.style(ctx)
+        if p is None or p.get("transform") is not None:
+            return None
+        xe, ye = p["x_edges"], p["y_edges"]
+        cols = len(xe) - 1
+        for r in range(len(ye) - 1):
+            if ye[r] <= py <= ye[r + 1]:
+                for c in range(cols):
+                    if xe[c] <= px <= xe[c + 1]:
+                        return r * cols + c
+        return None
+
+
+def _even_edges(e: Any) -> list[float]:
+    """Edges evenly spaced from ``e[0]`` to ``e[-1]`` (both kept exactly)."""
+    n = len(e) - 1
+    a, b = e[0], e[-1]
+    return [a + (b - a) * j / n for j in range(n)] + [b]
+
+
+# ---------------------------------------------------------------------------
+# Text
+# ---------------------------------------------------------------------------
+
+class Text(Geom):
+    """Labels at points: ``page_x``/``page_y`` (page units, placed once the axes are known:
+    value labels, cell labels, contour and wedge labels, gene names) or ``x``/``y`` (data).
+    Columns ``text`` and optionally ``color`` (per label), ``ha``, ``va``, ``angle``;
+    ``boxes`` (a background rectangle ``(w, h)`` behind each label, rotated with it) and
+    ``leaders`` (a line ``(x0, y0, x1, y1, …)`` through its points, drawn before each
+    label, or ``None``).  Paint: ``font``, ``background``, ``ha``/``va``/``angle`` for all
+    labels."""
+
+    CHANNELS: dict[str, tuple[str, ...]] = {}
+
+    def _positions(self, ctx: Any, layer: Any) -> tuple[Any, Any]:
+        px = layer.col("page_x")
+        if px is not None:
+            return px, layer.col("page_y")
+        f = ctx.frame(layer)
+        return f.page(_many(f.u, layer.col("x")), _many(f.v, layer.col("y")))
+
+    def draw(self, ctx: Any, layer: Any) -> None:
+        from ..text import draw_text
+        p = layer.style(ctx)
+        texts = layer.col("text")
+        if not texts:
+            return
+        canvas = ctx.canvas
+        xs, ys = self._positions(ctx, layer)
+        font = p["font"]
+        colors, has, vas = layer.col("color"), layer.col("ha"), layer.col("va")
+        angles, boxes, leaders = layer.col("angle"), layer.col("boxes"), layer.col("leaders")
+        for i, text in enumerate(texts):
+            if text is None or not (math.isfinite(xs[i]) and math.isfinite(ys[i])):
+                continue
+            ang = (angles[i] if angles is not None else None) or p.get("angle", 0.0)
+            if leaders is not None and leaders[i] is not None and all(
+                    math.isfinite(v) for v in leaders[i]):
+                pts = leaders[i]
+                canvas.draw_lines(list(pts[0::2]), list(pts[1::2]), stroke=font.color,
+                                  stroke_width=0.5)
+            if boxes is not None and boxes[i] is not None:
+                bw, bh, pad = boxes[i]
+                with canvas.state():
+                    canvas.translate(xs[i], ys[i])
+                    canvas.rotate(-ang)
+                    canvas.fill = p["background"]
+                    canvas.draw_rect(-bw / 2 - pad, -bh / 2, bw + 2 * pad, bh, stroke=None)
+            f = font.with_color(colors[i]) if colors is not None else font
+            ha = has[i] if has is not None else p.get("ha", "center")
+            va = vas[i] if vas is not None else p.get("va", "center")
+            if ang:
+                draw_text(canvas, text, xs[i], ys[i], f, ha, va, ang)
+            else:
+                draw_text(canvas, text, xs[i], ys[i], f, ha, va)
+
+    def _boxes(self, ctx: Any, layer: Any) -> list[tuple[float, float, float, float]]:
+        from ..text import measure
+        p = layer.style(ctx)
+        texts = layer.col("text") or []
+        xs, ys = self._positions(ctx, layer)
+        out = []
+        for i, text in enumerate(texts):
+            if text is None or not (math.isfinite(xs[i]) and math.isfinite(ys[i])):
+                continue
+            w, a, d = measure(ctx.canvas, text, p["font"])
+            out.append((xs[i] - w / 2, ys[i] - (a + d) / 2, xs[i] + w / 2, ys[i] + (a + d) / 2))
+        return out
+
+    def occupy(self, ctx: Any, layer: Any, occ: Any) -> None:
+        boxes = self._boxes(ctx, layer)
+        if boxes:
+            occ.rects(*([b[k] for b in boxes] for k in range(4)))
+
+    def hit(self, ctx: Any, layer: Any, px: float, py: float) -> int | None:
+        for i, (x0, y0, x1, y1) in enumerate(self._boxes(ctx, layer)):
+            if x0 <= px <= x1 and y0 <= py <= y1:
+                return i
+        return None
+
+
+#: The rectangles geom (its page rectangles place value labels).
+RECTS = Rects()
+#: One instance of each geom (geoms hold no state).
+#: Layer options read for every geom: ``bounds`` (``False``: not in the axes' limits),
+#: ``segment`` (the genome segment it is drawn in), ``occupy_aes`` (the channels the legend
+#: placement reads).
+LAYER_OPTIONS = ("bounds", "segment", "occupy_aes")
+
+GEOMS: dict[str, Geom] = {"points": Points(), "path": Path(), "band": Band(), "rects": RECTS,
+                          "polygons": Polygons(), "segments": Segments(), "cells": Cells(),
+                          "text": Text()}