plot-io 0.12.0__py3-none-win_amd64.whl

plot_io/axis.py

@@ -0,0 +1,1347 @@
+"""Axes: settings (:class:`Axis`) and their state while a figure is drawn
+(:class:`AxisState`: scale, limits, ticks, mapping to the page)."""
+
+import inspect
+import math
+from collections.abc import Sequence
+from typing import Any
+
+from vec_io.arrays import doubles
+
+from ._methods import AxisMixin
+from . import kernels
+from .transform import affine, apply
+from .limits import check_limits, needs_quantiles, resolve_limits, symmetric
+from .scales import AXIS_SCALES, Scale, get_scale
+from .color.values import color
+from . import groups
+from .settings import (Setting, Settings, boolean, either, literal, number, one_of, pair,
+                       table, text, time_zone)
+from .validators import angle, length
+from .text import Font, font_of, lines_box, wrap
+from .numbers import NumberStyle
+from .formatters import CategoryFormatter, NumberFormatter, TimeFormatter
+from .ticks import (MAX_TICKS, Every, Tick, minor_linear, numeric_ticks, power_labels,
+                    step_values)
+from .times import axis_value, calendar_ticks, from_seconds
+
+__all__ = ["Axis", "AxisState", "Mapper"]
+
+
+def _shrunk(q: list[tuple[float, float]], d: float) -> list[tuple[float, float]]:
+    """A rectangle's corners (in order around it) moved ``d`` px inward along its sides
+    (outward for a negative ``d``)."""
+    out = []
+    for k in range(4):
+        p, a, b = q[k], q[(k + 1) % 4], q[(k - 1) % 4]
+        move = [0.0, 0.0]
+        for o in (a, b):
+            ux, uy = o[0] - p[0], o[1] - p[1]
+            n = math.hypot(ux, uy)
+            if n > 2 * d and n > 0:
+                move[0] += d * ux / n
+                move[1] += d * uy / n
+        out.append((p[0] + move[0], p[1] + move[1]))
+    return out
+
+
+def _values(v: Any, what: str) -> list[Any] | None:
+    """The items of a non-string iterable (``None`` for anything else), each a number, a
+    date or text."""
+    if isinstance(v, (str, bytes)) or not hasattr(v, "__iter__") or (
+            getattr(v, "shape", None) == ()):
+        return None
+    out: list[Any] = []
+    for x in v:
+        if isinstance(x, str):
+            out.append(x)
+            continue
+        try:
+            out.append(axis_value(x))
+        except ValueError:
+            raise ValueError(f"{what}: expected numbers, dates or text, got {x!r}") from None
+    return out
+
+
+def _ticks_value(v: Any) -> Any:
+    if v is False or isinstance(v, Every) or callable(v):
+        return v
+    out = _values(v, "ticks")
+    if out is None:
+        raise ValueError(f"expected False, a list of values, plt.every(step) or a function "
+                         f"f(lo, hi), got {v!r}")
+    return out
+
+
+def _minor_value(v: Any) -> Any:
+    if isinstance(v, bool) or isinstance(v, Every) or callable(v):
+        return v
+    out = _values(v, "minor_ticks")
+    if out is None:
+        raise ValueError(f"expected True, False, a list of values, plt.every(step) or a "
+                         f"function f(lo, hi), got {v!r}")
+    return out
+
+
+def _check_count(labels: list[Any], ticks: list[Any], what: str) -> None:
+    if len(labels) != len(ticks):
+        raise ValueError(f"tick_labels: {len(labels)} labels for {len(ticks)} {what}")
+
+
+_rotation = either(literal("auto"), angle(-180, 180))
+
+
+def _region(v: Any) -> Any:
+    from .genome.regions import parse_regions
+    return parse_regions(v)
+
+
+def _chr_sizes(v: Any) -> Any:
+    """A mapping of chromosome names to sizes (bp)."""
+    from collections.abc import Mapping
+    if not isinstance(v, Mapping):
+        raise ValueError(f"expected a mapping of chromosome names to sizes, got {v!r}")
+    from .genome.regions import parse_bp
+    return {str(k): parse_bp(n, f"the size of {k!r}", positive=True) for k, n in v.items()}
+
+
+def _scale_bar(v: Any) -> Any:
+    from .genome.scale import check_scale_bar
+    return check_scale_bar(v)
+
+
+def _tick_format(v: Any) -> Any:
+    from .genome.scale import check_tick_format
+    return check_tick_format(v)
+
+
+def _origin(v: Any) -> Any:
+    from .transform import check_origin
+    return check_origin(v)
+
+
+
+class Axis(AxisMixin, Settings):
+    """An axis of a plot (``plot.x_axis``, ``plot.y_axis``); color and size axes
+    (:mod:`plot_io.mapped`) are axes too.
+
+    Scales (``scale``): ``linear``; ``log``, ``log10``, ``log2``, ``ln`` (v > 0; they place
+    data alike and differ in their ticks); ``sqrt`` (v ≥ 0); ``exp`` (v < 709); ``symlog``
+    (sign(v)·log₁₀(1 + abs(v)/``linthresh``)); ``logit`` (0 < p < 1); ``time`` (seconds since
+    1970-01-01 UTC); ``category``; ``genome`` (bp less the axis' ``origin``, limits the
+    axis' ``region`` without padding, tick labels in ``unit``).  Values outside the domain
+    are missing, except the ends of shapes (bar baselines, fill edges, stems, error-bar
+    ends), drawn at the axes' edge.  Mixing category and numeric series on an axis raises.
+
+    Dates (``datetime``, ``date``, ``datetime64``, pandas timestamps) make a ``time`` axis:
+    naive values read as UTC, aware ones shown in their zone (``tz``).  Ticks follow the
+    calendar (years, months, days, hours, minutes, seconds), labels are concise (``2026``,
+    ``Mar``, ``Mar 14``, ``14:30``) with the unit common to every tick written at the end of
+    the axis; ``tick_format`` takes a ``strftime`` pattern or a function of a ``datetime``.
+
+    Limits: ``"auto"`` is the union of the series' extents plus ``padding`` (per side, in
+    position space); ``"lo/hi"`` takes ``min``, ``max``, a number, an ISO date or ``q:F`` (a
+    quantile of the axis' values) each side (``"0/max"``, ``"q:0.01/q:0.99"``), or
+    ``(lo, hi)`` with ``None`` automatic.  A single value widens by ±0.5 (a time: by one unit
+    of its data).  Limits high to low, or ``invert=True``, reverse the axis.
+    ``include_zero="auto"`` reaches 0 where a series asks (both axes of scatter plots, the
+    value axis of lines, areas and boxes), before padding.  ``snap`` moves automatic limits
+    onto major ticks (linear and log axes): the default ``("4%", "8%")`` extends a limit to
+    the next tick within 8% of the axis or pulls it back to a tick it passed by at most 4%;
+    ``True`` always extends, ``False`` keeps the padded limits.
+
+    Ticks: linear steps 1, 2, 2.5 (not with a ``precision``) or 5 × 10ᵏ, at most
+    ``max_ticks`` (on x the step grows until labels do not overlap); log decades labelled
+    10ᵏ (below three decades 1, 2 and 5 × 10ᵏ as numbers), minor ticks 2–9; ``log2`` powers of two; ``ln`` powers of e;
+    ``symlog`` 0, ±``linthresh``, then decades; ``logit`` 0.5, 0.1/0.9, 0.01/0.99, …;
+    categories one each, turned 45° when they overlap (``tick_rotation="auto"``), else every
+    k-th.  Tick labels still closer than ``tick_label_gap`` (chosen or given, either axis)
+    are labelled every k-th, then turned 45° (``"auto"``, x), wrapped at spaces, made smaller
+    down to ``label_min_size``, and else one is drawn with a warning; a y label at the corner
+    over an x label is left out; a dendrogram's leaves (and the axes sharing them) all labelled, turned 90°, then
+    smaller down to ``label_min_size``, and every k-th only below it.  Labels share the fewest decimals that tell them apart; beyond 10^``sci_limits``
+    they are mantissas and ×10ᵏ is written at the end of the axis.  ``ticks`` takes values
+    (numbers, dates, ISO text, category names), :func:`every` (``every("3 months")``,
+    ``every(1)``: each decade) or a function of the limits; ``ticks=False`` hides them.
+    ``grid`` and ``minor_grid`` draw at the major and minor ticks, ``zero_line`` at 0, under
+    the series.  ``side`` moves ticks, labels and axis line; ``mirror`` repeats the ticks on
+    the other side; ``spine_offset`` moves the axis line away; ``spine_trim`` draws it from
+    the first to the last major tick.  ``color`` sets the default of ``line_color``,
+    ``tick_color``, ``tick_label_color`` and ``label_color``.
+    """
+
+    @property
+    def nominal_scale(self) -> str:
+        """``scale``, or ``"linear"`` while unset (before it is detected from the data)."""
+        s = self.resolve("scale")
+        return "linear" if s is None else s
+
+    SETTINGS = table(
+        label=Setting(text, doc="Axis title: a string or rich content; `\\n` starts a line "
+                                "in a row band."),
+        label_position=Setting(one_of("axis", "band", "left", "inside"),
+                               doc="Where the label of a plot's y axis goes: `axis` (beside "
+                                   "the tick labels); in a band left of the plot, lined up "
+                                   "with the labels of the other plots of its grid column "
+                                   "(row labels): `band` (rotated) or `left` (horizontal, "
+                                   "right-aligned); `inside` (top left inside the axes)."),
+        **groups.TextStyle.embed("label_", docs={
+            "font_size": "Font size of the label; default: the base font size.",
+            "font_weight": "Axis title weight: `normal`, `bold` or 1–1000.",
+            "font_style": "Axis title style: `normal`, `italic`, `oblique` or "
+                          "`\"oblique 10deg\"`.",
+            "color": "Axis title color."}),
+        scale=Setting(one_of(*AXIS_SCALES),
+                      doc="`linear`, `log` (base 10), `ln` (base e), `log2`, `log10`, `sqrt`, "
+                          "`exp`, `symlog`, `logit`, `time`, `category` or `genome`; "
+                          "default: `category` for categorical series, `time` for dates, `genome` for genome "
+                          "series, else `linear`."),
+        region=Setting(_region,
+                       doc="Genome scale: the region drawn, its limits: "
+                           "`\"chr2:143,120,001-143,780,000\"` (1-based, inclusive), "
+                           "`(chr, start, end)` (0-based, half-open) or a mapping; genome "
+                           "series read it. A chromosome name (`\"chr1\"`): the whole "
+                           "chromosome (`chr_sizes`). A list of regions or names: drawn "
+                           "side by side (`region_widths`, `region_gap`), each series "
+                           "reading each."),
+        chr_sizes=Setting(_chr_sizes,
+                          doc="Genome scale: chromosome sizes (a mapping, "
+                              "`gwseq_io.get_chr_sizes(\"mm10\")`) giving the end of a whole "
+                              "chromosome (`region=\"chr1\"`); `None`: the largest size the "
+                              "figure's readers give."),
+        region_widths=Setting(one_of("span", "equal"),
+                              doc="Genome scale over several regions: the width of each, "
+                                  "its share of the bp (`span`) or `equal`."),
+        region_gap=Setting(length(lo=0, percent="em"),
+                           doc="Genome scale over several regions: the gap between them."),
+        unit=Setting(one_of("auto", "bp", "kb", "Mb", "Gb", aliases={"mb": "Mb", "gb": "Gb"}),
+                     doc="Genome scale: unit of the tick labels; `auto`: with ticks about a "
+                         "fifth of the span apart, the largest unit in which they are at "
+                         "least 1 apart and at most 1000, else the largest in which they are "
+                         "at most 1000 with at most 3 decimals, else bp."),
+        unit_in=Setting(one_of("label", "ticks"),
+                        doc="Genome scale: where the unit is written, in the axis label "
+                            "(`chr2 (Mb)`) or after each tick label (`500kb`)."),
+        scale_bar=Setting(_scale_bar,
+                          doc="Genome scale (x): a scale bar at the axis' right end (at "
+                              "each region's) with its length written left of it, in "
+                              "place of the ticks and tick labels; the label is then the "
+                              "chromosome alone. `True`: the largest 1, 2 or 5 × 10ᵏ bp at "
+                              "most a fifth of the axis; a length (`\"10kb\"`); `False`: "
+                              "ticks."),
+        origin=Setting(_origin,
+                       doc="The value drawn at 0 for the axis' series (a series' own "
+                           "`x_origin` wins): a number, or `\"center\"`, `\"start\"`, "
+                           "`\"end\"` of the region (genome scale), else of each series' "
+                           "range. Values are drawn at `(v − origin) × x_scale`; limits, "
+                           "ticks and decorations are in the drawn units."),
+        linthresh=Setting(number(positive=True),
+                          doc="Half-width of the linear region of a `symlog` axis."),
+        tz=Setting(time_zone,
+                   doc="Time zone of a time axis (a `tzinfo`, or a zone name such as "
+                       "`\"Europe/Paris\"`); default: the zone of the first aware date, else "
+                       "naive (UTC)."),
+        limits=Setting(check_limits,
+                       doc="`\"auto\"`, `\"lo/hi\"` or `[lo, hi]` (a tuple too); each side a "
+                           "number, `\"min\"`, `\"max\"`, `\"q:F\"` (a quantile), a date, or "
+                           "`\"auto\"`/`None`: `\"0/max\"` is `[0, \"max\"]`; in a pair on a "
+                           "category axis, a category by name (shown whole); `\"-m/m\"`: "
+                           "symmetric about the `center` (or 0), `m` the farthest value."),
+        padding=Setting(either(literal("auto"), length(lo=0, percent="data_range")),
+                        doc="Space added to automatic limits, as a fraction of the range; "
+                            "`\"auto\"`: `auto_padding`, or 0 on axes of series drawn to "
+                            "exact limits (box value axes, heatmaps, …) and in plots "
+                            "without axes."),
+        auto_padding=Setting(length(lo=0, percent="data_range"),
+                             doc="The fraction `padding=\"auto\"` adds on each side."),
+        sticky=Setting(boolean,
+                       doc="No padding past the baseline of bars and histograms when an "
+                           "automatic limit is on it (matplotlib's sticky edges)."),
+        invert=Setting(boolean, doc="Reverse the axis (limits given high to low, "
+                                    "`(2, 0)`, reverse it too)."),
+        ticks=Setting(_ticks_value,
+                      doc="`False` (no ticks), the tick values: any iterable (a list, a "
+                          "range, an array) of numbers, dates, `datetime64` or ISO 8601 "
+                          "text, on a category axis categories by name or index; "
+                          "`plt.every(step)` (`plt.every(\"2 months\")`; decades on log "
+                          "axes); or a function `f(lo, hi)` of the limits (datetimes on a "
+                          "time axis) returning the values."),
+        tick_labels=Setting(lambda v: [text(x) for x in v],
+                            doc="Labels of `ticks` (of the categories without `ticks`), as "
+                                "many as they; markup is read, `\\n` starts a line."),
+        minor_ticks=Setting(_minor_value,
+                            doc="`True`, `False`, or the minor tick values, "
+                                "`plt.every(step)` or a function (as `ticks`); default: on "
+                                "for base-10 logs."),
+        tick_format=Setting(_tick_format,
+                            doc="Number format: `auto`, `percent`, `sci`, `eng`, `si`, `int`, "
+                                "a format string (`\"{:.2f}\"`, printf `\"%.2f\"` or a "
+                                "bare spec `\".2f\"`; strftime `%` codes on a time axis) or "
+                                "a function; on a genome axis also `chr:pos` "
+                                "(`chr2:143,250,000`)."),
+        tick_rotation=Setting(_rotation,
+                              doc="Label rotation in degrees, or `\"auto\"` (45° when "
+                                  "x labels overlap; 90° for a dendrogram's leaves)."),
+        label_min_size=Setting(length(positive=True, font=True),
+                               doc="Smallest font size tick labels that overlap shrink to "
+                                   "(a dendrogram's leaves: before some are left out)."),
+        max_ticks=Setting(either(literal("auto"), number(lo=1, hi=MAX_TICKS, integer=True)),
+                          doc="Most major ticks; `\"auto\"`: one per `tick_spacing` of "
+                              "axis length, at least 2, at most `auto_max_ticks`."),
+        tick_spacing=Setting(pair(length(positive=True, percent="em", em="tick_label_font_size")),
+                             doc="Space per automatic tick, in tick label font sizes, on "
+                                 "horizontal and vertical axes."),
+        time_tick_spacing=Setting(pair(length(positive=True, percent="em",
+                                               em="tick_label_font_size")),
+                                  doc="`tick_spacing` of time axes."),
+        tick_label_gap=Setting(length(lo=0, percent="em", em="tick_label_font_size"),
+                               doc="Smallest gap between neighbouring tick labels side by "
+                                   "side: fewer numeric ticks, or category labels rotated "
+                                   "and thinned out, below it."),
+        category_label_spacing=Setting(pair(length(positive=True, percent="em",
+                                                   em="tick_label_font_size")),
+                                       doc="Distance between category labels: rotated "
+                                           "(horizontal axes) and stacked (vertical "
+                                           "axes); labels closer than it are thinned out."),
+        auto_max_ticks=Setting(pair(number(lo=2, hi=MAX_TICKS, integer=True)),
+                               doc="Most automatic ticks on numeric and time axes."),
+        sci_limits=Setting(pair(number(integer=True)),
+                           doc="Exponents beyond which labels become mantissas × 10ᵏ."),
+        tick_length=Setting(length(lo=0, percent="across"), doc="Tick length."),
+        minor_tick_length=Setting(length(lo=0, percent="tick_length"),
+                                  doc="Minor tick length; default 0.6 × `tick_length`."),
+        tick_direction=Setting(one_of("out", "in", "both"), doc="`out`, `in` or `both`."),
+        **groups.Stroke.embed("tick_", only=("color", "line_width"),
+                       docs={"color": "Tick color.", "line_width": "Tick line width."}),
+        **groups.TextStyle.embed("tick_label_", only=("font_size", "font_weight", "color"),
+                          docs={"font_size": "Font size of tick labels.",
+                                "font_weight": "Tick label weight: `normal`, `bold` or "
+                                               "1–1000.",
+                                "color": "Tick label color."}),
+        tick_pad=Setting(length(lo=0, percent="across"), doc="Gap between ticks and labels."),
+        label_pad=Setting(length(lo=0, percent="across"), doc="Gap between tick labels and the label."),
+        color=Setting(color,
+                      doc="Color of the axis line, ticks and labels (the default of "
+                          "`line_color`, `tick_color`, `tick_label_color`, `label_color`)."),
+        **groups.Stroke.embed("line_", only=("color", "line_width"),
+                       docs={"color": "Axis line color.", "line_width": "Axis line width."}),
+        side=Setting(one_of("left", "right", "bottom", "top"),
+                     doc="Where the ticks, labels and axis line go: `bottom` or `top` (x "
+                         "axis), `left` or `right` (y axis)."),
+        mirror=Setting(boolean, doc="Ticks also on the opposite side of the axes."),
+        spine_offset=Setting(length(lo=0, percent="across"),
+                             doc="Distance the axis line (with its ticks and labels) is "
+                                 "moved away from the axes."),
+        spine_trim=Setting(boolean,
+                           doc="Axis line from the first to the last major tick only."),
+        include_zero=Setting(either(boolean, literal("auto")),
+                             doc="Extend automatic limits to 0 (linear and sqrt scales), "
+                                 "before padding and `snap`: `True`, or `\"auto\"` where a "
+                                 "series on the axis asks for it (Vega-Lite's rule: scatter "
+                                 "axes, the value axis of lines, areas and boxes)."),
+        zero_line=Setting(boolean, doc="A line across the plot at 0."),
+        **groups.Stroke.embed("zero_line_", only=("color", "line_width"),
+                       docs={"color": "Zero line color; default `line_color`.",
+                             "line_width": "Zero line width; default `line_width`."}),
+        snap=Setting(either(boolean, pair(length(lo=0, percent="data_range"))),
+                       doc="Automatic limits on major ticks (linear and log scales): `True`, "
+                           "out to the enclosing ticks; `(back, out)`, out to a tick within "
+                           "`out` (`%` of the axis), or back to one within `back` that "
+                           "is still outside the data; `False`: as padded."),
+        grid=Setting(boolean, doc="Major grid lines across the plot."),
+        **groups.Stroke.embed("grid_", only=("color", "line_width", "line_style"),
+                       docs={"color": "Grid line color.", "line_width": "Grid line width.",
+                             "line_style": "Grid line style or dash list."}),
+        minor_grid=Setting(boolean,
+                           doc="Minor grid lines: at the minor ticks, or halfway between "
+                               "major ticks on linear axes without minor ticks."),
+        **groups.Stroke.embed("minor_grid_", only=("color", "line_width", "line_style"),
+                       checks={"line_width": length(lo=0, percent="grid_width")},
+                       docs={"color": "Minor grid color; default `grid_color`.",
+                             "line_width": "Minor grid width; default half `grid_width`.",
+                             "line_style": "Minor grid style; default `grid_style`."}),
+        visible=Setting(boolean, doc="Draw the axis (ticks, labels)."),
+        **groups.Font.embed(),
+        text_color=Setting(color, inherited=True, doc="Text color."),
+        **groups.NumberFormat.embed(),
+    )
+
+    def __init__(self, owner: Any, role: str) -> None:
+        self._owner = owner
+        self.role = role
+        fig = getattr(owner, "figure", None)
+        #: the figure's axis of this role, whose own values this axis takes (see
+        #: :func:`plot_io.settings.cascade`)
+        self._figure_axis: Settings | None = getattr(fig, f"{role}_axis", None) \
+            if role in ("x", "y") else None
+        super().__init__()
+
+    def _parent(self) -> Settings | None:
+        return self._owner
+
+    def _shared(self) -> Settings | None:
+        """The figure's axis of this role (``figure.x_axis``), for a plot's x or y axis."""
+        return self._figure_axis
+
+    def _levels(self, name: str) -> tuple[tuple[str, ...], ...]:
+        """One level: ``XAxis``/``YAxis`` keys before the class's; a color axis takes
+        ``Colorbar`` keys of the axis settings a colorbar lacks (its guide's)."""
+        classes = tuple(c for level in super()._levels(name) for c in level)
+        if self.role == "c":
+            from .colorbar import Colorbar
+            return (classes,) if name in Colorbar.SETTINGS else (("Colorbar",) + classes,)
+        return ((f"{self.role.upper()}Axis",) + classes,)
+
+    def _level_key(self) -> Any:
+        return self.role
+
+    def _box(self, kind: str, name: str) -> float:
+        if kind in ("across", "along"):
+            vertical = self.role == "y"
+            if (kind == "across") == vertical:
+                kind = "axes_width"
+            else:
+                kind = "axes_height"
+        return super()._box(kind, name)
+
+    def __call__(self, label: Any = None, **settings: Any) -> "Axis":
+        """Set the axis title (``label``) and any axis settings; returns the axis."""
+        if label is not None:
+            settings["label"] = label
+        return self.set(**settings)
+
+    def __repr__(self) -> str:
+        return f"Axis({self.role})"
+
+
+class Mapper:
+    """Data → page coordinate on one axis: ``page = a·f(v) + b``."""
+
+    __slots__ = ("function", "a", "b", "forward", "options", "flo", "fhi")
+
+    def __init__(self, scale: Scale | None, flo: float, fhi: float, p0: float, p1: float) -> None:
+        self.function = scale.function if scale is not None else None
+        self.options = scale.options if scale is not None else {}
+        self.forward = scale.f if scale is not None else (lambda v: v)
+        self.flo, self.fhi = flo, fhi
+        span = fhi - flo
+        self.a = (p1 - p0) / span if span else 0.0
+        self.b = p0 - self.a * flo
+
+    def __call__(self, v: float) -> float:
+        return self.a * self.forward(v) + self.b
+
+    def many(self, values: Any) -> Any:
+        return kernels.scaled(values, self.a, self.b, self.function, **self.options)
+
+    def ends(self, values: Any) -> Any:
+        """As :meth:`many`, for the ends of shapes (bar baselines, band edges, segment
+        ends): values below the scale's domain (0 on a log axis) at the edge of the low
+        limit, values above it at the edge of the high limit."""
+        if self.function is None:
+            return self.many(values)
+        return kernels.scaled(values, self.a, self.b, self.function, **self.options,
+                              below=self.position(self.flo), above=self.position(self.fhi))
+
+    def position(self, f: float) -> float:
+        """Page coordinate of a value already through the scale function."""
+        return self.a * f + self.b
+
+    def affine(self, origin: float, scale: float, role: str) -> "Mapper":
+        """This mapper for a series whose values ``v`` are drawn at ``(v - origin) *
+        scale`` (``x_origin``…): on a linear or time axis, still ``a·v + b``."""
+        if self.function is not None:
+            raise ValueError(f"{role}_origin, {role}_scale and {role}_extent need a linear "
+                             f"or time {role} axis")
+        m = Mapper(None, 0.0, 1.0, 0.0, 1.0)
+        m.a, m.b = self.a * scale, self.b - self.a * scale * origin
+        return m
+
+
+def _about(scale: Scale, center: float, flo: float, fhi: float, lo_auto: bool, hi_auto: bool,
+           lo: float, hi: float) -> tuple[float, float, float, float]:
+    """Limits symmetric about ``center`` (on the scale): the automatic sides as far from it
+    as the farther side (both automatic) or the given side."""
+    fc = scale.f(center)
+    if not math.isfinite(fc):
+        return flo, fhi, lo, hi
+    a, b = sorted((flo, fhi))
+    d = max(fc - a, b - fc) if lo_auto and hi_auto else (b - fc if lo_auto else fc - a)
+    if not d > 0:
+        return flo, fhi, lo, hi
+    return fc - d, fc + d, scale.inverse(fc - d), scale.inverse(fc + d)
+
+
+class AxisState:
+    """An axis while drawing: resolved scale, limits, categories and ticks."""
+
+    def __init__(self, axis: Axis) -> None:
+        self.axis = axis
+        self.scale: Scale | None = None      # None: category
+        self.categories: list[Any] = []
+        self.lo = 0.0                        # data limits (category: index range)
+        self.hi = 1.0
+        self.flo = 0.0                       # limits after the scale function
+        self.fhi = 1.0
+        self.data_lo = math.nan              # union of the series' extents
+        self.data_hi = math.nan
+        self.moved = False                   # a series' x_origin, … moved its values
+        self.ticks: list[Tick] = []
+        #: what is written at the end of the axis (×10ᵏ, ``+1×10⁹``, a date), or None
+        self.offset_label: Any = None
+        self.rotation = 0.0
+        self.length = 0.0
+        self.auto_invert = False             # inverted by a series (heatmap rows)
+        self.reversed = False                # limits given high to low: drawn inverted
+        self._auto = (False, False)          # automatic low / high limit (for `snap`)
+        self._zero_pad = False               # a series wants exact limits (heatmaps)
+        self._base = (0.0, 1.0, 0.0, 1.0)    # lo, hi, flo, fhi before `snap`
+        self._inner = (0.0, 1.0)             # flo, fhi before padding (`snap` keeps them)
+        self._pad_px = 0.0                   # padding in px, added when the length is known
+        self._roomers: list[Any] = []        # series with labels past their values
+        self._pad_frac = 0.0                 # padding as a fraction of the range
+        self._unpadded_px = self._base       # limits before the px padding
+        self.shared: "AxisState | None" = None   # the group's leader (shared axes)
+        self.hide_labels = False             # an inner plot of a shared group
+        self.auto_label: Any = None          # the column name of the series' data
+        self.tz: Any = None                  # time zone of a time axis
+        self.genome = False                  # a genome scale (linear, in bp)
+        self.whole = False                   # integer ticks only (grid rows and columns)
+        self.region: Any = None              # its region (the axis', else a series')
+        self.origin = 0.0                    # the position drawn at 0 on a genome axis
+        #: the regions of a genome axis over several, side by side
+        #: (:class:`plot_io.genome.scale.Segments`), else None
+        self.segments: Any = None
+        #: the label of each region of an axis over several: ``[(Block, Segment)]``
+        self.segment_titles: list[Any] = []
+        self.hide_title = False              # an inner plot of a group: tick labels only
+        #: the axis label's lines as last measured (wrapped to the plot's box)
+        self.title_block: Any = None
+        #: the height of the ×10ᵏ offset's own row under the label row (0: beside the label)
+        self.offset_row = 0.0
+        #: the font size the tick labels were made at when even then only one fits
+        self.crowded: float | None = None
+        #: ``[(value, label)]`` the calls on the axis give as its ticks (named rows)
+        self.call_ticks: list[tuple[float, Any]] | None = None
+        #: whether those ticks' labels are thinned until none overlap
+        self.call_thin = False
+        #: whether the labels are a dendrogram's leaves (:meth:`_fit_leaves`)
+        self.call_leaves = False
+        #: the leaves' font size when shrunk to fit, else ``None``
+        self.leaf_size: float | None = None
+        #: px the axis leaves at its low and high ends of the axes (a y axis over the
+        #: value lane of a plot with interval lanes, :mod:`plot_io.genome.lanes`)
+        self.span = (0.0, 0.0)
+
+    def on_far_side(self) -> bool:
+        """Whether the axis is drawn on the top (x) or right (y) side of the axes."""
+        return self.axis.resolve("side") in ("top", "right")
+
+    @property
+    def is_category(self) -> bool:
+        return self.scale is None
+
+    def f(self, v: float) -> float:
+        return self.scale.f(v) if self.scale is not None else v
+
+    @property
+    def inverted(self) -> bool:
+        if self.shared is not None:
+            return self.shared.inverted
+        a = self.axis
+        if self.reversed:
+            return True
+        return a.resolve("invert") if a.is_set("invert") else self.auto_invert
+
+    def tick_out(self, marks: bool = False) -> tuple[float, float]:
+        """Tick extent outside and inside the axes: of all ticks (the room they take), or
+        with ``marks`` of the major tick marks."""
+        a = self.axis
+        n = a.resolve("tick_length")
+        if not marks and any(not t.major for t in self.ticks):
+            n = max(n, a.resolve("minor_tick_length"))
+        d = a.resolve("tick_direction")
+        return (n if d in ("out", "both") else 0.0), (n if d in ("in", "both") else 0.0)
+
+    def mapper(self, p0: float, p1: float) -> Mapper:
+        """Data → page from the axes' low end ``p0`` to their high end ``p1``, less the
+        axis' ``span`` at each end."""
+        lo, hi = self.span
+        if lo or hi:
+            d = 1.0 if p1 >= p0 else -1.0
+            p0, p1 = p0 + d * lo, p1 - d * hi
+        inv = self.inverted
+        if inv:
+            p0, p1 = p1, p0
+        return Mapper(self.scale, self.flo, self.fhi, p0, p1)
+
+    # -- limits ------------------------------------------------------------------
+
+    def resolve(self, series: Sequence[Any], padded: bool) -> None:
+        """Scale, categories and limits from the series drawn on this axis."""
+        role = self.axis.role
+        scale_name = self.axis.resolve("scale")
+        cats: list[Any] = []
+        categorical = False
+        for s in series:
+            c = s.categories(role)
+            if c is not None:
+                categorical = True
+                for k in c:
+                    if k not in cats:
+                        cats.append(k)
+        on_axis = [s for s in series if s.has_axis(role)]
+        self._roomers = [s for s in on_axis if hasattr(s, "label_room")]
+        self.auto_invert = any(s.inverts(role) for s in on_axis)
+        self.whole = bool(on_axis) and all(
+            getattr(s, "whole_ticks", lambda r: False)(role) for s in on_axis)
+        times = [s for s in on_axis if getattr(s, "time_role", lambda r: None)(role)]
+        genome = [s for s in on_axis if getattr(s, "scale_of", lambda r: None)(role) == "genome"]
+        if scale_name is None:
+            scale_name = "category" if categorical else ("time" if times else
+                                                         "genome" if genome else "linear")
+        self.genome = scale_name == "genome"
+        if self.genome:
+            scale_name = "linear"
+            from .genome.series import axis_region
+            self.region = axis_region(self.axis) or next(
+                (r for r in (s.region_of(role) if hasattr(s, "region_of") else
+                             getattr(s, "region", None) for s in genome) if r is not None),
+                None)
+            from .genome.scale import origin_of, segments_of
+            self.segments = segments_of(self.axis._owner) if role == "x" else None
+            if self.segments is not None:
+                self._check_segmented(on_axis)
+                self.region = None
+            o = origin_of(self.axis.resolve("origin"), self.region)
+            self.origin = 0.0 if o is None else o
+        self.tz = self.axis.resolve("tz")
+        if self.tz is None and times:
+            self.tz = times[0].time_role(role)[1]
+        if scale_name == "category":
+            if any(s.categories(role) is None and s.has_axis(role) for s in series):
+                raise ValueError(f"{role} axis mixes categorical and numeric series")
+            self.scale = None
+            self.categories = cats
+            n = max(len(cats), 1)
+            self.lo, self.hi = -0.5, n - 0.5
+            spec = self._named_limits(self.axis.resolve("limits"))
+            if spec != "auto":
+                lo, hi, _, _ = resolve_limits(spec, self.lo, self.hi)
+                self.lo, self.hi = float(lo), float(hi)
+            self.flo, self.fhi = self.lo, self.hi
+            return
+        if categorical:
+            raise ValueError(f"{role} axis has categorical series but scale {scale_name!r}")
+        scale = self.scale = get_scale(scale_name, self.axis.resolve("linthresh"))
+        count, lo, hi = 0, math.inf, -math.inf
+        zero_pad, self.moved = False, False
+        sticky: list[float] = []
+        for s in series:
+            if not s.has_axis(role):
+                continue
+            t = affine(s, role)            # x_origin, …: limits in the drawn units
+            if t is not None and scale.function is not None:
+                raise ValueError(f"{role}_origin, {role}_scale and {role}_extent need a "
+                                 f"linear or time {role} axis")
+            n, a, b = s.extent(role, scale)
+            if n:
+                if t is not None:
+                    finite = math.isfinite(b - a)
+                    a, b = sorted((apply(t, a), apply(t, b)))
+                    if finite and not math.isfinite(b - a):
+                        kind = getattr(getattr(s, "series", s), "kind", "series")
+                        raise ValueError(f"{kind}: {role}_origin, {role}_scale or "
+                                         f"{role}_extent draw its {role} values beyond the "
+                                         f"number range")
+                    self.moved = True
+                count += n
+                lo, hi = min(lo, a), max(hi, b)
+            zero_pad = zero_pad or s.zero_padding(role)
+            sticky.extend(s.sticky(role) if t is None else [apply(t, v) for v in s.sticky(role)])
+        if not count:
+            lo, hi = (1.0, 10.0) if scale.base is not None else (0.0, 1.0)
+        self.data_lo, self.data_hi = lo, hi
+        zero = self.axis.resolve("include_zero")
+        if zero == "auto":
+            zero = any(s.zero_default(role) for s in on_axis)
+        spec = self._named_limits(self.axis.resolve("limits"))
+        if self.genome:                       # the region (drawn), without padding or 0
+            zero, zero_pad = False, True
+            if spec == "auto" and self.region is not None:
+                spec = (self.region.start - self.origin, self.region.end - self.origin)
+            elif spec == "auto" and self.segments is not None:
+                spec = (0.0, self.segments.total)
+        if zero and scale.name in ("linear", "sqrt"):
+            lo, hi = min(lo, 0.0), max(hi, 0.0)
+        qs = needs_quantiles(spec)
+        qmap: dict[float, float] = {}
+        if qs:
+            from array import array
+            vals = array("d")
+            for s in series:
+                if s.has_axis(role):
+                    v = s.values(role)
+                    if v is not None:
+                        t = affine(s, role)
+                        v = doubles(v)
+                        vals.extend(v if t is None else kernels.scaled(v, t[1], -t[0] * t[1]))
+            vals = array("d", [v for v in vals if math.isfinite(v) and (
+                scale.function is None or scale.contains(v))])
+            if len(vals):                      # none: quantile sides at the data's ends
+                for q, r in zip(qs, kernels.quantiles(vals, qs)):
+                    qmap[q] = r
+        lo2, hi2, lo_auto, hi_auto = resolve_limits(spec, lo, hi,
+                                                    (lambda q: qmap[q]) if qmap else None)
+        flo, fhi = scale.f(lo2), scale.f(hi2)
+        if not (math.isfinite(flo) and math.isfinite(fhi)):
+            what = {"c": "color", "s": "size"}.get(role, role)
+            raise ValueError(f"{what} axis limits {lo2!r}/{hi2!r} are outside the "
+                             f"{scale.name} scale's domain")
+        center = self.axis.resolve("center") if "center" in self.axis.SETTINGS else None
+        if symmetric(spec):
+            flo, fhi, lo2, hi2 = _about(scale, 0.0 if center is None else center, flo, fhi,
+                                        True, True, lo2, hi2)
+        elif center is not None and (lo_auto or hi_auto):
+            flo, fhi, lo2, hi2 = _about(scale, center, flo, fhi, lo_auto, hi_auto, lo2, hi2)
+        self.reversed = flo > fhi and not (lo_auto or hi_auto)    # (2, 0): inverted
+        if flo > fhi:
+            flo, fhi = fhi, flo
+            lo_auto, hi_auto = hi_auto, lo_auto
+        inner = (flo, fhi)
+        self._pad_frac = 0.0
+        if fhi == flo and scale.name == "time":   # one time: a unit of its data each side
+            from .times import time_unit
+            u = time_unit(flo, self.tz)
+            flo, fhi = flo - u, fhi + u
+        elif fhi - flo < 1e-280:                  # one value (or too close to map to px)
+            flo, fhi = (flo + fhi) / 2 - 0.5, (flo + fhi) / 2 + 0.5
+            if scale.name == "sqrt" and flo < 0:
+                flo, fhi = 0.0, fhi + 0.5
+        else:
+            if sticky and self.axis.resolve("sticky"):    # a side on a baseline: unpadded
+                tol = 1e-12 * max(1.0, abs(flo), abs(fhi))
+                fs = [f for f in (scale.f(v) for v in sticky) if math.isfinite(f)]
+                lo_auto = lo_auto and not any(abs(f - flo) <= tol for f in fs)
+                hi_auto = hi_auto and not any(abs(f - fhi) <= tol for f in fs)
+            name: str | None = "padding"
+            if self.axis.get("padding") == "auto":
+                name = "auto_padding" if padded and not zero_pad else None
+            pad, self._pad_px = self._padding(name)
+            self._pad_frac = pad
+            d = (fhi - flo) * pad
+            if lo_auto:
+                flo -= d
+                if scale.name == "sqrt" and flo < 0:
+                    flo = 0.0
+            if hi_auto:
+                fhi += d
+            if not math.isfinite(scale.inverse(flo)):
+                flo = scale.f(lo2) if scale.f(lo2) < fhi else flo + d
+            if not math.isfinite(scale.inverse(fhi)):
+                fhi = scale.f(hi2)
+        self._inner = inner
+        self.flo, self.fhi = flo, fhi
+        self.lo, self.hi = scale.inverse(flo), scale.inverse(fhi)
+        self._auto = (lo_auto, hi_auto)
+        self._zero_pad = zero_pad
+        self._base = (self.lo, self.hi, self.flo, self.fhi)
+        self._unpadded_px = self._base
+
+    def _check_segmented(self, on_axis: Sequence[Any]) -> None:
+        """An axis over several regions: only genome series, no limits or origin."""
+        role = self.axis.role
+        plain = [s for s in on_axis
+                 if getattr(s, "scale_of", lambda r: None)(role) != "genome"]
+        if plain:
+            what = getattr(getattr(plain[0], "series", plain[0]), "kind", "a series")
+            raise ValueError(f"{what} has plain {role} values, which an axis over several "
+                             f"regions cannot place: draw it over one region, or mark "
+                             f"regions with fig.vspan(region)")
+        for name in ("limits", "origin"):
+            if self.axis.resolve(name) not in (None, "auto"):
+                raise ValueError(f"{role} axis over several regions: {name} cannot be set "
+                                 f"(each region is drawn whole)")
+
+    def _named_limits(self, spec: Any) -> Any:
+        """``limits`` with its category names (``("b", "d")``) as positions that show those
+        categories whole."""
+        if spec == "auto" or not any(isinstance(s, tuple) and s[0] == "name" for s in spec):
+            return spec
+        if not self.is_category:
+            bad = next(s[1] for s in spec if isinstance(s, tuple) and s[0] == "name")
+            raise ValueError(f"limits: {bad!r} is not a value of the {self.axis.role} axis "
+                             f"(a number, a date or ISO 8601 text)")
+        at = [self.value(s[1]) if isinstance(s, tuple) and s[0] == "name" else s
+              for s in spec]
+        sign = -1.0 if all(isinstance(v, float) for v in at) and at[0] > at[1] else 1.0
+        return tuple(v - sign * 0.5 * (1 if i == 0 else -1)
+                     if isinstance(s, tuple) and s[0] == "name" else v
+                     for i, (s, v) in enumerate(zip(spec, at)))
+
+    def _padding(self, name: str | None) -> tuple[float, float]:
+        """Padding setting ``name`` as (fraction of the range, px): `%` is of the range,
+        lengths are px, added once the axis length is known."""
+        if name is None:
+            return 0.0, 0.0
+        a = self.axis
+        px = a.resolve(name, of=0.0)
+        return a.resolve(name, of=1.0) - px, px
+
+    def _apply_px_padding(self, length: float) -> None:
+        """Add the px part of the padding to the automatic limits of an axis ``length`` px
+        long."""
+        if not self._pad_px or self.scale is None:
+            return
+        lo_auto, hi_auto = self._auto
+        n = int(lo_auto) + int(hi_auto)
+        lo, hi, flo, fhi = self._unpadded_px
+        if not n or length <= n * self._pad_px or fhi == flo:
+            return
+        d = (fhi - flo) * self._pad_px / (length - n * self._pad_px)
+        if lo_auto:
+            flo -= d
+            if self.scale.name == "sqrt" and flo < 0:
+                flo = 0.0
+        if hi_auto:
+            fhi += d
+        if not (math.isfinite(self.scale.inverse(flo)) and math.isfinite(self.scale.inverse(fhi))):
+            return
+        self.flo, self.fhi = flo, fhi
+        self.lo, self.hi = self.scale.inverse(flo), self.scale.inverse(fhi)
+        self._base = (self.lo, self.hi, self.flo, self.fhi)
+
+    def _apply_label_room(self, fonts: Any, length: float) -> None:
+        """Widen automatic limits until the labels series draw past their values (outside
+        bar labels) fit within an axis ``length`` px long, with the axis padding past them."""
+        if not self._roomers or self.scale is None or length <= 0 or not any(self._auto):
+            return
+        scale = self.scale
+        needs = []
+        for s in self._roomers:
+            t = affine(s, self.axis.role)
+            for v, px, d in s.label_room(fonts, self.axis.role):
+                if t is not None:
+                    v, d = apply(t, v), (d if t[1] > 0 else -d)
+                f = scale.f(v)
+                k = (px + self._pad_px) / length + self._pad_frac
+                if math.isfinite(f) and px > 0 and k < 0.5:
+                    needs.append((f, k, d))
+        if not needs:
+            return
+        lo_auto, hi_auto = self._auto
+        flo, fhi = self.flo, self.fhi
+        for _ in range(8):            # each side's need depends on the other limit
+            nlo, nhi = flo, fhi
+            for f, k, d in needs:
+                if d > 0 and hi_auto:
+                    nhi = max(nhi, (f - k * flo) / (1 - k))
+                elif d < 0 and lo_auto:
+                    nlo = min(nlo, (f - k * fhi) / (1 - k))
+            if (nlo, nhi) == (flo, fhi):
+                break
+            flo, fhi = nlo, nhi
+        if (flo, fhi) == (self.flo, self.fhi) or not (
+                math.isfinite(scale.inverse(flo)) and math.isfinite(scale.inverse(fhi))):
+            return
+        in_lo, in_hi = self._inner          # snapping keeps the labels' room
+        self._inner = (flo if flo < self.flo else in_lo, fhi if fhi > self.fhi else in_hi)
+        self.flo, self.fhi = flo, fhi
+        self.lo, self.hi = scale.inverse(flo), scale.inverse(fhi)
+        self._base = (self.lo, self.hi, self.flo, self.fhi)
+
+    def copy_limits(self, other: "AxisState") -> None:
+        """Take the scale, categories and limits of ``other`` (a shared group's leader)."""
+        for k in ("scale", "categories", "lo", "hi", "flo", "fhi", "data_lo", "data_hi",
+                  "segments",
+                  "auto_invert", "reversed", "_auto", "_zero_pad", "_base", "_inner",
+                  "_pad_px", "_pad_frac", "_unpadded_px"):
+            setattr(self, k, getattr(other, k))
+        self.categories = list(other.categories)
+
+    # -- ticks -------------------------------------------------------------------
+
+    def tick_font(self) -> Font:
+        a = self.axis
+        size = self.leaf_size or a.resolve("tick_label_font_size")
+        return font_of(a, size, a.resolve("tick_label_weight"),
+                       color=a.resolve("tick_label_color"), markup=False)
+
+    def label_font(self) -> Font:
+        a = self.axis
+        return font_of(a, a.resolve("label_font_size"), a.resolve("label_weight"),
+                       a.resolve("label_style"), a.resolve("label_color"))
+
+    def compute_ticks(self, fonts: Any, length: float, horizontal: bool) -> None:
+        """Ticks for an axis ``length`` px long (``horizontal``: labels side by side);
+        with ``snap``, automatic limits are then moved onto major ticks."""
+        lead = self.shared
+        if lead is not None:
+            self.copy_limits(lead)
+            if lead.length and abs(lead.length - length) <= 0.5:
+                self.lo, self.hi, self.flo, self.fhi = lead.lo, lead.hi, lead.flo, lead.fhi
+                self.ticks, self.offset_label = list(lead.ticks), lead.offset_label
+                self.rotation, self.length = lead.rotation, length
+                self.leaf_size = lead.leaf_size
+                self.crowded = lead.crowded
+                return
+        mode = self.axis.get("snap") if self.scale is not None else False
+        on = (self.scale is not None and mode is not False and any(self._auto)
+              and not self._zero_pad
+              and (self.scale.name in ("linear", "logit") or self.scale.base is not None))
+        self._apply_px_padding(length)
+        self._apply_label_room(fonts, length)
+        if on:
+            self.lo, self.hi, self.flo, self.fhi = self._base
+        self._compute_ticks(fonts, length, horizontal)
+        if not on:
+            return
+        assert self.scale is not None
+        base_flo, base_fhi = self._base[2], self._base[3]
+        if mode is True:
+            back = out = math.inf
+        else:                  # `%` of the axis, px: as position-space distances
+            px, frac = self.axis.resolve("snap", of=0.0), self.axis.resolve("snap", of=1.0)
+            span = base_fhi - base_flo
+            back, out = (((p / length if length > 0 else 0.0) + f - p) * span
+                         for p, f in zip(px, frac))
+        in_lo, in_hi = self._inner
+        # The wider range can need a larger step (labels must fit): repeat until stable.
+        for _ in range(8):
+            majors = sorted(self.major_positions())
+            if self.scale.name == "linear":
+                if len(majors) < 2:
+                    return
+                step = majors[1] - majors[0]
+            else:
+                step = 1.0
+            flo, fhi = self.flo, self.fhi
+            eps = step * 1e-9
+            if self._auto[0]:
+                outer = math.floor((base_flo + eps) / step) * step
+                tick = math.ceil((base_flo - eps) / step) * step
+                if base_flo - outer <= out:
+                    flo = outer
+                elif tick - base_flo <= back and tick < in_lo - eps:
+                    flo = tick
+                else:
+                    flo = base_flo
+            if self._auto[1]:
+                outer = math.ceil((base_fhi - eps) / step) * step
+                tick = math.floor((base_fhi + eps) / step) * step
+                if outer - base_fhi <= out:
+                    fhi = outer
+                elif base_fhi - tick <= back and tick > in_hi + eps:
+                    fhi = tick
+                else:
+                    fhi = base_fhi
+            if (flo, fhi) == (self.flo, self.fhi) or not math.isfinite(self.scale.inverse(flo)) \
+                    or not math.isfinite(self.scale.inverse(fhi)) or not flo < fhi:
+                return
+            self.flo, self.fhi = flo, fhi
+            self.lo, self.hi = self.scale.inverse(flo), self.scale.inverse(fhi)
+            self._compute_ticks(fonts, length, horizontal)
+
+    def minor_grid_positions(self) -> list[float]:
+        """Values of the minor grid lines: the minor ticks, else (linear axes) halfway
+        between major ticks."""
+        minors = [t.value for t in self.ticks if not t.major]
+        if minors or self.scale is None or self.scale.name != "linear":
+            return minors
+        majors = sorted(t.value for t in self.ticks if t.major)
+        if len(majors) < 2:
+            return []
+        step = majors[1] - majors[0]
+        lo, hi = min(self.lo, self.hi), max(self.lo, self.hi)
+        out = [m + step / 2 for m in [majors[0] - step] + majors]
+        return [v for v in out if lo <= v <= hi]
+
+
+    def _max_ticks(self, length: float, horizontal: bool, time: bool = False) -> int:
+        """``max_ticks``, or the automatic count for an axis of ``length`` px."""
+        a = self.axis
+        most = a.resolve("max_ticks")
+        if most != "auto":
+            return int(most)
+        spacing = a.resolve("time_tick_spacing" if time else "tick_spacing")[0 if horizontal else 1]
+        cap = a.resolve("auto_max_ticks")[1 if time else 0]
+        return min(cap, max(2, int(length / spacing) + 1))
+
+    def value(self, v: Any) -> float:
+        """``v`` in the axis' units: a number (numpy's too), a date or time (``datetime``,
+        ``date``, ``datetime64`` or ISO 8601 text: seconds since the epoch) or, on a
+        category axis, a category by name (its index; numbers are positions)."""
+        if self.is_category and not isinstance(v, (int, float)):
+            try:
+                if v in self.categories:
+                    return float(self.categories.index(v))
+            except (TypeError, ValueError):     # values that do not compare to names
+                pass
+        try:
+            return axis_value(v)
+        except ValueError:
+            what = "a category, a number" if self.is_category else "a number, a date"
+            raise ValueError(f"{v!r} is not a value of the {self.axis.role} axis ({what} "
+                             f"or ISO 8601 text)") from None
+
+    def formatter(self) -> Any:
+        """The axis' tick label formatter: of categories, times or numbers (``tick_format``;
+        a genome axis' unit)."""
+        a = self.axis
+        fmt = a.resolve("tick_format")
+        style = NumberStyle.of(a)
+        if self.is_category:
+            return CategoryFormatter(self.categories, fmt, style)
+        assert self.scale is not None
+        if self.scale.name == "time":
+            return TimeFormatter(fmt, self.tz)
+        if self.genome:
+            from .genome.scale import tick_format
+            fmt = tick_format(self) or fmt
+        elif fmt == "chr:pos":
+            raise ValueError("tick_format=\"chr:pos\" needs a genome axis (scale=\"genome\")")
+        return NumberFormatter(fmt, style, a.resolve("sci_limits"))
+
+    def _limits_of(self, f: Any) -> tuple[Any, Any]:
+        """The arguments of a ticks function ``f(lo, hi)``: the limits low to high, as
+        datetimes on a time axis."""
+        lo, hi = min(self.lo, self.hi), max(self.lo, self.hi)
+        if self.scale is not None and self.scale.name == "time":
+            return from_seconds(lo, self.tz), from_seconds(hi, self.tz)
+        return lo, hi
+
+    def _every(self, e: Every) -> tuple[list[float], list[Any] | None]:
+        """The values of ``plt.every(step)`` within the limits, and their labels when the
+        step makes them (powers on a log axis)."""
+        lo, hi = min(self.lo, self.hi), max(self.lo, self.hi)
+        role = self.axis.role
+        name = "category" if self.scale is None else self.scale.name
+        if e.unit is not None:
+            if name != "time":
+                raise ValueError(f"{role} axis: {e!r} needs a time axis")
+            unit, size = {"millisecond": ("microsecond", 1000), "week": ("day", 7)}.get(
+                e.unit, (e.unit, 1))
+            return calendar_ticks(lo, hi, unit, int(e.step) * size, self.tz), None
+        base = self.scale.base if self.scale is not None else None
+        if name == "category" or base is not None:
+            if not float(e.step).is_integer():
+                what = "categories" if name == "category" else "powers of the base"
+                raise ValueError(f"{role} axis: {e!r} needs a whole number of {what}")
+            n = int(e.step)
+            if name == "category":
+                return [float(i) for i in range(0, len(self.categories), n)
+                        if lo - 1e-9 <= i <= hi + 1e-9], None
+            assert base is not None
+            flo, fhi = min(self.flo, self.fhi), max(self.flo, self.fhi)
+            ks = [k for k in range(math.ceil(flo - 1e-9), math.floor(fhi + 1e-9) + 1)
+                  if k % n == 0]
+            return [base ** k for k in ks], power_labels(
+                base, ks, self.axis.resolve("tick_format"), NumberStyle.of(self.axis))
+        return step_values(lo, hi, e.step), None
+
+    def _spec_values(self, spec: Any) -> tuple[list[float], list[Any] | None]:
+        """The values of ``ticks`` or ``minor_ticks`` given as values, ``plt.every`` or a
+        function ``f(lo, hi)``, in axis units, and labels the step makes."""
+        if isinstance(spec, Every):
+            return self._every(spec)
+        if callable(spec):
+            limits = self._limits_of(spec)
+            try:
+                inspect.signature(spec).bind(*limits)
+            except TypeError as e:
+                raise ValueError(f"{self.axis.role} axis: the function of the ticks or "
+                                 f"minor_ticks setting takes (lo, hi): {e}") from None
+            except ValueError:                  # no signature (a builtin): called as is
+                pass
+            got = spec(*limits)
+            if isinstance(got, (str, bytes)) or not hasattr(got, "__iter__"):
+                raise ValueError(f"{self.axis.role} axis: the ticks function returned "
+                                 f"{got!r}, not a list of values")
+            spec = list(got)
+        return [self.value(v) for v in spec], None
+
+    def _compute_ticks(self, fonts: Any, length: float, horizontal: bool) -> None:
+        if self.segments is not None:
+            from .genome.scale import segment_ticks
+            segment_ticks(self, fonts, length, horizontal)
+            return
+        self.crowded = None
+        self._choose_ticks(fonts, length, horizontal)
+        if not self.call_leaves:               # leaves: :meth:`_fit_leaves`
+            self._fit_labels(fonts, length, horizontal)
+
+    def _overlaps(self, fonts: Any, length: float, horizontal: bool) -> bool:
+        """Whether two neighbouring tick labels, placed as drawn, are closer than
+        ``tick_label_gap``."""
+        from .boxes import tick_label_runs
+        from .labels import _overlap, run_quad
+        mapper = self.mapper(0.0, length) if horizontal else self.mapper(length, 0.0)
+        quads = [q for q in (run_quad(fonts, r) for r in
+                             tick_label_runs(self, fonts, mapper, 0.0, horizontal, False,
+                                             True))
+                 if q is not None]
+        quads.sort(key=lambda q: sum(p[0 if horizontal else 1] for p in q))
+        half = -float(self.axis.resolve("tick_label_gap")) / 2
+        inner = [_shrunk(q, half) for q in quads]
+        return any(_overlap(p, q) for p, q in zip(inner, inner[1:]))
+
+    def _fit_labels(self, fonts: Any, length: float, horizontal: bool) -> None:
+        """Tick labels closer than ``tick_label_gap``, chosen or given: every k-th
+        labelled (the others' ticks kept), then turned 45° (``tick_rotation="auto"``, x),
+        then wrapped at spaces (unrotated x labels), then smaller down to
+        ``label_min_size``, each with as few labels left out as fit; else one label
+        (``crowded``: the axis warns when drawn)."""
+        if length <= 0:
+            return
+        labelled = [i for i, t in enumerate(self.ticks)
+                    if t.major and t.label is not None and t.label != ""]
+        if len(labelled) < 2 or not self._overlaps(fonts, length, horizontal):
+            return
+        a = self.axis
+        full = list(self.ticks)
+        order = sorted(labelled, key=lambda i: self.f(full[i].value))
+        n = len(order)
+
+        def thinned() -> bool:
+            for k in range(1, max(n - 1, 1) + 1):
+                drop = {i for j, i in enumerate(order) if j % k}
+                self.ticks = [Tick(t.value, None, t.major) if i in drop else t
+                              for i, t in enumerate(full)]
+                if not self._overlaps(fonts, length, horizontal):
+                    return True
+            return False
+
+        if thinned():
+            return
+        if horizontal and not self.rotation and a.resolve("tick_rotation") == "auto":
+            self.rotation = 45.0
+            if thinned():
+                return
+        if horizontal and not self.rotation:
+            room = max(length / max(n, 1), 1.0)
+            font = self.tick_font()
+            wrapped = [Tick(t.value, wrap(fonts, t.label, font, room), t.major)
+                       if i in labelled else t for i, t in enumerate(full)]
+            if wrapped != full:
+                full = wrapped
+                if thinned():
+                    return
+        base = self.tick_font().size
+        least = min(base, float(a.resolve("label_min_size")))
+        size = base
+        while size > least:
+            size = max(least, size * 0.9)
+            self.leaf_size = size
+            if thinned():
+                return
+        self.ticks = [Tick(t.value, None, t.major) if i in order[1:] else t
+                      for i, t in enumerate(full)]
+        self.crowded = size
+
+    def _choose_ticks(self, fonts: Any, length: float, horizontal: bool) -> None:
+        a = self.axis
+        self.length = length
+        self.offset_label = None
+        self.rotation = 0.0
+        self.leaf_size = None
+        given = a.resolve("ticks")
+        font = self.tick_font()
+        if given is False:
+            self.ticks = []
+            return
+        if self.is_category:
+            self._category_ticks(fonts, length, horizontal, font)
+            return
+        assert self.scale is not None
+        if not (math.isfinite(self.fhi - self.flo) and math.isfinite(self.lo)
+                and math.isfinite(self.hi)):
+            origin = a.resolve("origin")
+            raise ValueError(f"{self.axis.role} axis limits {self.lo!r}/{self.hi!r}: the range is "
+                             f"not finite on the {self.scale.name} scale"
+                             + (f" (origin {origin!r})" if origin is not None else "")
+                             + (f"; check the series' {self.axis.role}_origin, "
+                                f"{self.axis.role}_scale and {self.axis.role}_extent"
+                                if self.moved else ""))
+        form = self.formatter()
+        if isinstance(form, TimeFormatter) and given is None:
+            most = self._max_ticks(length, horizontal, time=True)
+            pairs, self.offset_label = form.ticks(self.lo, self.hi, most)
+            self.ticks = [Tick(v, lab) for v, lab in pairs]
+            rot = a.resolve("tick_rotation")
+            self.rotation = 0.0 if rot == "auto" else float(rot)
+            return
+        if given is None and self.call_ticks is not None and a.resolve("tick_labels") is None:
+            self.ticks = [Tick(float(v), lab) for v, lab in self.call_ticks]
+            if self.call_leaves and len(self.ticks) > 1:
+                span = abs(self.fhi - self.flo) or 1.0
+                self.ticks = self._fit_leaves(fonts, self.ticks, length / span, horizontal,
+                                              font)
+                return
+            if self.call_thin:
+                self._thin_labels(fonts, font, length, horizontal)
+        elif given is not None:
+            labels = self._given_labels()
+            values, made = self._spec_values(given)
+            if labels is not None:
+                _check_count(labels, values, "ticks")
+            elif made is not None:
+                labels = made
+            else:
+                labels, self.offset_label = form(values)
+            self.ticks = [Tick(v, s) for v, s in zip(values, labels)]
+        else:
+            label_gap = a.resolve("tick_label_gap")
+            max_ticks = self._max_ticks(length, horizontal)
+
+            def fits(values: list[float], step: float) -> bool:
+                if len(values) < 2:
+                    return True
+                labels = form(values).labels
+                span = self.fhi - self.flo
+                if not span:
+                    return True
+                gap = length * abs(self.f(values[1]) - self.f(values[0])) / span
+                if not horizontal:                 # stacked labels must not overlap
+                    return max(lines_box(fonts, s, font)[1] for s in labels) <= gap
+                widest = max(lines_box(fonts, s, font)[0] for s in labels)
+                return widest + label_gap <= gap
+
+            minor = a.resolve("minor_ticks")
+            linear = self.scale.name == "linear"
+            self.ticks, factor = numeric_ticks(
+                self.scale, self.lo, self.hi, max_ticks, form.fmt, form.style,
+                form.sci_limits, minor=minor is not False, length=length,
+                fits=fits if linear else None,
+                min_step=1.0 if self.whole or self.genome else 0.0)
+            if linear:                 # labelled together: the additive offset
+                values = [t.value for t in self.ticks if t.major]
+                labels, self.offset_label = form(values)
+                self.ticks = [Tick(v, s) for v, s in zip(values, labels)] + [
+                    t for t in self.ticks if not t.major]
+            else:
+                self.offset_label = form.offset(factor)
+            if minor is True and linear:
+                majors = [t.value for t in self.ticks if t.major]
+                if len(majors) >= 2:
+                    step = majors[1] - majors[0]
+                    have = set(majors)
+                    self.ticks += [Tick(v, None, False) for v in minor_linear(self.lo, self.hi, step)
+                                   if not any(abs(v - m) < step * 1e-6 for m in have)]
+        minors = a.resolve("minor_ticks")
+        if not isinstance(minors, bool) and minors is not None:
+            self.ticks += [Tick(v, None, False) for v in self._spec_values(minors)[0]]
+        lo, hi = min(self.flo, self.fhi), max(self.flo, self.fhi)
+        eps = (hi - lo) * 1e-9
+        self.ticks = [t for t in self.ticks
+                      if lo - eps <= self.f(t.value) <= hi + eps]
+        rot = a.resolve("tick_rotation")
+        self.rotation = 0.0 if rot == "auto" else float(rot)
+
+    def _thin_labels(self, fonts: Any, font: Font, length: float, horizontal: bool) -> None:
+        """Drop the labels that collide: from the low end, a label is kept when it clears
+        the last kept one by ``tick_label_gap``; the others' ticks stay, unlabelled."""
+        span = self.fhi - self.flo
+        if len(self.ticks) < 2 or not span or length <= 0:
+            return
+        gap = self.axis.resolve("tick_label_gap")
+        out, last = [], None
+        for t in sorted(self.ticks, key=lambda t: self.f(t.value)):
+            if t.label in (None, ""):
+                out.append(t)
+                continue
+            at = length * (self.f(t.value) - self.flo) / span
+            half = lines_box(fonts, t.label, font)[0 if horizontal else 1] / 2
+            if last is not None and at - half < last + gap:
+                out.append(Tick(t.value, None, t.major))
+                continue
+            out.append(t)
+            last = at + half
+        self.ticks = out
+
+    def _category_index(self, v: Any) -> int:
+        """The index of a category given in ``ticks``: by name, else by index."""
+        x = self.value(v)
+        if x.is_integer() and 0 <= x < len(self.categories):
+            return int(x)
+        raise ValueError(f"ticks: {v!r} is neither a category of the {self.axis.role} axis "
+                         f"nor the index of one")
+
+    def _given_labels(self) -> list[Any] | None:
+        """``tick_labels``, their markup read (unless ``markup`` is off)."""
+        labels = self.axis.resolve("tick_labels")
+        if labels is None or not self.axis.resolve("markup"):
+            return labels
+        from .markup import parse
+        return [parse(x) for x in labels]
+
+    def _category_ticks(self, fonts: Any, length: float, horizontal: bool, font: Font) -> None:
+        a = self.axis
+        given = a.resolve("ticks")
+        index = list(range(len(self.categories))) if given is None else [
+            self._category_index(v) for v in self._spec_values(given)[0]]
+        labels = self._given_labels()
+        if labels is not None:
+            _check_count(labels, index, "categories" if given is None else "ticks")
+        else:
+            labels = self.formatter()(index).labels
+        lo, hi = min(self.lo, self.hi), max(self.lo, self.hi)
+        ticks = sorted((Tick(float(i), lab) for i, lab in zip(index, labels)
+                        if lo - 1e-9 <= i <= hi + 1e-9), key=lambda t: t.value)
+        labels = [t.label for t in ticks]
+        span = abs(self.fhi - self.flo) or 1.0
+        step = length / span            # px per category
+        rot = a.resolve("tick_rotation")
+        gap = a.resolve("tick_label_gap")
+        rotated, stacked = a.resolve("category_label_spacing")
+        if not ticks:
+            self.ticks = []
+            return
+        if self.call_leaves:
+            self.ticks = self._fit_leaves(fonts, ticks, step, horizontal, font)
+            return
+        if horizontal:
+            widest = max(lines_box(fonts, lab, font)[0] for lab in labels)
+            if rot == "auto":
+                rot = 45.0 if widest + gap > step else 0.0
+            need = (widest + gap) if rot == 0 else rotated
+        else:
+            rot = 0.0 if rot == "auto" else rot
+            need = stacked
+        self.rotation = float(rot)
+        every = max(1, math.ceil(need / step)) if step > 0 else 1
+        if every > 1:
+            ticks = [t for i, t in enumerate(ticks) if i % every == 0]
+        self.ticks = ticks
+
+    def _fit_leaves(self, fonts: Any, ticks: list[Tick], step: float, horizontal: bool,
+                    font: Font) -> list[Tick]:
+        """A dendrogram's leaf labels, ``step`` px apart: flat when they fit, else rotated
+        90° (x; ``tick_rotation="auto"``), then at a smaller font size (down to
+        ``label_min_size``), and only then every k-th."""
+        a = self.axis
+        rot = a.resolve("tick_rotation")
+        gap = a.resolve("tick_label_gap")
+        rotated, stacked = a.resolve("category_label_spacing")
+        if horizontal:
+            widest = max(lines_box(fonts, t.label, font)[0] for t in ticks)
+            if rot == "auto":
+                rot = 0.0 if widest + gap <= step else 90.0
+            # at 90° the labels lie side by side as stacked lines do
+            need = (widest + gap) if rot == 0 else stacked if abs(rot) == 90 else rotated
+        else:
+            rot = 0.0 if rot == "auto" else rot
+            need = stacked
+        self.rotation = float(rot)
+        if step <= 0:
+            return ticks
+        base = font.size
+        if need > step:
+            size = min(base, max(a.resolve("label_min_size"), base * step / need))
+            if size < base:
+                self.leaf_size = size
+                need *= size / base
+        every = max(1, math.ceil(need / step - 1e-9))
+        return ticks if every == 1 else [t for i, t in enumerate(ticks) if i % every == 0]
+
+    def major_positions(self) -> list[float]:
+        return [self.f(t.value) for t in self.ticks if t.major]