plot-io 0.1.0__py3-none-any.whl

plot_io/series/points.py

@@ -0,0 +1,341 @@
+"""Markers shared by scatter, line and box series: settings and drawing."""
+
+import array
+from typing import Any
+
+from .. import _backend
+from ..maps import ColorMap
+from ..markers import area_factor, check_marker, resolve
+from ..settings import Setting, boolean, either, number, one_of
+from ..style import resolve_color, with_alpha
+from ..values import Values, is_computed, paint, size_value
+
+__all__ = ["paint", "colors_only", "size_value", "marker_value", "marker_settings",
+           "MarkerStyle", "map_colors", "to_values", "order_settings", "order_index",
+           "permuted", "density_points"]
+
+
+def colors_only(v: Any) -> Any:
+    """A color or a list of colors (series whose colors are per value set, not mapped)."""
+    out = paint(v)
+    if isinstance(out, Values) or is_computed(out):
+        raise ValueError("expected a color or a list of colors (values to map are not "
+                         "accepted here)")
+    return out
+
+
+def marker_value(v: Any) -> Any:
+    if isinstance(v, (list, tuple)):
+        return [check_marker(m) for m in v]
+    return check_marker(v)
+
+
+def to_values(v: Any) -> Any:
+    if isinstance(v, dict):
+        return v
+    return _backend.doubles(v)
+
+
+def marker_settings(prefix: str = "") -> dict[str, Setting]:
+    """Settings of markers, named ``<prefix>marker``, ``<prefix>size``…"""
+    p = prefix
+    size_name = "size" if not p else "marker_size"
+    color_name = "color" if not p else "marker_color"
+    return {
+        "marker": Setting(marker_value,
+                          doc="Marker name, `Path` or path data, or one per point."),
+        size_name: Setting(size_value,
+                           doc="Marker size (pt): the diameter of the circle of equal area; "
+                               "one value or one per point; numbers per point are values to map "
+                               "when `size_map` is set; or `\"density\"`.", length=True),
+        color_name: Setting(lambda v: paint(v, color_name),
+                            doc="Fill: a color, colors per point, numbers per point (mapped "
+                                "through `color_map`) or `\"density\"`."),
+        f"{p}line_color": Setting(lambda v: paint(v, f"{p}line_color"),
+                                  doc="Outline: as the fill color."),
+        f"{p}line_width": Setting(number(lo=0), doc="Outline width (pt).", length=True),
+        f"{p}filled": Setting(either(boolean, number(0, 1)),
+                              doc="`True`: filled with the color; `False`: hollow, outlined "
+                                  "in the color; a number: filled at that opacity and "
+                                  "outlined in the color."),
+        "size_basis": Setting(one_of("area", "box"),
+                              doc="`area`: shapes of the same size have the same area; "
+                                  "`box`: size is the width of the shape's box."),
+    }
+
+
+def permuted(v: Any, idx: Any) -> Any:
+    """A per-point column (list, ``array('d')``, ``(n, 4)`` buffer) reordered by ``idx``
+    (gathered in C by pdf_io for numeric columns); single values unchanged."""
+    from pdf_io import arrays as _arrays
+    if isinstance(v, list):
+        return [v[i] for i in idx]
+    if isinstance(v, array.array):
+        n = len(idx)
+        if len(v) == 4 * n and n != 4:                    # flat RGBA
+            return _arrays.take(memoryview(v).cast("B").cast("d", (len(v) // 4, 4)), idx)
+        return _arrays.take(v, idx)
+    if isinstance(v, memoryview) and v.ndim == 2:
+        m: Any = v
+        k = m.shape[1]
+        out_mv: Any = memoryview(_arrays.take(m, idx)).cast("B")
+        return out_mv.cast("d", (len(idx), k))
+    return v
+
+
+def order_index(series: Any, n: int) -> Any:
+    """The drawing order of a series' ``order`` setting, or ``None`` (call order)."""
+    from ..density import Density
+    o = series.get("order")
+    if o is None:
+        return None
+    descending = False
+    if isinstance(o, str):
+        descending = o.startswith("-")
+        dens = next((series.get(k) for k in ("color", "size", "alpha")
+                     if k in series.SETTINGS and isinstance(series.get(k), Density)), None)
+        o = dens if dens is not None else series.cached("order_density", Density)
+    if isinstance(o, Density):
+        keys = series.point_values(o)
+    elif isinstance(o, Values):
+        keys = o.data
+    else:
+        keys = o
+    if len(keys) != n:
+        raise ValueError(f"{len(keys)} order keys for {n} points")
+    return _backend.argsort(keys, descending=descending)
+
+
+def order_value(v: Any) -> Any:
+    """``order``: ``"density"``, ``"-density"``, a ``Density`` or sort keys per point."""
+    from ..density import Density
+    if isinstance(v, Density):
+        return v
+    if isinstance(v, str):
+        if v.strip().lower() in ("density", "-density"):
+            return v.strip().lower()
+        raise ValueError(f"expected 'density', '-density' or sort keys, got {v!r}")
+    return _backend.doubles(v.to_numpy() if hasattr(v, "to_numpy") else v)
+
+
+def alpha_value(v: Any) -> Any:
+    """``alpha``: a number in [0, 1], or ``"density"`` / a ``Density``."""
+    from ..density import Density
+    if isinstance(v, Density):
+        return v
+    if isinstance(v, str) and v.strip().lower() == "density":
+        return Density()
+    return number(0, 1)(v)
+
+
+def map_colors(cmap: ColorMap, values: Any, limits: tuple[float, ...]) -> Any:
+    """Colors of ``values`` through a map with limits ``(flo, fhi, …)`` (after its scale
+    function)."""
+    from ..scales import get_scale
+    flo, fhi = limits[0], limits[1]
+    span = fhi - flo
+    k = 1.0 / span if span else 0.0
+    fn = get_scale(cmap.scale).function
+    ts = _backend.scaled(values, k, -flo * k, fn)
+    return cmap.colors_at(ts)
+
+
+def _faded(paint: Any, alpha: float) -> Any:
+    """A resolved paint (a color, a list of colors or flat RGBA values) at ``alpha``."""
+    if isinstance(paint, array.array):
+        out = array.array("d", paint)
+        out[3::4] = _backend.scaled(out[3::4], alpha)
+        return out
+    if isinstance(paint, list):
+        return [with_alpha(c, alpha) if c is not None else None for c in paint]
+    if isinstance(paint, memoryview):      # (n, 4) colors from a ColorMap
+        flat = _faded(array.array("d", paint.cast("B").cast("d")), alpha)
+        return memoryview(flat).cast("B").cast("d", (len(flat) // 4, 4))
+    return with_alpha(paint, alpha)
+
+
+class MarkerStyle:
+    """Resolved marker arguments for ``Canvas.draw_markers``."""
+
+    def __init__(self, series: Any, ctx: Any, prefix: str = "", default_color: Any = None,
+                 n: int = 0, glyph: bool = False, order: Any = None) -> None:
+        self.glyph_only = glyph
+        self.order = None if glyph else order
+        g = series.get
+        p = prefix
+        size_name = "size" if not p else "marker_size"
+        color_name = "color" if not p else "marker_color"
+        alpha = g("alpha")
+        if is_computed(alpha) and glyph:
+            alpha = series.get("alpha_range")[1]
+        elif is_computed(alpha):
+            lo, hi = series.get("alpha_range")
+            vals = self._take(series.point_values(alpha))
+            _, vmin, vmax = _backend.extent(vals, None)
+            span = (vmax - vmin) if vmax > vmin else 1.0
+            k = (hi - lo) / span
+            alpha = _backend.scaled(vals, k, lo - k * vmin, None, nan=0.0)
+        self.opacity = 1.0 if alpha is None else alpha
+        marker = g("marker")
+        basis = g("size_basis")
+        size = g(size_name)
+        if isinstance(marker, list):
+            marker = self._take(marker)
+        if isinstance(size, array.array):
+            size = self._take(size)
+        if isinstance(marker, list) and glyph:
+            marker = marker[0]
+        if isinstance(marker, list):
+            if len(marker) != n:
+                raise ValueError(f"{len(marker)} markers for {n} points")
+            resolved = [resolve(m) for m in marker]
+            self.marker: Any = [r[0] for r in resolved]
+            factor: Any = array.array("d", [area_factor(m) if basis == "area" else 1.0
+                                            for m in marker])
+        else:
+            self.marker = resolve(marker)[0]
+            factor = area_factor(marker) if basis == "area" else 1.0
+        smap = series.size_map_obj(size_name) if hasattr(series, "size_map_obj") else None
+        if smap is not None and glyph:
+            size = (smap.sizes[0] + smap.sizes[1]) / 2
+        elif smap is not None:
+            from ..scales import get_scale
+            values = self._take(series.point_values(size))
+            flo, fhi = ctx.maps[id(smap)][:2]
+            size = smap.map(values, flo, fhi, get_scale(smap.scale).function)
+        if isinstance(size, array.array) and glyph:
+            finite = sorted(v for v in size[::max(1, len(size) // 1000)] if v == v)
+            size = finite[len(finite) // 2] if finite else 4.0
+        if isinstance(size, array.array):
+            if len(size) != n:
+                raise ValueError(f"{len(size)} sizes for {n} points")
+            if isinstance(factor, array.array):
+                size = array.array("d", [s * f for s, f in zip(size, factor)])
+            elif factor != 1.0:
+                size = _backend.scaled(size, factor)
+        elif isinstance(factor, array.array):
+            size = array.array("d", [size * f for f in factor])
+        else:
+            size = size * factor
+        self.size = size
+        fill = g(color_name)
+        if fill is None:
+            fill = default_color
+        self.fill = self._paint(fill, series, ctx, n)
+        self.stroke = self._paint(g(f"{p}line_color"), series, ctx, n)
+        self.line_width = g(f"{p}line_width")
+        filled = g(f"{p}filled")
+        if filled is not True and self.fill is not None:
+            if self.stroke is None:
+                self.stroke = self.fill
+            self.fill = None if filled is False else _faded(self.fill, filled)
+        if self.stroke is None:
+            self.line_width = None
+
+    def _paint(self, value: Any, series: Any, ctx: Any, n: int) -> Any:
+        if value is None:
+            return None
+        mapped = isinstance(value, Values) or is_computed(value)
+        if mapped and self.glyph_only:
+            return series.color_map_obj()(0.5)
+        if isinstance(value, list) and self.glyph_only:
+            return resolve_color(next((c for c in value if c is not None), None), ctx.palette)
+        if isinstance(value, memoryview) and self.glyph_only:
+            return tuple(value[0, k] for k in range(4)) if len(value) else None
+        if mapped:
+            values = self._take(series.point_values(value))
+            if len(values) != n:
+                raise ValueError(f"{len(values)} color values for {n} points")
+            cmap = series.color_map_obj()
+            return map_colors(cmap, values, ctx.maps[id(cmap)])
+        if isinstance(value, memoryview):
+            if len(value) != n:
+                raise ValueError(f"{len(value)} colors for {n} points")
+            return self._take(value)
+        if isinstance(value, list):
+            if len(value) != n:
+                raise ValueError(f"{len(value)} colors for {n} points")
+            return [resolve_color(c, ctx.palette) for c in self._take(value)]
+        return resolve_color(value, ctx.palette)
+
+    def first_color(self, which: str = "fill") -> Any:
+        v = self.fill if which == "fill" else self.stroke
+        if v is None or isinstance(v, (str, tuple)):
+            return v
+        if isinstance(v, list):
+            return next((c for c in v if c is not None), None)
+        if isinstance(v, array.array):        # flat RGBA
+            return tuple(v[:4]) if len(v) >= 4 else None
+        if isinstance(v, memoryview) and v.ndim == 2:
+            m: Any = v
+            return tuple(m[0, k] for k in range(m.shape[1])) if len(m) else None
+        try:
+            return tuple(v[0])
+        except (TypeError, IndexError):
+            return None
+
+    def _take(self, v: Any) -> Any:
+        """A per-point input in drawing order (``order``), before colors are mapped."""
+        return v if self.order is None or v is None else permuted(v, self.order)
+
+    def draw(self, canvas: Any, xs: Any, ys: Any, simplify: Any) -> None:
+        if self.fill is None and self.stroke is None:
+            return
+        canvas.draw_markers(xs, ys, marker=self.marker, size=self.size, fill=self.fill,
+                            stroke=self.stroke, line_width=self.line_width,
+                            opacity=self.opacity, simplify=simplify)
+
+    def glyph(self, canvas: Any, cx: float, cy: float, max_size: float) -> None:
+        """One marker for a legend entry."""
+        size = self.size
+        if not isinstance(size, (int, float)):
+            finite = [s for s in size if s == s]
+            size = sorted(finite)[len(finite) // 2] if finite else 4.0
+        size = min(size, max_size)
+        marker = self.marker[0] if isinstance(self.marker, list) else self.marker
+        fill = self.first_color("fill")
+        stroke = self.first_color("stroke")
+        if fill is None and stroke is None:
+            return
+        canvas.draw_markers([cx], [cy], marker=marker, size=size, fill=fill, stroke=stroke,
+                            line_width=self.line_width, opacity=self.opacity)
+
+
+def order_settings() -> dict[str, Setting]:
+    """``order``, ``alpha`` (numbers or a density) and ``alpha_range``."""
+    from ..settings import pair
+    return {
+        "order": Setting(order_value,
+                         doc="Drawing order: `\"density\"` (densest drawn last), "
+                             "`\"-density\"`, or sort keys per point (ascending); default: "
+                             "call order."),
+        "alpha": Setting(alpha_value, inherited=True,
+                         doc="Opacity, multiplying the colors' own; or `\"density\"` / a "
+                             "`Density`, mapped linearly to `alpha_range`."),
+        "alpha_range": Setting(pair(number(0, 1)),
+                               doc="Opacities of the least and most dense points when "
+                                   "`alpha` is a density."),
+    }
+
+
+def density_points(series: Any, xs: Any, ys: Any) -> tuple[Any, Any]:
+    """Points ``(xs, ys)`` on the plot's axis positions (log axes in log space)."""
+    from ..scales import get_scale
+    out = []
+    for v, axis in ((xs, series.plot.x_axis), (ys, series.plot.y_axis)):
+        name = axis.get("scale")
+        fn = get_scale(name, axis.get("linthresh")).function \
+            if name not in (None, "category", "time") else None
+        out.append(_backend.scaled(v, 1.0, 0.0, fn) if fn else _backend.doubles(v))
+    return out[0], out[1]
+
+
+def density_stats(series: Any) -> dict[str, Any]:
+    """``{"density": values}`` when a setting of the series maps a density."""
+    from ..density import Density
+    for k in ("color", "line_color", "size", "alpha", "order"):
+        if k in series.SETTINGS and isinstance(series.get(k), Density):
+            return {"density": series.point_values(series.get(k))}
+    if "order" in series.SETTINGS and isinstance(series.get("order"), str):
+        return {"density": series.point_values(series.cached("order_density", Density))}
+    return {}

plot_io/series/regression.py

@@ -0,0 +1,250 @@
+"""Regression: a fitted line (polynomial or LOWESS) with a confidence band."""
+
+import array
+import math
+from typing import Any
+
+from .. import _backend, stats
+from ..settings import Setting, boolean, color, either, literal, number, table
+from ..style import dash_of, with_alpha
+from . import Series, common
+from .points import MarkerStyle, marker_settings
+
+__all__ = ["Regression", "t_quantile"]
+
+
+def _solve(a: list[list[float]], b: list[float]) -> list[float]:
+    """Gaussian elimination with partial pivoting."""
+    n = len(b)
+    m = [row[:] + [bv] for row, bv in zip(a, b)]
+    for i in range(n):
+        p = max(range(i, n), key=lambda r: abs(m[r][i]))
+        if abs(m[p][i]) < 1e-300:
+            raise ValueError("the fit is singular (too few distinct x values for the order)")
+        m[i], m[p] = m[p], m[i]
+        for r in range(i + 1, n):
+            f = m[r][i] / m[i][i]
+            for c in range(i, n + 1):
+                m[r][c] -= f * m[i][c]
+    x = [0.0] * n
+    for i in range(n - 1, -1, -1):
+        x[i] = (m[i][n] - sum(m[i][c] * x[c] for c in range(i + 1, n))) / m[i][i]
+    return x
+
+
+def _inverse(a: list[list[float]]) -> list[list[float]]:
+    n = len(a)
+    cols = [_solve(a, [1.0 if r == c else 0.0 for r in range(n)]) for c in range(n)]
+    return [[cols[c][r] for c in range(n)] for r in range(n)]
+
+
+def _betacf(a: float, b: float, x: float) -> float:
+    qab, qap, qam = a + b, a + 1.0, a - 1.0
+    c, d = 1.0, 1.0 - qab * x / qap
+    d = 1.0 / (d if abs(d) > 1e-300 else 1e-300)
+    h = d
+    for m in range(1, 300):
+        m2 = 2 * m
+        aa = m * (b - m) * x / ((qam + m2) * (a + m2))
+        d = 1.0 + aa * d
+        d = 1.0 / (d if abs(d) > 1e-300 else 1e-300)
+        c = 1.0 + aa / c if abs(c) > 1e-300 else 1e300
+        h *= d * c
+        aa = -(a + m) * (qab + m) * x / ((a + m2) * (qap + m2))
+        d = 1.0 + aa * d
+        d = 1.0 / (d if abs(d) > 1e-300 else 1e-300)
+        c = 1.0 + aa / c if abs(c) > 1e-300 else 1e300
+        de = d * c
+        h *= de
+        if abs(de - 1.0) < 1e-15:
+            break
+    return h
+
+
+def _betai(a: float, b: float, x: float) -> float:
+    if x <= 0:
+        return 0.0
+    if x >= 1:
+        return 1.0
+    lb = math.lgamma(a + b) - math.lgamma(a) - math.lgamma(b) + a * math.log(x) \
+        + b * math.log(1 - x)
+    if x < (a + 1) / (a + b + 2):
+        return math.exp(lb) * _betacf(a, b, x) / a
+    return 1.0 - math.exp(lb) * _betacf(b, a, 1 - x) / b
+
+
+def _t_cdf(t: float, df: float) -> float:
+    x = df / (df + t * t)
+    p = 0.5 * _betai(df / 2.0, 0.5, x)
+    return 1.0 - p if t > 0 else p
+
+
+def t_quantile(p: float, df: float) -> float:
+    """The ``p`` quantile of Student's t distribution with ``df`` degrees of freedom."""
+    if df <= 0:
+        return math.inf
+    lo, hi = -1e3, 1e3
+    for _ in range(200):
+        mid = (lo + hi) / 2
+        if _t_cdf(mid, df) < p:
+            lo = mid
+        else:
+            hi = mid
+    return (lo + hi) / 2
+
+
+class Regression(Series):
+    """A regression of ``y`` on ``x``: a polynomial of ``order`` (least squares) with a
+    confidence band of the mean, or a LOWESS curve; ``scatter`` also draws the points."""
+
+    SETTINGS = table(
+        order=Setting(number(lo=1, hi=5, integer=True), doc="Polynomial order (1–5)."),
+        lowess=Setting(boolean, doc="Fit a LOWESS curve instead (no band)."),
+        frac=Setting(number(0, 1), doc="Fraction of the points in each LOWESS fit."),
+        ci=Setting(either(literal(None), number(0, 100)),
+                   doc="Confidence level of the band (%); `None`: no band."),
+        logx=Setting(boolean, doc="Fit y against log(x) (x > 0)."),
+        scatter=Setting(boolean, doc="Draw the points too."),
+        truncate=Setting(boolean, doc="Draw the fit over the data range only (`False`: "
+                                            "over the axis range)."),
+        points=Setting(number(lo=2, integer=True), doc="Points of the fitted curve."),
+        color=Setting(color, doc="Line, band and point color; default the next palette color."),
+        line_width=Setting(number(lo=0), doc="Line width (pt).", length=True),
+        line_style=Setting(lambda v: v, doc="Line style."),
+        band_alpha=Setting(number(0, 1), doc="Opacity of the band."),
+        **{**marker_settings("marker_")},
+        **common("name", "alpha", "z", "rasterize", "simplify", "font_size", "font_family",
+                 "text_color"),
+    )
+
+    def __init__(self, x: Any, y: Any, plot: Any = None, **settings: Any) -> None:
+        self.x, self.y = _backend.doubles(x), _backend.doubles(y)
+        if len(self.x) != len(self.y):
+            raise ValueError(f"x has {len(self.x)} values and y {len(self.y)}")
+        super().__init__(plot=plot, **settings)
+
+    @property
+    def stats(self) -> dict[str, Any]:
+        """``coefficients`` (highest power last, in x or log x), ``r2``, ``se`` (residual
+        standard error), and the curve: ``x``, ``y``, ``low``, ``high``."""
+        return self.cached("stats", self._compute)
+
+    def _pairs(self) -> list[tuple[float, float]]:
+        logx = self.get("logx")
+        return [(math.log(a) if logx else a, b) for a, b in zip(self.x, self.y)
+                if math.isfinite(a) and math.isfinite(b) and (a > 0 or not logx)]
+
+    def _compute(self) -> dict[str, Any]:
+        logx = self.get("logx")
+        pts = self._pairs()
+        n = len(pts)
+        npts = self.get("points")
+        if n < 2:
+            return {"coefficients": [], "r2": math.nan, "se": math.nan, "x": array.array("d"),
+                    "y": array.array("d"), "low": None, "high": None}
+        lo = min(p[0] for p in pts)
+        hi = max(p[0] for p in pts)
+        grid = [lo + (hi - lo) * i / (npts - 1) for i in range(npts)]
+        if self.get("lowess"):
+            xs, fit = stats.lowess([p[0] for p in pts], [p[1] for p in pts], self.get("frac"))
+            gx = array.array("d", (math.exp(v) for v in xs) if logx else xs)
+            return {"coefficients": [], "r2": math.nan, "se": math.nan, "x": gx, "y": fit,
+                    "low": None, "high": None}
+        k = min(self.get("order"), n - 1) + 1
+        mx = math.fsum(p[0] for p in pts) / n
+        sx = math.sqrt(math.fsum((p[0] - mx) ** 2 for p in pts) / n) or 1.0
+
+        def row(v: float) -> list[float]:
+            u = (v - mx) / sx
+            return [u ** j for j in range(k)]
+
+        rows = [row(p[0]) for p in pts]
+        ata = [[math.fsum(r[i] * r[j] for r in rows) for j in range(k)] for i in range(k)]
+        aty = [math.fsum(r[i] * p[1] for r, p in zip(rows, pts)) for i in range(k)]
+        beta = _solve(ata, aty)
+        fitted = [sum(b * v for b, v in zip(beta, r)) for r in rows]
+        my = math.fsum(p[1] for p in pts) / n
+        ss_res = math.fsum((p[1] - f) ** 2 for p, f in zip(pts, fitted))
+        ss_tot = math.fsum((p[1] - my) ** 2 for p in pts)
+        dof = n - k
+        se = math.sqrt(ss_res / dof) if dof > 0 else math.nan
+        gy = [sum(b * v for b, v in zip(beta, row(g))) for g in grid]
+        low = high = None
+        ci = self.get("ci")
+        if ci is not None and dof > 0:
+            inv = _inverse(ata)
+            t = t_quantile(0.5 + ci / 200.0, dof)
+            low, high = array.array("d"), array.array("d")
+            for g, yv in zip(grid, gy):
+                r = row(g)
+                var = sum(r[i] * inv[i][j] * r[j] for i in range(k) for j in range(k))
+                h = t * se * math.sqrt(max(var, 0.0))
+                low.append(yv - h)
+                high.append(yv + h)
+        # coefficients in powers of x (or log x)
+        coef = [0.0] * k
+        for j, b in enumerate(beta):
+            for i in range(j + 1):
+                coef[i] += b * math.comb(j, i) * (-mx) ** (j - i) / sx ** j
+        gx = array.array("d", (math.exp(v) for v in grid) if logx else grid)
+        return {"coefficients": coef, "r2": 1.0 - ss_res / ss_tot if ss_tot else math.nan,
+                "se": se, "x": gx, "y": array.array("d", gy), "low": low, "high": high}
+
+    def values(self, role: str) -> Any:
+        st = self.stats
+        out = array.array("d", self.x if role == "x" else self.y)
+        if role == "y":
+            for v in (st["low"], st["high"]):
+                if v is not None:
+                    out.extend(v)
+        return out
+
+    def occupy(self, ctx: Any, occ: Any) -> None:
+        st = self.stats
+        if self.get("scatter"):
+            from ..occupancy import thin
+            x, y = thin(self.x, self.y)
+            occ.points(ctx.xmap.many(x), ctx.ymap.many(y))
+        if len(st["x"]):
+            px = ctx.xmap.many(st["x"])
+            occ.lines(px, ctx.ymap.many(st["y"]))
+            if st["low"] is not None:
+                occ.band(px, ctx.ymap.many(st["low"]), ctx.ymap.many(st["high"]))
+
+    def legend_points(self) -> tuple[Any, Any]:
+        return self.x, self.y
+
+    def _color(self, ctx: Any) -> Any:
+        return with_alpha(self.base_color(ctx), self.get("alpha"))
+
+    def draw(self, ctx: Any) -> None:
+        st = self.stats
+        c = self._color(ctx)
+        canvas = ctx.canvas
+        if self.get("scatter"):
+            style = MarkerStyle(self, ctx, "marker_", c, len(self.x))
+            style.draw(canvas, ctx.xmap.many(self.x), ctx.ymap.many(self.y), self.simplify_arg())
+        if c is None or not len(st["x"]):
+            return
+        px = ctx.xmap.many(st["x"])
+        if st["low"] is not None:
+            canvas.fill_between(px, ctx.ymap.many(st["low"]), ctx.ymap.many(st["high"]),
+                                color=c, opacity=self.get("band_alpha"))
+        lw = self.get("line_width")
+        if lw:
+            canvas.draw_lines(px, ctx.ymap.many(st["y"]), color=c, width=lw,
+                              dash=dash_of(self.get("line_style"), lw))
+
+    def legend_colors(self, ctx: Any) -> tuple[Any, Any]:
+        return None, self._color(ctx)
+
+    def legend_glyph(self, ctx: Any, x: float, y: float, w: float, h: float) -> None:
+        c = self._color(ctx)
+        if c is None:
+            return
+        canvas = ctx.canvas
+        if self.get("ci") is not None and not self.get("lowess"):
+            canvas.fill_style = with_alpha(c, self.get("band_alpha"))
+            canvas.fill_rect(x, y + h * 0.2, w, h * 0.6)
+        canvas.draw_lines([x, x + w], [y + h / 2, y + h / 2], color=c,
+                          width=min(self.get("line_width"), h / 3))