plot-io 0.12.0__py3-none-win_amd64.whl

plot_io/presets/scatter.py

@@ -0,0 +1,194 @@
+"""Scatter: markers at points (``Points``), with optional error bars (``Segments``) and
+point labels (``Text``, placed by :func:`plot_io.labels.around`)."""
+
+import math
+from typing import Any
+
+from .._methods import ScatterMixin
+from .. import groups
+from ..layers.base import column, common
+from ..layers.grammar import Lay, Spec, flipped
+from ..layers.paint import density_points, density_stats, order_settings
+from ..settings import Setting, table
+from ..validators import boolean, length
+from ..transform import settings_both as coord_settings
+from .errors import Summarized, error_value
+
+__all__ = ["Scatter"]
+
+
+class Scatter(ScatterMixin, Summarized):
+    """Markers at points ``(x, y)``.
+
+    ``color``, ``edge_color``, ``size``, ``marker`` and ``opacity`` take one value or one per
+    point.  Numbers per point in ``color``/``edge_color`` are mapped through ``color_map``;
+    in ``size``, through ``size_map`` when it is set; ``"density"`` maps the points'
+    density.  ``orientation="horizontal"`` draws ``x`` on the y axis.
+
+    ``size`` is a diameter; with ``size_basis="area"`` every shape has the area of the circle
+    of that diameter (a square of size 4 is drawn 3.54 px wide).  See
+    `values in color and size <docs/api.md#values-in-color-and-size>`_.
+
+    Error bars: ``x_error``/``y_error`` take a value, a sequence, ``(low, high)`` sequences
+    or ``Errors(values, color=None, line_width=None, cap_length=None)`` (cap: the series'
+    ``cap_length``, else 4 px).  With replicates, ``estimate`` draws a point per ``x`` and
+    ``interval`` its error bars (`summaries <docs/api.md#summaries-estimate-interval>`_).
+
+    Point labels (``labels``) go beside their point (8 places, at ``0.25em``) or further out
+    on rings up to ``label_reach``, with a leader line to the point; a label meets no other
+    label, no point of the series, no leader and no inside legend placed before it, and
+    stays inside the axes.  Labels are placed in the order given; one without room is
+    dropped (``series.labels_dropped`` counts them).  The placement is deterministic.
+
+    Example::
+
+        rng = random.Random(1)
+        p = plt.Plot(width=240, height=160)
+        p.scatter([rng.gauss(0, 1) for _ in range(100)], [rng.gauss(0, 1) for _ in range(100)])
+    """
+
+    SETTINGS = table(
+        **coord_settings(),
+        **groups.Marker.embed(),
+        **common("color_map", "size_map", "size_key"),
+        **order_settings(),
+        x_error=Setting(error_value, doc="Horizontal error bars: a value, a sequence, "
+                                         "`(low, high)` or `Errors`."),
+        y_error=Setting(error_value, doc="Vertical error bars."),
+        **common("estimate"),
+        orientation=Setting(lambda v: _orientation(v),
+                            doc="`vertical` (x along the x axis) or `horizontal` (x along "
+                                "the y axis)."),
+        labels=Setting(lambda v: _labels(v),
+                       doc="A text per point (a sequence or a `data=` column; `None` and "
+                           "`\"\"`: none), placed beside its point or further out with a "
+                           "leader, meeting no other label, no point and an inside legend; "
+                           "a label without room is dropped (`labels_dropped`)."),
+        **groups.TextStyle.embed("label_", only=("font_size", "color"),
+                                 docs={"font_size": "Font size of the point labels.",
+                                       "color": "Color of the point labels (unset: the "
+                                                "text color)."}),
+        label_reach=Setting(length(lo=0, percent="em", em="label_font_size"),
+                            doc="Farthest a point label goes from its point."),
+        label_leaders=Setting(boolean, doc="A line from each label placed away from its "
+                                           "point to the point."),
+        **common("name", "z", "rasterize", "simplify", "font_size", "font_family",
+                 "text_color"),
+    )
+
+    DATA = {"x": "position", "y": "position"}
+    x = column("x", "x of each point (categories at their index among their own).")
+    y = column("y", "y of each point (as x).")
+
+    def __init__(self, x: Any, y: Any, plot: Any = None, **settings: Any) -> None:
+        super().__init__(plot=plot, **settings)
+
+    @property
+    def stats(self) -> dict[str, Any]:
+        """Derived data: ``{"density": values}`` when the series maps a density."""
+        return density_stats(self)
+
+    @property
+    def labels_dropped(self) -> int:
+        """Point labels left out for want of room at the last drawing."""
+        return self.__dict__.get("_labels_dropped", 0)
+
+    def _label_picks(self) -> list[tuple[int, Any]]:
+        """``(point index, text)`` of the labels, in priority order."""
+        texts = self.resolve("labels")
+        if not texts:
+            return []
+        return [(i, t if isinstance(t, str) else str(t)) for i, t in enumerate(texts)
+                if t is not None and t != "" and not (isinstance(t, float) and t != t)]
+
+    def density_points(self) -> tuple[Any, Any]:
+        if flipped(self):
+            return density_points(self, self.y, self.x)
+        return density_points(self, self.x, self.y)
+
+    SPEC = Spec(
+        [Lay("errors", ("error_source", {"color": "marker", "opacity": "marker",
+                                          "marker": "@points"})),
+         Lay("points", ("marker", {"order": True, "once": True, "n": lambda s: len(s.x)}),
+             name="points", radius=lambda s: _radius(s.resolve("size")))],
+        key={"fill": "marker", "stroke": "marker", "marker": "@points"},
+        zero=("x", "y"), color_sources=True, size_sources=True,
+        finish=lambda s, b: point_labels(s, b))
+
+
+def _labels(v: Any) -> Any:
+    if v is None:
+        return None
+    if isinstance(v, (str, bytes)) or not hasattr(v, "__len__"):
+        raise ValueError(f"expected a text per point (a column of data= by name), got {v!r}")
+    return list(v.tolist() if hasattr(v, "tolist") else v)
+
+
+def point_labels(s: Any, b: Any) -> None:
+    """The text layer of ``s``' point labels (a series of Scatter's settings whose spec has
+    a ``points`` layer of its data's points), placed when drawn."""
+    from .. import labels
+    from ..layers.geoms import GEOMS
+    from ..text import font_of
+    from ._util import memo, placed_text
+    pts = [la for la in b.call.layers if la.geom is GEOMS["points"]]
+    if not s.resolve("labels") or not pts:
+        return
+    layer = pts[-1]
+    radius = layer.options.get("radius", 0.0) or 3.0
+
+    def font(ctx: Any) -> Any:
+        c = s.resolve("label_color")
+        return font_of(s, s.resolve("label_font_size"),
+                       color=ctx.color(s.resolve("text_color") if c is None else c))
+
+    def items(ctx: Any) -> list[tuple[Any, ...]]:
+        picks = s._label_picks()
+        s.__dict__["_labels_dropped"] = 0
+        if not picks:
+            return []
+        lay = layer.columns(ctx)
+        xs, ys = GEOMS["points"]._xy(ctx, lay)           # type: ignore[attr-defined]
+        if isinstance(xs, float):
+            xs, ys = [xs], [ys]
+        f = font(ctx)
+        sizes, shift = [], []
+        for _, t in picks:
+            q = labels.quad(ctx.canvas, t, f, 0.0, 0.0, "center", "center")
+            us, vs = [c[0] for c in q], [c[1] for c in q]       # type: ignore[union-attr]
+            sizes.append((max(us) - min(us), max(vs) - min(vs)))
+            shift.append(((max(us) + min(us)) / 2, (max(vs) + min(vs)) / 2))
+        taken = memo(ctx, "point_labels", lambda: list(ctx.root.avoid))
+        n = len(xs)
+        keep = [(k, i) for k, (i, _) in enumerate(picks) if i < n]
+        got = labels.around((xs, ys), radius, [i for _, i in keep], [sizes[k] for k, _ in keep],
+                            ctx.rect, labels.PAD * f.size, s.resolve("label_reach"), taken)
+        leaders = s.resolve("label_leaders")
+        out: list[tuple[Any, ...]] = []
+        for (k, i), g in zip(keep, got):
+            if g is None:
+                continue
+            cx, cy, ring = g
+            line = None
+            if ring and leaders:
+                w, h = sizes[k]
+                px, py = float(xs[i]), float(ys[i])
+                qx = min(max(px, cx - w / 2), cx + w / 2)
+                qy = min(max(py, cy - h / 2), cy + h / 2)
+                dist = math.hypot(qx - px, qy - py) or 1.0
+                line = (px + (qx - px) * radius / dist, py + (qy - py) * radius / dist, qx, qy)
+            out.append((picks[k][1], cx - shift[k][0], cy - shift[k][1], f.color, "center",
+                        "center", None, None, line))
+        s.__dict__["_labels_dropped"] = len(picks) - len(out)
+        return out
+
+    b.call.layers.append(placed_text(s, (id(s), "point labels"), items, font))
+
+
+def _radius(size: Any) -> float:
+    return size / 2 if isinstance(size, (int, float)) else 0.0
+
+
+def _orientation(v: Any) -> Any:
+    from ..settings import one_of
+    return one_of("vertical", "horizontal")(v)

plot_io/presets/stem.py

@@ -0,0 +1,100 @@
+"""Stems: segments from a baseline to each value (``Segments``), ending in a marker
+(``Points``), over a baseline (``Path``): lollipops."""
+
+from typing import Any
+
+from .._methods import StemMixin
+from .. import groups
+from .. import kernels
+from ..color.values import color
+from ..layers.base import COMMON, column, common
+from ..layers.core import Table
+from ..layers.grammar import Lay, Spec
+from ..layers.paint import xy_density_points
+from ..settings import Setting, number, one_of, table
+from ..transform import settings_both as coord_settings
+from ..validators import length
+from .errors import Summarized
+
+__all__ = ["Stem"]
+
+
+class Stem(StemMixin, Summarized):
+    """Stems from ``baseline`` to ``y`` at ``x`` (or at 0, 1, … when ``y`` is omitted);
+    numbers per point in ``marker_color`` map through the series' color axis.
+
+    Stems from ``baseline`` to each value with a marker (lollipops), and a baseline line.
+    With replicates, ``estimate`` draws a stem per ``x``.
+
+    Example::
+
+        import math
+        p = plt.Plot(width=240, height=160)
+        p.stem(range(16), [math.sin(i / 2) for i in range(16)])
+    """
+
+    SETTINGS = table(
+        **coord_settings(),
+        **groups.Marker.embed("marker_"),
+        **common("color_map"),
+        color=Setting(color, doc="Stem and marker color; default: the plot's next color."),
+        line_width=Setting(length(lo=0), inherited=True, doc="Stem width."),
+        baseline=Setting(number(), doc="Value the stems start from."),
+        **groups.Stroke.embed("baseline_",
+                              only=("color", "line_width"),
+                              docs={"color": "Baseline color; `none`: no baseline.",
+                                    "line_width": "Baseline width."}),
+        orientation=Setting(one_of("vertical", "horizontal"),
+                            doc="`vertical` stems (values on y) or `horizontal`."),
+        estimate=COMMON["estimate"](),
+        **common("name", "opacity", "z", "rasterize", "simplify", "font_size", "font_family",
+                 "text_color"),
+    )
+
+    DATA = {"x": "position", "y": "numbers"}
+    x = column("x", "x of each point (categories at their index among their own).")
+    y = column("y", "y of each point (as x).")
+
+    def __init__(self, x: Any, y: Any = None, plot: Any = None, **settings: Any) -> None:
+        super().__init__(plot=plot, **settings)
+
+    def density_points(self) -> tuple[Any, Any]:
+        """The markers' positions on the plot's axes (a density in ``marker_color``)."""
+        return xy_density_points(self, self.x, self.y)
+
+    SPEC = Spec(
+        [Lay("path", ("stroke", {"color": "baseline_color", "width": "baseline_width"}),
+             table="baseline", key=False, occupy=False),
+         Lay("segments", ("stroke", {"color": "faded", "drop_zero": True,
+                                     "extra": ("simplify",)}),
+             table="stems", glyph="stem"),
+         Lay("points", ("marker", {"prefix": "marker_", "color": "faded",
+                                   "n": lambda s: len(s.x)}),
+             occupy=False, glyph_at=0.35, glyph_max=0.7)],
+        tables={"stems": lambda s, b: _stems(s, b), "baseline": lambda s, b: _baseline(s, b)},
+        key={"fill": "faded"}, zero=("y",), color_sources=True)
+
+
+def _stems(s: Stem, b: Any) -> Table:
+    t = Table(x0=s.x, x1=s.x, y0=s.resolve("baseline"), y1=s.y)
+    if "x" in b.at:
+        t.lazy["x0"] = t.lazy["x1"] = b.at["x"]
+    return t
+
+
+def _baseline(s: Stem, b: Any) -> Table | None:
+    """The baseline under the stems, from the first to the last."""
+    if not len(s.x):
+        return None
+    cnt, lo, hi = kernels.extent(s.x, None)
+    if not cnt:
+        return None
+    base = s.resolve("baseline")
+    t = Table(x=[lo, hi], y=[base, base])
+    at = b.at.get("x")
+    if at is not None:
+        def ends(ctx: Any) -> list[float]:
+            _, a, b = kernels.extent(at(ctx), None)
+            return [a, b]
+        t.lazy["x"] = ends
+    return t

plot_io/presets/violin.py

@@ -0,0 +1,323 @@
+"""Violin plots (stat ``violin``): a mirrored density per category (``Band``, along the
+value axis), with an inner box (``Path``, ``Rects``, ``Points``), quartile lines
+(``Path``) or points (``Points``)."""
+
+import array
+from typing import Any
+
+from .._methods import ViolinMixin
+from .. import columns, groups
+from ..color.values import desaturate, with_alpha
+from ..layers import stats
+from ..layers.base import Series, common
+from ..layers.core import Layer, Table
+from ..layers.geoms import GEOMS, Marks
+from ..layers.grammar import Lay, Spec, axis_of
+from ..layers.paint import Paint, role
+from ..layers.positions import Dodge, placed
+from ..lines import dash_of
+from ..settings import Setting, boolean, either, literal, number, one_of, table
+from ..transform import settings_both as coord_settings
+from ..validators import length
+from ..values import category_paint
+from ..layers.paint import base_colors
+from ._util import fill_colors
+from .kde import check_bandwidth
+
+__all__ = ["Violin"]
+
+
+def _inner(v: Any) -> Any:
+    if v is False or v == "none":
+        return False
+    return one_of("box", "quartiles", "points")(v)
+
+
+class Violin(ViolinMixin, Series):
+    """Violins of ``values``: a dict ``{category: values}``, a list of arrays (categories
+    ``0, 1, …`` or ``categories=``), or one array.
+
+    ``values`` as :class:`Box` takes them.  Each violin is the density of its category,
+    mirrored, in the value axis' space (log axes: in log space); ``width_scale`` gives equal
+    areas (default), areas proportional to the counts, or equal widths.  A category of one
+    value (or all equal) is a line at it, with a warning.  ``inner`` draws a thin box with
+    whiskers and a median dot, dashed quartiles, the points, or nothing (``False``).  With
+    ``split=True``, two violin series share each slot as facing halves.  ``side="low"`` or
+    ``"high"`` draws one half of each violin (toward lower or higher positions), alone in
+    its slot.
+
+    Example::
+
+        rng = random.Random(1)
+        p = plt.Plot(width=240, height=160)
+        p.violin({k: [rng.gauss(m, 1) for _ in range(80)] for k, m in (("A", 0), ("B", 1), ("C", 0.5))})
+    """
+
+    SETTINGS = table(
+        **coord_settings(),
+        color=Setting(category_paint,
+                      doc="Fill: a color, one per violin (list or dict by category), or "
+                          "numbers per violin mapped through `color_map`; default the next "
+                          "plot's color."),
+        **common("color_map"),
+        **groups.Stroke.embed("edge_",
+                              only=("color", "line_width"),
+                              checks={"color": groups.series_color},
+                              docs={"color": "Outline and inner color: a color or "
+                                             "`\"series\"` (each violin's own color, at "
+                                             "`opacity`).",
+                                    "line_width": "Outline width."}),
+        saturation=Setting(number(0, 1), doc="Saturation of the fills."),
+        **groups.FillStyle.embed(docs={"fill": "Fill: `True` (each violin's color), a color, or "
+                                               "`False`.",
+                                       "fill_opacity": "Opacity of the fill, times `opacity` "
+                                                       "(outlines keep `opacity`)."}),
+        max_width=Setting(length(positive=True, data=True, percent="slot"),
+                          doc="Largest width of the series' part of a slot (as `width`); "
+                              "default none."),
+        width=Setting(length(positive=True, data=True, percent="slot"),
+                      doc="Violin width: `%` of the slot, a length (bare numbers: px), `d` "
+                          "data units, or a duration on time axes."),
+        bandwidth=Setting(check_bandwidth, doc="`scott`, `silverman` or a number."),
+        weights=Setting(columns.weights,
+                        doc="A weight per value, counted as repeated values (a dict or a list "
+                            "per category, as the values; long data: a weight per row)."),
+        adjust=Setting(number(positive=True), doc="Factor applied to the bandwidth."),
+        cut=Setting(number(lo=0), doc="The density extends this many bandwidths past "
+                                           "the data."),
+        points=Setting(number(lo=16, hi=65536, integer=True),
+                       doc="Points per violin outline."),
+        width_scale=Setting(one_of("area", "count", "width"),
+                            doc="`area`: equal areas; `count`: area proportional to the "
+                                "number of values; `width`: equal widths."),
+        inner=Setting(_inner,
+                      doc="Inside each violin: `box` (a thin box, whiskers and a median dot), "
+                          "`quartiles` (dashed lines), `points`, or `False` (nothing)."),
+        split=Setting(boolean, doc="Two violin series share each slot as facing "
+                                          "halves."),
+        side=Setting(one_of("both", "low", "high"),
+                     doc="`both` halves, or only the `low` or `high` one (toward lower or "
+                         "higher positions)."),
+        orientation=Setting(one_of("vertical", "horizontal"),
+                            doc="`vertical` (categories on x) or `horizontal`."),
+        dodge=Setting(boolean, doc="Violin and box series sharing a category share its "
+                                         "slot side by side; `False` overlays them."),
+        gap=Setting(length(lo=0, percent="slot_part"), doc="Fraction of each part of a shared slot left "
+                                           "empty."),
+        categories=Setting(either(literal(None), lambda v: list(v)),
+                           doc="Category names of a list of arrays."),
+        **common("name", "opacity", "z", "rasterize", "simplify", "font_size", "font_family",
+                 "text_color"),
+    )
+    DATA = {"values": "categories", "positions": "slots"}
+    ITEMS = "violins"
+
+    def __init__(self, values: Any, positions: Any = None, plot: Any = None,
+                 **settings: Any) -> None:
+        super().__init__(plot=plot, **settings)
+
+    def value_scale(self) -> Any:
+        """The scale of the value axis (densities are computed in its space)."""
+        return stats.axis_scale(axis_of(self, "y"))
+
+    @property
+    def stats(self) -> dict[Any, dict[str, Any]]:
+        """``{category: {"grid", "density", "count", "box": BoxStats, "bandwidth",
+        "line"}}``: densities per unit of the value axis' scale; ``line``: a category
+        without a bandwidth, drawn as a line at its value."""
+        return stats.run(self, "violin")
+
+    # -- paint -----------------------------------------------------------------------
+
+    def _colors(self, ctx: Any) -> list[Any]:
+        return base_colors(self, ctx, self.cols.categories, "violins", items=True,
+                           saturation=False)
+
+    def fills(self, ctx: Any) -> list[Any]:
+        return fill_colors(self, ctx, self._colors(ctx))
+
+    def edges(self, ctx: Any) -> list[Any]:
+        """Outline and inner color of each violin (``None``: none)."""
+        v = self.resolve("edge_color")
+        if v != "series":
+            return [ctx.color(v)] * len(self.cols.categories)
+        sat, a = self.resolve("saturation"), self.resolve("opacity")
+        return [with_alpha(desaturate(x, sat) if sat != 1.0 else x, a) if x is not None else None
+                for x in self._colors(ctx)]
+
+    def _half_widths(self) -> dict[Any, float]:
+        """Scale factor per category: half-width in category units per unit of density."""
+        st = self.stats
+        mode = self.resolve("width_scale")
+        peaks = {k: (max(s["density"]) if len(s["density"]) else 0.0) for k, s in st.items()
+                 if not s["line"]}
+        lines = {k: 1.0 for k, s in st.items() if s["line"]}       # lines: the full width
+        if mode == "width":
+            return {**{k: (1.0 / p if p else 0.0) for k, p in peaks.items()}, **lines}
+        if mode == "count":
+            top = max((peaks[k] * st[k]["count"] for k in peaks), default=0.0)
+            return {**{k: (st[k]["count"] / top if top else 0.0) for k in peaks}, **lines}
+        top = max(peaks.values(), default=0.0)
+        return {**{k: (1.0 / top if top else 0.0) for k in peaks}, **lines}
+
+    # -- the preset --------------------------------------------------------------------
+
+    SPEC = Spec(
+        [Lay("band", ("violin.band", {"table": "#bodies"}), table="bodies", stat="violin",
+             position="dodge", key=False, turn=True),
+         Lay("rects", "violin.key", table="key", name="key", drawn=False)],
+        tables={"bodies": lambda s, b: _bodies(s, b), "key": lambda s, b: Table()},
+        key={"fill": "symbol", "stroke": "symbol", "marker": "@key"},
+        titles={"values": "y", "categories": "x"}, slots="positions",
+        color_sources="items", finish=lambda s, b: _finish(s, b))
+
+
+def _bodies(s: Violin, b: Any) -> Table | None:
+    """The violins with values (``drawn``), in slots shared with the plot's dodged boxes
+    and violins; ``scale``: half-width per unit of density."""
+    st = s.stats
+    cats = s.cols.categories
+    drawn = [i for i, k in enumerate(cats) if st[k]["count"]]
+    if not drawn:
+        return None
+    scale = s._half_widths()
+    d = Dodge(s, "box", b.flip, list(cats), s.cols["positions"],
+              "split" if s.resolve("split") else None)
+    if not s.resolve("split"):
+        d.side = {"low": -1, "high": 1}.get(s.resolve("side"), 0)
+    t: Any = Table(x=[st[cats[i]]["grid"] for i in drawn])
+    t.dodge, t.drawn, t.scale = d, drawn, scale
+
+    def halves(ctx: Any, sign: int) -> list[Any]:
+        pl = placed(d, ctx)
+        out = []
+        for i in drawn:
+            k = cats[i]
+            center, width = pl.geo[i]
+            half = width / 2
+            if sign * d.side < 0:                # the other half of a split violin
+                out.append(pl.back(array.array("d", [center] * len(st[k]["density"]))))
+            else:
+                out.append(pl.back(array.array("d", (center + sign * v * scale[k] * half
+                                                     for v in st[k]["density"]))))
+        return out
+
+    t.lazy["y1"] = lambda ctx: halves(ctx, 1)
+    t.lazy["y2"] = lambda ctx: halves(ctx, -1)
+    return t
+
+
+@role("violin.band")
+def _band_paint(s: Violin, ctx: Any, glyph: bool, table: Any = None) -> dict[str, Any]:
+    fills, lcs = s.fills(ctx), s.edges(ctx)
+    p: dict[str, Any] = {"color": [fills[i] for i in table.drawn],
+                         "simplify": s.resolve("simplify")}
+    lw = s.resolve("edge_width")
+    if lw:
+        p["stroke"] = [lcs[i] for i in table.drawn]
+        p["width"] = lw
+    return p
+
+
+@role("violin.key")
+def _key_paint(s: Violin, ctx: Any, glyph: bool) -> dict[str, Any]:
+    f, e = s.fills(ctx), s.edges(ctx)
+    lw = s.resolve("edge_width")
+    return {"fill": f[0] if f else None, "stroke": e[0] if e else None,
+            "line_width": lw if lw else None}
+
+
+def _finish(s: Violin, b: Any) -> None:
+    """Dates on the category axis; the inner marks of each violin."""
+    t = b.tables.get("bodies")
+    if t is None:
+        return
+    t.dodge.time = b.role("x") in b.call.times
+    inner = s.resolve("inner")
+    if inner:
+        for i in t.drawn:
+            b.call.layers += _Inner(s, i, b.flip, t).layers(inner)
+
+
+class _Inner:
+    """The inner marks of violin ``i`` (layers in the violin's frame)."""
+
+    def __init__(self, v: Violin, i: int, flip: bool, bodies: Any) -> None:
+        self.v, self.i, self.flip, self.d = v, i, flip, bodies.dodge
+        self.scale, self.lw = bodies.scale, v.resolve("edge_width")
+        self.k = v.cols.categories[i]
+        self.st = v.stats[self.k]
+
+    def centre(self, ctx: Any) -> tuple[float, float]:
+        """The violin's centre (a split half's inner marks shift to its side) and width,
+        in slot space."""
+        c, w = placed(self.d, ctx).geo[self.i]
+        return c + (0.0 if not self.d.side else self.d.side * w * 0.06), w
+
+    def at(self, ctx: Any, xs: list[float]) -> Any:
+        """Slot-space values in data units."""
+        return placed(self.d, ctx).back(xs)
+
+    def _layer(self, geom: str, t: Table, part: str, **options: Any) -> Layer:
+        return Layer(GEOMS[geom], t, paint=Paint(self.v, "violin.inner", at=self, part=part,
+                                                 **options),
+                     flip=self.flip, key=False, occupy=False, each=geom == "rects")
+
+    def layers(self, inner: str) -> list[Layer]:
+        b = self.st["box"]
+        if inner == "box":
+            return self._box(b)
+        if inner == "quartiles":
+            return [self._quartile(q, "solid" if i == 1 else "dashed")
+                    for i, q in enumerate((b.q1, b.median, b.q3))]
+        pts = Table(y=self.v.cols.values[self.i])
+        pts.lazy["x"] = lambda ctx: self.at(ctx, [self.centre(ctx)[0]] *
+                                            len(self.v.cols.values[self.i]))
+        return [self._layer("points", pts, "points")]
+
+    def _box(self, b: Any) -> list[Layer]:
+        line = Table(y=[b.low, b.high])
+        line.lazy["x"] = lambda ctx: self.at(ctx, [self.centre(ctx)[0]] * 2)
+        body = Table(y0=[b.q1], y1=[b.q3])
+        body.lazy["x0"] = lambda ctx: self.at(ctx, [self.centre(ctx)[0] -
+                                                    self.centre(ctx)[1] * 0.03])
+        body.lazy["x1"] = lambda ctx: self.at(ctx, [self.centre(ctx)[0] +
+                                                    self.centre(ctx)[1] * 0.03])
+        dot = Table(y=[b.median])
+        dot.lazy["x"] = lambda ctx: self.at(ctx, [self.centre(ctx)[0]])
+        return [self._layer("path", line, "whisker"), self._layer("rects", body, "body"),
+                self._layer("points", dot, "median")]
+
+    def _quartile(self, q: float, dash: str) -> Layer:
+        t = Table(y=[q, q])
+        side = self.d.side
+
+        def ends(ctx: Any) -> list[float]:
+            c, w = self.centre(ctx)
+            dd = stats.density_at(self.st, q, self.v.value_scale()) * self.scale[self.k] * w / 2
+            return self.at(ctx, [c - dd if side <= 0 else c, c + dd if side >= 0 else c])
+        t.lazy["x"] = ends
+        return self._layer("path", t, "quartile", dash=dash)
+
+
+@role("violin.inner")
+def _inner_paint(s: Violin, ctx: Any, glyph: bool, at: Any = None, part: str = "",
+                 dash: str = "solid") -> Any:
+    """The inner marks of a violin: its whisker line, body, median dot, quartile lines or
+    points, in its outline color."""
+    c = s.edges(ctx)[at.i]
+    if part == "whisker":
+        return {"color": c, "width": max(at.lw, 0.5)}
+    if part == "body":
+        return {"fill": c, "stroke": None, "line_width": None}
+    if part == "quartile":
+        width = at.lw or 0.8
+        return {"color": c, "width": width, "dash": dash_of(dash, width)}
+    if c is None:
+        return None
+    if part == "points":
+        return Marks(None, 3.0, c, None)
+    m, w = at.centre(ctx)
+    pl = placed(at.d, ctx)
+    bw = abs(pl.px(m + w * 0.03) - pl.px(m - w * 0.03))
+    return Marks(None, max(bw * 0.9, 2.0), "white", None)