plot-io 0.1.0__py3-none-any.whl

plot_io/series/hexbin.py

@@ -0,0 +1,216 @@
+"""Hexagonal 2-D histograms: counts of points in hexagons, colored by a map."""
+
+import array
+import math
+from typing import Any
+
+import pdf_io
+from pdf_io import arrays as _arrays
+
+from .. import _backend
+from ..maps import ColorMap, check_cmap
+from ..limits import check_limits
+from ..scales import NUMERIC_SCALES, get_scale
+from ..settings import Setting, color, either, literal, number, one_of, table
+from ..style import with_alpha
+from . import Series, common
+from .points import map_colors
+
+__all__ = ["Hexbin"]
+
+
+_S3 = math.sqrt(3.0)
+
+
+class Hexbin(Series):
+    """A hexagonal 2-D histogram of points ``(x, y)``: ``gridsize`` regular hexagons across
+    the axes width.  The lattice is laid out in page units once the axes are placed, so the
+    hexagons are regular and tile exactly whatever the axes' aspect."""
+
+    SETTINGS = table(
+        gridsize=Setting(number(lo=1, integer=True), doc="Hexagons across the axes width."),
+        weights=Setting(lambda v: _backend.doubles(v), doc="A weight per point (sums)."),
+        stat=Setting(one_of("count", "probability", "percent"),
+                     doc="`count`, `probability` or `percent`."),
+        min_count=Setting(number(lo=0), doc="Hexagons below this count are not drawn."),
+        color_map=Setting(check_cmap, inherited=True, doc="A `ColorMap`, a map name or colors."),
+        color_limits=Setting(check_limits, doc="Override of the map's limits."),
+        color_scale=Setting(one_of(*NUMERIC_SCALES), doc="Override of the map's scale."),
+        line_color=Setting(color, doc="Hexagon outline color; default none."),
+        line_width=Setting(number(lo=0), doc="Outline width (pt).", length=True),
+        colorbar=Setting(either(literal(False), literal(True)),
+                         doc="Attach a colorbar to the plot."),
+        **common("name", "alpha", "z", "rasterize", "simplify", "font_size", "font_family",
+                 "text_color"),
+    )
+    USES_PALETTE = False
+
+    def __init__(self, x: Any, y: Any, plot: Any = None, **settings: Any) -> None:
+        self.px, self.py = _backend.doubles(x), _backend.doubles(y)
+        if len(self.px) != len(self.py):
+            raise ValueError(f"x has {len(self.px)} values and y {len(self.py)}")
+        self._map: Any = None
+        self._map_key: Any = None
+        self._bar: Any = None
+        #: The page frame the lattice is laid out in (set by the layout once the axes are
+        #: placed): ``(function_x, a_x, b_x, function_y, a_y, b_y, width, height)``, page
+        #: coordinates relative to the axes' top-left corner being ``a·f(v) + b``.
+        self._frame: Any = None
+        super().__init__(plot=plot, **settings)
+        if self.get("colorbar"):
+            self._bar = self.plot.colorbar(self)
+
+    @staticmethod
+    def _frame_of(ctx: Any) -> tuple:
+        x0, y0, x1, y1 = ctx.rect
+        xm, ym = ctx.xmap, ctx.ymap
+        return (xm.function, xm.a, xm.b - x0, ym.function, ym.a, ym.b - y0, x1 - x0, y1 - y0)
+
+    @staticmethod
+    def _same(f: tuple, g: tuple) -> bool:
+        return f[0] == g[0] and f[3] == g[3] and all(
+            abs(a - b) <= 1e-6 * max(1.0, abs(a), abs(b))
+            for a, b in zip(f[1:3] + f[4:], g[1:3] + g[4:]))
+
+    def set_frame(self, ctx: Any) -> bool:
+        """Lays the lattice out for the placed axes; whether that changed it."""
+        f = self._frame_of(ctx)
+        if self._frame is not None and self._same(f, self._frame):
+            return False
+        self._frame = f
+        return True
+
+    def _guess_frame(self) -> tuple:
+        """A frame before the axes are placed: the data range over the nominal plot size."""
+        fig = self.plot.figure
+        k = fig.points_per_unit
+        w = fig.get("plot_width") * k
+        h = fig.get("plot_height") * k
+        out: list[Any] = []
+        for axis, values, (p0, p1) in ((self.plot.x_axis, self.px, (0.0, w)),
+                                        (self.plot.y_axis, self.py, (h, 0.0))):
+            name = axis.nominal_scale
+            sc = get_scale("linear" if name == "category" else name)
+            n, lo, hi = _backend.extent(values, sc.function)
+            if not n:
+                lo, hi = 0.0, 1.0
+            if hi == lo:
+                lo, hi = lo - 0.5, hi + 0.5
+            frac = axis.get("padding")
+            pad = (axis.get("auto_padding") if frac == "auto" else frac) * (hi - lo)
+            lo, hi = lo - pad, hi + pad
+            a = (p1 - p0) / (hi - lo)
+            out += [sc.function, a, p0 - a * lo]
+        return (*out, w, h)
+
+    @property
+    def stats(self) -> dict[str, Any]:
+        """``{"x", "y": hexagon centres (page units, relative to the axes' top-left corner),
+        "values", "dx": hexagon width (pt)}``."""
+        frame = self._frame or self._guess_frame()
+        return self.cached(("stats", frame), lambda: self._compute(frame))
+
+    def _compute(self, frame: tuple) -> dict[str, Any]:
+        fx, ax, bx, fy, ay, by, w, h = frame
+        nx = self.get("gridsize")
+        dx = w / nx
+        dy = _S3 * dx
+        nan = math.nan
+        u = _backend.scaled(self.px, ax, bx, fx)
+        v = _backend.scaled(self.py, ay, by, fy)
+        # Points outside the axes are not counted.
+        u = _backend.scaled(u, 1.0, 0.0, None, low=0.0, high=w, under=nan, over=nan)
+        v = _backend.scaled(v, 1.0, 0.0, None, low=0.0, high=h, under=nan, over=nan)
+        ny = int(h / dy) + 2
+        cx, cy, cs = _arrays.hexbin(u, v, 0.0, 0.0, dx, dy, nx + 1, ny, self.get("weights"))
+        total = math.fsum(cs)
+        mc = self.get("min_count")
+        keep = [i for i in range(len(cs)) if cs[i] >= mc and cs[i] > 0]
+        st = self.get("stat")
+        k = 1.0 if st == "count" else ((100.0 if st == "percent" else 1.0) / (total or 1.0))
+        return {"x": array.array("d", (cx[i] for i in keep)),
+                "y": array.array("d", (cy[i] for i in keep)),
+                "values": array.array("d", (cs[i] * k for i in keep)), "dx": dx}
+
+    @staticmethod
+    def hexagon(dx: float) -> list[tuple[float, float]]:
+        """Vertices of the regular hexagon (pointy top) of width ``dx`` centred on 0."""
+        r = dx / _S3
+        return [(0.5 * dx, -0.5 * r), (0.5 * dx, 0.5 * r), (0.0, r), (-0.5 * dx, 0.5 * r),
+                (-0.5 * dx, -0.5 * r), (0.0, -r)]
+
+    def color_map(self) -> ColorMap:
+        cmap, lim, sc = self.get("color_map"), self.get("color_limits"), self.get("color_scale")
+        key = (id(cmap) if isinstance(cmap, ColorMap) else repr(cmap), lim, sc)
+        if self._map is None or self._map_key != key:
+            if isinstance(cmap, ColorMap) and lim is None and sc is None:
+                self._map = cmap
+            else:
+                base = cmap if isinstance(cmap, ColorMap) else ColorMap(cmap)
+                self._map = ColorMap(base, limits=lim if lim is not None else base.limits,
+                                     scale=sc or base.scale)
+            self._map_key = key
+        return self._map
+
+    def color_sources(self) -> list[tuple[Any, Any]]:
+        return [(self.color_map(), self.stats["values"])]
+
+    def has_own_color(self) -> bool:
+        return True
+
+    def values(self, role: str) -> Any:
+        return self.px if role == "x" else self.py
+
+    def legend_points(self) -> tuple[Any, Any]:
+        return self.px, self.py
+
+    def occupy(self, ctx: Any, occ: Any) -> None:
+        st = self._page_stats(ctx)
+        x0, y0 = ctx.rect[0], ctx.rect[1]
+        hw, hh = st["dx"] / 2, st["dx"] / _S3
+        occ.rects([x0 + x - hw for x in st["x"]], [y0 + y - hh for y in st["y"]],
+                  [x0 + x + hw for x in st["x"]], [y0 + y + hh for y in st["y"]])
+
+    def _page_stats(self, ctx: Any) -> dict[str, Any]:
+        frame = self._frame_of(ctx)
+        if self._frame is not None and self._same(frame, self._frame):
+            return self.stats
+        # Placed differently than laid out (e.g. one plot saved alone): recount; the colors
+        # keep the map limits resolved before.
+        return self.cached(("stats", frame), lambda: self._compute(frame))
+
+    def draw(self, ctx: Any) -> None:
+        st = self._page_stats(ctx)
+        if not len(st["x"]):
+            return
+        dx = st["dx"]
+        path = pdf_io.Path()
+        pts = [(x / dx, y / dx) for x, y in self.hexagon(dx)]
+        path.move_to(*pts[0])
+        for p in pts[1:]:
+            path.line_to(*p)
+        path.close()
+        cmap = self.color_map()
+        fills = map_colors(cmap, st["values"], ctx.maps[id(cmap)])
+        a = self.get("alpha")
+        lc = ctx.color(self.get("line_color"))
+        lw = self.get("line_width")
+        x0, y0 = ctx.rect[0], ctx.rect[1]
+        # The hexagons are drawn 0.2 % larger than the lattice so that anti-aliased seams
+        # between neighbours don't show; the lattice itself tiles exactly.
+        ctx.canvas.draw_markers(_backend.scaled(st["x"], 1.0, x0),
+                                _backend.scaled(st["y"], 1.0, y0), marker=path,
+                                size=dx * 1.002, fill=fills,
+                                stroke=lc if lw and lc is not None else None,
+                                line_width=lw or None, opacity=1.0 if a is None else a,
+                                simplify=self.simplify_arg())
+
+    def legend_colors(self, ctx: Any) -> tuple[Any, Any]:
+        cmap = self.color_map()
+        return with_alpha(cmap(0.6), self.get("alpha")), None
+
+    def legend_glyph(self, ctx: Any, x: float, y: float, w: float, h: float) -> None:
+        fill, _ = self.legend_colors(ctx)
+        ctx.canvas.draw_markers([x + w / 2], [y + h / 2], marker="M0.5 -0.29 L0.5 0.29 L0 "
+                                "0.58 L-0.5 0.29 L-0.5 -0.29 L0 -0.58 Z", size=h * 0.9,
+                                fill=fill, stroke=None)

plot_io/series/hist.py

@@ -0,0 +1,379 @@
+"""Histograms: counts (or densities…) of values in bins, as bars or steps."""
+
+import array
+import math
+from typing import Any
+
+from .. import _backend, stats
+from ..labels import bar_labels, check_labels
+from ..numbers import NumberStyle, check_format, format_numbers, number_settings
+from ..scales import get_scale
+from ..settings import Setting, boolean, color, either, literal, number, one_of, pair, table
+from ..shapes import draw_rects, fill_polygons
+from ..stacking import check_stack, stacked
+from ..style import desaturate, with_alpha
+from ..text import Font
+from . import Series, common
+from .points import colors_only
+
+__all__ = ["Hist", "value_sets"]
+
+
+def value_sets(values: Any) -> tuple[list[tuple[Any, Any]], bool]:
+    """``([(name, doubles)], named)`` of one array, a dict or a list of arrays."""
+    if isinstance(values, dict):
+        return [(k, _backend.doubles(v)) for k, v in values.items()], True
+    if isinstance(values, (list, tuple)) and values and all(
+            hasattr(v, "__len__") and not isinstance(v, str) for v in values):
+        return [(i, _backend.doubles(v)) for i, v in enumerate(values)], False
+    try:
+        mv = memoryview(values)
+        if mv.ndim == 2:
+            from pdf_io import arrays
+            return [(i, r) for i, r in enumerate(arrays.rows(values))], False
+    except TypeError:
+        pass
+    return [(0, _backend.doubles(values))], False
+
+
+def _weights(v: Any) -> Any:
+    if isinstance(v, dict):
+        return {k: _backend.doubles(x) for k, x in v.items()}
+    if isinstance(v, (list, tuple)) and v and all(hasattr(x, "__len__") for x in v):
+        return [_backend.doubles(x) for x in v]
+    return _backend.doubles(v)
+
+
+_STATS = ("count", "density", "probability", "percent", "frequency")
+
+
+class Hist(Series):
+    """A histogram of ``values``: one array, or several (a dict or a list of arrays) that
+    share the same bins."""
+
+    SETTINGS = table(
+        bins=Setting(stats.check_bins,
+                     doc="A count, edges, or a rule: `auto`, `fd`, `sturges`, `scott`, `sqrt`, "
+                         "`rice`, `doane` (numpy's)."),
+        range=Setting(either(literal(None), pair(number())), doc="Range of the bins; default "
+                                                                 "the data range."),
+        weights=Setting(_weights, doc="A weight per value (per set for several sets)."),
+        stat=Setting(one_of(*_STATS),
+                     doc="`count`, `density` (area 1), `probability`, `percent` or "
+                         "`frequency` (count per unit)."),
+        cumulative=Setting(boolean, doc="Accumulate the bins."),
+        kind=Setting(one_of("bar", "step", "stepfilled"),
+                     doc="`bar` (adjacent bars), `step` (outline) or `stepfilled`."),
+        bins_scale=Setting(one_of("axis", "linear"),
+                           doc="`axis`: bins even on the axis scale (log axes: in log space); "
+                               "`linear`: even in data units."),
+        orientation=Setting(one_of("vertical", "horizontal"),
+                            doc="`vertical` (bins along x) or `horizontal`."),
+        stack=Setting(check_stack, doc="Stack the sets (and other stacked histograms "
+                                              "with the same bins)."),
+        dodge=Setting(boolean, doc="Put the sets side by side within each bin."),
+        color=Setting(colors_only, doc="Fill color, or one per set; default palette colors."),
+        line_color=Setting(color, doc="Outline color (bars: default none; steps: the fill "
+                                      "color)."),
+        line_width=Setting(number(lo=0), doc="Outline width (pt); default 0 for bars, 1 for "
+                                             "steps.", length=True),
+        alpha=Setting(number(0, 1), doc="Opacity; default 1, 0.5 for overlaid sets."),
+        saturation=Setting(number(0, 1), doc="Saturation of the fills."),
+        labels=Setting(check_labels, doc="Value labels on bars."),
+        label_format=Setting(check_format, doc="Number format of the labels."),
+        **common("name", "z", "rasterize", "simplify", "font_size", "font_family", "text_color"),
+        **number_settings(),
+    )
+    STACK_GROUP = "hist"
+
+    def __init__(self, values: Any, plot: Any = None, **settings: Any) -> None:
+        self.sets, self.named = value_sets(values)
+        super().__init__(plot=plot, **settings)
+
+    def _horizontal(self) -> bool:
+        return self.get("orientation") == "horizontal"
+
+    def _bin_role(self) -> str:
+        return "y" if self._horizontal() else "x"
+
+    def _bin_scale(self) -> Any:
+        if self.get("bins_scale") == "linear":
+            return get_scale("linear")
+        axis = self.plot.y_axis if self._horizontal() else self.plot.x_axis
+        name = axis.nominal_scale
+        return get_scale("linear" if name == "category" else name)
+
+    # -- statistics -------------------------------------------------------------------
+
+    @property
+    def stats(self) -> dict[str, Any]:
+        """``{"edges": bin edges, "heights": [per set], "counts": [per set]}``."""
+        scale = self._bin_scale()
+        return self.cached(("stats", scale.name), lambda: self._compute(scale))
+
+    def _compute(self, scale: Any) -> dict[str, Any]:
+        fn = scale.function
+        fsets = [_backend.scaled(v, 1.0, 0.0, fn) if fn else v for _, v in self.sets]
+        bins = self.get("bins")
+        rng = self.get("range")
+        frng = None if rng is None else (scale.f(rng[0]), scale.f(rng[1]))
+        if isinstance(bins, array.array):
+            fedges = array.array("d", (scale.f(e) for e in bins))
+        else:
+            if len(fsets) == 1:
+                allv = fsets[0]
+            else:
+                allv = array.array("d")
+                for v in fsets:
+                    allv.extend(v)
+            fedges = stats.bin_edges(allv, bins, frng)
+        edges = array.array("d", (scale.inverse(e) for e in fedges))
+        weights = self.get("weights")
+        st = self.get("stat")
+        counts, heights = [], []
+        for i, ((key, _), fv) in enumerate(zip(self.sets, fsets)):
+            w = None
+            if weights is not None:
+                w = (weights[key] if isinstance(weights, dict) else
+                     weights[i] if isinstance(weights, list) else weights)
+            c = stats.histogram(fv, fedges, w)
+            counts.append(c)
+            total = math.fsum(c)
+            widths = [b - a for a, b in zip(edges, edges[1:])]
+            if st == "count":
+                hgt = list(c)
+            elif st == "probability":
+                hgt = [x / total if total else 0.0 for x in c]
+            elif st == "percent":
+                hgt = [100.0 * x / total if total else 0.0 for x in c]
+            elif st == "frequency":
+                hgt = [x / wd for x, wd in zip(c, widths)]
+            else:
+                hgt = [x / (total * wd) if total else 0.0 for x, wd in zip(c, widths)]
+            if self.get("cumulative"):
+                acc, out = 0.0, []
+                for x, wd in zip(hgt, widths):
+                    acc += x * wd if st in ("density", "frequency") else x
+                    out.append(acc)
+                hgt = out
+            heights.append(array.array("d", hgt))
+        return {"edges": edges, "heights": heights, "counts": counts}
+
+    def stack_layers(self) -> list[tuple[list[Any], Any]]:
+        st = self.stats
+        e = st["edges"]
+        keys = [(round(a, 12), round(b, 12)) for a, b in zip(e, e[1:])]
+        return [(keys, h) for h in st["heights"]]
+
+    def _ends(self) -> list[tuple[list[float], list[float]]]:
+        if self.get("stack"):
+            return stacked(self)
+        return [([0.0] * len(h), list(h)) for h in self.stats["heights"]]
+
+    # -- axes -------------------------------------------------------------------------
+
+    def values(self, role: str) -> Any:
+        if role == self._bin_role():
+            return self.stats["edges"]
+        out = array.array("d", [0.0])
+        for b, t in self._ends():
+            out.extend(x for x in t if math.isfinite(x))
+            out.extend(x for x in b if math.isfinite(x))
+        return out
+
+    def zero_default(self, role: str) -> bool:
+        return role != self._bin_role()
+
+    def palette_count(self) -> int:
+        return len(self.sets)
+
+    def has_own_color(self) -> bool:
+        return self.is_set("color")
+
+    def legend_labels(self) -> list[Any]:
+        if self.named:
+            return [str(k) for k, _ in self.sets]
+        name = self.get("name")
+        return [] if name is None else [name]
+
+    def occupy(self, ctx: Any, occ: Any) -> None:
+        e = list(self.stats["edges"])
+        step = self.get("kind") == "step"
+        horiz = self._horizontal()
+        for bottom, top in self._ends():
+            if step:
+                t, v = [], []
+                for a, b, h in zip(e, e[1:], top):
+                    t += [a, b]
+                    v += [h, h]
+                px, py = (v, t) if horiz else (t, v)
+                occ.lines(ctx.xmap.many(px), ctx.ymap.many(py))
+                continue
+            if horiz:
+                occ.rects(ctx.xmap.many(bottom), ctx.ymap.many(e[:-1]), ctx.xmap.many(top),
+                          ctx.ymap.many(e[1:]))
+            else:
+                occ.rects(ctx.xmap.many(e[:-1]), ctx.ymap.many(bottom), ctx.xmap.many(e[1:]),
+                          ctx.ymap.many(top))
+
+    def legend_points(self) -> tuple[Any, Any] | None:
+        st = self.stats
+        e = st["edges"]
+        mids = [(a + b) / 2 for a, b in zip(e, e[1:])]
+        xs, ys = array.array("d"), array.array("d")
+        for _, t in self._ends():
+            xs.extend(mids)
+            ys.extend(t)
+        return (ys, xs) if self._horizontal() else (xs, ys)
+
+    # -- drawing ----------------------------------------------------------------------
+
+    def _alpha(self) -> float:
+        return self.get("alpha")
+
+    def set_colors(self, ctx: Any) -> list[Any]:
+        c = self.get("color")
+        n = len(self.sets)
+        if isinstance(c, list):
+            if len(c) != n:
+                raise ValueError(f"{len(c)} colors for {n} sets")
+            cols = [ctx.color(x) for x in c]
+        elif c is not None:
+            cols = [ctx.color(c)] * n
+        else:
+            cols = self.auto_colors(ctx)
+        sat = self.get("saturation")
+        return [desaturate(x, sat) if sat != 1.0 and x is not None else x for x in cols]
+
+    def draw(self, ctx: Any) -> None:
+        st = self.stats
+        edges = st["edges"]
+        horiz = self._horizontal()
+        bmap, vmap = (ctx.ymap, ctx.xmap) if horiz else (ctx.xmap, ctx.ymap)
+        kind = self.get("kind")
+        cols = self.set_colors(ctx)
+        alpha = self._alpha()
+        ends = self._ends()
+        n = len(self.sets)
+        dodge = self.get("dodge") and n > 1
+        lc = self.get("line_color")
+        if kind == "bar":
+            lw = self.get("line_width")
+            xs, ys, ws, hs, fills, rects, texts_v = [], [], [], [], [], [], []
+            for k, ((bots, tops), col) in enumerate(zip(ends, cols)):
+                fill = with_alpha(col, alpha) if col is not None else None
+                for i, (a, b) in enumerate(zip(edges, edges[1:])):
+                    lo, hi = bots[i], tops[i]
+                    if not (math.isfinite(lo) and math.isfinite(hi)) or hi == lo:
+                        continue
+                    if dodge:
+                        fa, fb = bmap.forward(a), bmap.forward(b)
+                        d = (fb - fa) / n
+                        p0, p1 = bmap.position(fa + k * d), bmap.position(fa + (k + 1) * d)
+                    else:
+                        p0, p1 = bmap(a), bmap(b)
+                    v0, v1 = vmap(lo), vmap(hi)
+                    if horiz:
+                        r = (min(v0, v1), min(p0, p1), max(v0, v1), max(p0, p1), hi < lo)
+                    else:
+                        r = (min(p0, p1), min(v0, v1), max(p0, p1), max(v0, v1), hi < lo)
+                    rects.append(r)
+                    texts_v.append(hi - lo)
+                    xs.append(r[0])
+                    ys.append(r[1])
+                    ws.append(r[2] - r[0])
+                    hs.append(r[3] - r[1])
+                    fills.append(fill)
+            stroke = ctx.color(lc) if lc is not None and lw else None
+            draw_rects(ctx.canvas, xs, ys, ws, hs, fill=fills, stroke=stroke,
+                       line_width=lw or None, simplify=self.simplify_arg())
+            self._labels = (rects, texts_v, fills)
+            return
+        lw = self.get("line_width")
+        for (bots, tops), col in zip(ends, cols):
+            outline = self._step_outline(edges, bots, tops)
+            if outline is None:
+                continue
+            (tb, tv), (bb, bv) = outline
+            if horiz:
+                top_x, top_y = vmap.many(tv), bmap.many(tb)
+                bot_x, bot_y = vmap.many(bv), bmap.many(bb)
+            else:
+                top_x, top_y = bmap.many(tb), vmap.many(tv)
+                bot_x, bot_y = bmap.many(bb), vmap.many(bv)
+            if kind == "stepfilled" and col is not None:
+                ring_x = array.array("d", top_x)
+                ring_x.extend(reversed(bot_x))
+                ring_y = array.array("d", top_y)
+                ring_y.extend(reversed(bot_y))
+                fill_polygons(ctx.canvas, [[(ring_x, ring_y)]], fill=with_alpha(col, alpha))
+            stroke = ctx.color(lc) if lc is not None else col
+            if stroke is not None and lw:
+                if kind == "step":
+                    xs_ = array.array("d", [bot_x[0]])
+                    xs_.extend(top_x)
+                    xs_.append(bot_x[-1])
+                    ys_ = array.array("d", [bot_y[0]])
+                    ys_.extend(top_y)
+                    ys_.append(bot_y[-1])
+                    ctx.canvas.draw_lines(xs_, ys_, color=stroke, width=lw)
+                else:
+                    ctx.canvas.draw_lines(top_x, top_y, color=stroke, width=lw)
+
+    def draw_overlay(self, ctx: Any) -> None:
+        where = self.get("labels")
+        lab = getattr(self, "_labels", None)
+        if not where or lab is None or self.get("kind") != "bar":
+            return
+        rects, values, fills = lab
+        texts = format_numbers(values, self.get("label_format"), NumberStyle.of(self))
+        font = Font(self.get("font_size"), self.get("font_family"),
+                    color=ctx.color(self.get("text_color")))
+        bar_labels(ctx.canvas, rects, texts, fills, where, self._horizontal(), font)
+
+    @staticmethod
+    def _step_outline(edges: Any, bots: list[float], tops: list[float]) -> Any:
+        """``((bin coords, values) of the top, (…) of the bottom)`` step polylines."""
+        tb, tv, bb, bv = (array.array("d") for _ in range(4))
+        for i, (a, b) in enumerate(zip(edges, edges[1:])):
+            lo, hi = bots[i], tops[i]
+            if not (math.isfinite(lo) and math.isfinite(hi)):
+                lo = hi = 0.0
+            tb.extend((a, b))
+            tv.extend((hi, hi))
+            bb.extend((a, b))
+            bv.extend((lo, lo))
+        if not len(tb):
+            return None
+        return (tb, tv), (bb, bv)
+
+    def legend_colors_at(self, ctx: Any, i: int) -> tuple[Any, Any]:
+        cols = self.set_colors(ctx)
+        col = cols[i] if i < len(cols) else None
+        fill = with_alpha(col, self._alpha()) if col is not None else None
+        if self.get("kind") == "step":
+            return None, col
+        lc = self.get("line_color")
+        return fill, (ctx.color(lc) if lc is not None and self.get("line_width") else None)
+
+    def legend_colors(self, ctx: Any) -> tuple[Any, Any]:
+        return self.legend_colors_at(ctx, 0)
+
+    def legend_glyph_at(self, ctx: Any, i: int, x: float, y: float, w: float, h: float) -> None:
+        fill, stroke = self.legend_colors_at(ctx, i)
+        canvas = ctx.canvas
+        if self.get("kind") == "step":
+            if stroke is not None:
+                canvas.draw_lines([x, x + w], [y + h / 2, y + h / 2], color=stroke,
+                                  width=self.get("line_width"))
+            return
+        canvas.begin_path()
+        canvas.rect(x, y, w, h)
+        if fill is not None:
+            canvas.fill(fill)
+        if stroke is not None:
+            canvas.line_width = self.get("line_width")
+            canvas.stroke(stroke)
+
+    def legend_glyph(self, ctx: Any, x: float, y: float, w: float, h: float) -> None:
+        self.legend_glyph_at(ctx, 0, x, y, w, h)