plot3 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

plot3/__version__.py

@@ -1 +1 @@
-__version__ = "0.4.2"
+__version__ = "0.5.0"

plot3/build.py

@@ -976,8 +976,8 @@ def expand_stat_geom(
             indices = np.zeros((0, 3), dtype=np.int32)
         colour_by = getattr(geom, "colour_by", "level")
         map_kwargs: dict = {"x": "x", "y": "y", "z": "z"}
-        if colour_by == "level" and "colour" in vertices.columns:
-            map_kwargs["colour"] = "colour"
+        if colour_by == "level" and "level" in vertices.columns:
+            map_kwargs["colour"] = "level"
         out = _Geom(
             aes(**map_kwargs),
             color=geom.const_color,
@@ -990,6 +990,7 @@ def expand_stat_geom(
         out.wireframe = bool(getattr(geom, "wireframe", False))
         out._indices = indices
         out._iso_levels = used
+        out._colour_title = "level"
         return out
     return geom
 

plot3/calculus.py

@@ -884,37 +884,115 @@ def _arrow(x, y, dx, dy, length: float):
 
 
 def _streamlines(formula, xs, ys, cell, xlim, ylim):
-    stride = max(1, int(len(xs) / 6))
-    seeds = [
-        (float(xs[i]), float(ys[j]))
-        for j in range(0, len(ys), stride)
-        for i in range(0, len(xs), stride)
-    ]
-    step = 0.45 * cell
+    """Evenly spaced streamlines (Jobard and Lefer), one arrowhead each.
+
+    Seeds sit on the grid, centre first. Each line is traced both ways with
+    RK4 at unit speed and stops at the edge, at a zero of the field, within
+    ``0.5 * cell`` of another line, or where it meets itself (a closed
+    orbit), so lines never pile up on one another.
+    """
+    sep = cell
+    near = 0.5 * sep
+    step = 0.1 * sep
+    lag = 3.0 * sep  # arc length before a line may end on itself
+    max_steps = int(4 * ((xlim[1] - xlim[0]) + (ylim[1] - ylim[0])) / step)
+    taken: dict[tuple[int, int], list[tuple[float, float]]] = {}
+
+    def key(x, y):
+        return int(np.floor(x / near)), int(np.floor(y / near))
+
+    def crowded(grid, x, y, radius, s=None):
+        kx, ky = key(x, y)
+        for ix in (kx - 1, kx, kx + 1):
+            for iy in (ky - 1, ky, ky + 1):
+                for item in grid.get((ix, iy), ()):
+                    if (item[0] - x) ** 2 + (item[1] - y) ** 2 >= radius * radius:
+                        continue
+                    if s is None or abs(item[2] - s) > lag:
+                        return True
+        return False
+
+    def unit(x, y):
+        vx, vy = _field_at(formula, x, y)
+        mag = float(np.hypot(vx, vy))
+        if not np.isfinite(mag) or mag < 1e-12:
+            return None
+        return vx / mag, vy / mag
+
+    def trace(sx, sy, direction, own):
+        points = []
+        x, y, s = sx, sy, 0.0
+        for _ in range(max_steps):
+            k1 = unit(x, y)
+            if k1 is None:
+                break
+            k2 = unit(x + 0.5 * step * direction * k1[0], y + 0.5 * step * direction * k1[1])
+            k3 = None if k2 is None else unit(
+                x + 0.5 * step * direction * k2[0], y + 0.5 * step * direction * k2[1]
+            )
+            k4 = None if k3 is None else unit(
+                x + step * direction * k3[0], y + step * direction * k3[1]
+            )
+            if k4 is None:
+                break
+            x += step * direction * (k1[0] + 2 * k2[0] + 2 * k3[0] + k4[0]) / 6
+            y += step * direction * (k1[1] + 2 * k2[1] + 2 * k3[1] + k4[1]) / 6
+            s += direction * step
+            if not (xlim[0] <= x <= xlim[1] and ylim[0] <= y <= ylim[1]):
+                break
+            if crowded(taken, x, y, near):
+                break
+            closed = crowded(own, x, y, 0.5 * step + 1e-12, s)
+            points.append((x, y, s))
+            own.setdefault(key(x, y), []).append((x, y, s))
+            if closed:
+                break
+        return points
+
+    cx, cy = 0.5 * (xlim[0] + xlim[1]), 0.5 * (ylim[0] + ylim[1])
+    seeds = sorted(
+        ((float(x), float(y)) for y in ys for x in xs),
+        key=lambda p: (p[0] - cx) ** 2 + (p[1] - cy) ** 2,
+    )
     rows: list[tuple[float, float]] = []
     groups: list[list[int]] = []
     for sx, sy in seeds:
-        for direction in (1.0, -1.0):
-            points = [(sx, sy)]
-            x, y = sx, sy
-            for _ in range(48):
-                vx, vy = _field_at(formula, x, y)
-                mag = float(np.hypot(vx, vy))
-                if not np.isfinite(mag) or mag < 1e-12:
-                    break
-                x += direction * step * vx / mag
-                y += direction * step * vy / mag
-                if x < xlim[0] or x > xlim[1] or y < ylim[0] or y > ylim[1]:
-                    break
-                points.append((x, y))
-            if len(points) < 2:
-                continue
+        if crowded(taken, sx, sy, sep) or unit(sx, sy) is None:
+            continue
+        own: dict = {key(sx, sy): [(sx, sy, 0.0)]}
+        forward = trace(sx, sy, 1.0, own)
+        backward = trace(sx, sy, -1.0, own)
+        line = [p for p in reversed(backward)] + [(sx, sy, 0.0)] + forward
+        if len(line) * step < sep:
+            continue
+        for p in line:
+            taken.setdefault(key(p[0], p[1]), []).append(p)
+        start = len(rows)
+        rows.extend((p[0], p[1]) for p in line)
+        groups.append([start, len(line)])
+        head = _line_arrowhead(line, 0.7 * sep)
+        if head is not None:
             start = len(rows)
-            rows.extend(points)
-            groups.append([start, len(points)])
+            rows.extend(head)
+            groups.append([start, len(head)])
     return rows, groups
 
 
+def _line_arrowhead(line, size: float):
+    """A barb pair at the middle of ``line``, pointing along it."""
+    mid = len(line) // 2
+    a, b = line[max(0, mid - 1)], line[min(len(line) - 1, mid + 1)]
+    dx, dy = b[0] - a[0], b[1] - a[1]
+    mag = float(np.hypot(dx, dy))
+    if not np.isfinite(mag) or mag == 0.0:
+        return None
+    ux, uy = dx / mag, dy / mag
+    hx, hy = line[mid][0], line[mid][1]
+    bx, by = hx - 0.4 * size * ux, hy - 0.4 * size * uy
+    wing = 0.25 * size
+    return [(bx - wing * uy, by + wing * ux), (hx, hy), (bx + wing * uy, by - wing * ux)]
+
+
 def _field_at(formula, x: float, y: float) -> tuple[float, float]:
     env = {"x": np.array([x]), "y": np.array([y])}
     dx = float(np.asarray(_component(formula, "dx", env)).reshape(-1)[0])

plot3/contour.py

@@ -42,6 +42,7 @@ _EDGE_LUT = np.array(
 # it cannot refine a small loop that shares the window with a long curve.
 _REFINE_SUB = 8
 _REFINE_NODE_BUDGET = 400_000
+_REFINE_GROW = 4  # rounds of refining around a curve's stray ends
 
 _contourpy_mod = None
 _contourpy_loaded = False
@@ -130,6 +131,51 @@ def _interp_t(a: np.ndarray, b: np.ndarray, level: float) -> np.ndarray:
         return np.clip(t, 0.0, 1.0)
 
 
+_ROOT_STEPS = 14  # bisection steps per crossing: 1/16384 of a fine cell
+
+
+def _edge_root(sample, fa, fb, xa, ya, xb, yb, level: float) -> np.ndarray:
+    """Where the curve crosses each edge, as a fraction from a to b.
+
+    Linear interpolation of the corner values is exact only where the
+    function crosses zero like a line. Near a double or triple root (the
+    heart ``(x^2 + y^2 - 1)^3 = x^2 y^3``) it can miss by half a cell, which
+    shows as kinks. With ``sample``, the crossing is bisected on the
+    function itself, then interpolated inside the final bracket.
+    """
+    t = _interp_t(fa, fb, level)
+    if sample is None:
+        return t
+    fa = np.asarray(fa, dtype=np.float64)
+    fb = np.asarray(fb, dtype=np.float64)
+    cross = np.isfinite(fa) & np.isfinite(fb) & ((fa >= level) != (fb >= level))
+    if not np.any(cross):
+        return t
+    xa, ya, xb, yb = (np.broadcast_to(v, fa.shape)[cross] for v in (xa, ya, xb, yb))
+    lo = np.zeros(xa.shape)
+    hi = np.ones(xa.shape)
+    flo = fa[cross] - level
+    fhi = fb[cross] - level
+    for _ in range(_ROOT_STEPS):
+        mid = 0.5 * (lo + hi)
+        fm = np.asarray(sample(xa + mid * (xb - xa), ya + mid * (yb - ya)), dtype=np.float64)
+        fm = np.broadcast_to(fm, mid.shape) - level
+        ok = np.isfinite(fm)
+        low_side = ok & ((fm >= 0) == (flo >= 0))
+        high_side = ok & ~low_side
+        lo = np.where(low_side, mid, lo)
+        flo = np.where(low_side, fm, flo)
+        hi = np.where(high_side, mid, hi)
+        fhi = np.where(high_side, fm, fhi)
+        if not ok.all():
+            break
+    with np.errstate(divide="ignore", invalid="ignore"):
+        inner = np.where(fhi != flo, -flo / (fhi - flo), 0.5)
+    out = np.array(t, dtype=np.float64, copy=True)
+    out[cross] = lo + np.clip(inner, 0.0, 1.0) * (hi - lo)
+    return out
+
+
 def _pair_segments(
     local_ids: np.ndarray,
     cases: np.ndarray,
@@ -367,6 +413,83 @@ def _refine_active_cells(
     _case, active, _center = _cell_cases(field, level)
     if not np.any(active):
         return []
+    lines = _refine_cells(xs, ys, active, level, sample, sub)
+    # A curve that stops inside the window left the refined cells through
+    # a cell whose corners all share a sign: a cusp, or a wedge thinner
+    # than one cell. Refine around each stray end until the curve goes on.
+    for _ in range(_REFINE_GROW):
+        if lines is None:
+            return None
+        ends = _stray_ends(lines, xs, ys)
+        if not ends:
+            break
+        grown = active.copy()
+        for x_val, y_val in ends:
+            i = int(np.clip(np.searchsorted(xs, x_val) - 1, 0, len(xs) - 2))
+            j = int(np.clip(np.searchsorted(ys, y_val) - 1, 0, len(ys) - 2))
+            grown[max(0, j - 1) : j + 2, max(0, i - 1) : i + 2] = True
+        if grown.sum() == active.sum():
+            break
+        active = grown
+        lines = _refine_cells(xs, ys, active, level, sample, sub)
+    if lines is None:
+        return None
+    gap = 2.0 * max(float(np.max(np.diff(xs))), float(np.max(np.diff(ys)))) / max(1, int(sub))
+    return _join_close_ends(lines, xs, ys, gap)
+
+
+def _stray_ends(lines, xs, ys) -> list[tuple[float, float]]:
+    """End points of open polylines that are not on the window's edge."""
+    tol_x = 1e-9 * max(1.0, abs(float(xs[-1] - xs[0])))
+    tol_y = 1e-9 * max(1.0, abs(float(ys[-1] - ys[0])))
+    out = []
+    for line in lines:
+        if len(line) < 2 or line[0] == line[-1]:
+            continue
+        for x_val, y_val in (line[0], line[-1]):
+            on_edge = (
+                abs(x_val - xs[0]) <= tol_x or abs(x_val - xs[-1]) <= tol_x
+                or abs(y_val - ys[0]) <= tol_y or abs(y_val - ys[-1]) <= tol_y
+            )
+            if not on_edge:
+                out.append((x_val, y_val))
+    return out
+
+
+def _join_close_ends(lines, xs, ys, gap: float):
+    """Join open polylines whose stray ends are within ``gap`` (a cusp tip)."""
+    lines = [list(line) for line in lines if len(line) >= 2]
+    while True:
+        stray = set(_stray_ends(lines, xs, ys))
+        ends = [
+            (a, at_end, line[-1] if at_end else line[0])
+            for a, line in enumerate(lines)
+            for at_end in (False, True)
+            if line[0] != line[-1] and (line[-1] if at_end else line[0]) in stray
+        ]
+        pair = next(
+            (
+                (p, q)
+                for k, p in enumerate(ends)
+                for q in ends[k + 1 :]
+                if (p[0], p[1]) != (q[0], q[1])
+                and np.hypot(p[2][0] - q[2][0], p[2][1] - q[2][1]) <= gap
+            ),
+            None,
+        )
+        if pair is None:
+            return lines
+        (a, a_end, _pa), (b, b_end, _pb) = pair
+        if a == b:
+            lines[a].append(lines[a][0])  # both ends of one line: close it
+            continue
+        first = lines[a] if a_end else lines[a][::-1]  # ends at the joint
+        second = lines[b] if not b_end else lines[b][::-1]  # starts at it
+        lines[a] = first + second
+        del lines[b]
+
+
+def _refine_cells(xs, ys, active, level, sample, sub):
     jj, ii = np.nonzero(active)
     sub = int(sub)
     nodes = sub + 1
@@ -389,7 +512,7 @@ def _refine_active_cells(
     fine = np.asarray(sample(xx, yy), dtype=np.float64)
     if fine.shape != xx.shape:
         fine = np.broadcast_to(fine, xx.shape).astype(np.float64, copy=False)
-    return _contour_refined(ii, jj, xs, ys, fine, xf, yf, level, sub)
+    return _contour_refined(ii, jj, xs, ys, fine, xf, yf, level, sub, sample)
 
 
 def _contour_refined(
@@ -402,6 +525,7 @@ def _contour_refined(
     yf: np.ndarray,
     level: float,
     sub: int,
+    sample=None,
 ) -> list[list[tuple[float, float]]]:
     """Marching squares on a batch of refined cells, chained by global edge id."""
     f00 = fine[:, :-1, :-1]
@@ -429,7 +553,7 @@ def _contour_refined(
     ny = int(ys.shape[0])
     h_stride = (nx - 1) * sub
     v_stride = (nx - 1) * sub + 1
-    n_horizontal = h_stride * ((ny - 1) * sub)
+    n_horizontal = h_stride * ((ny - 1) * sub + 1)  # rows of cells + 1 rows of edges
     bottom = gj * h_stride + gi
     top = (gj + 1) * h_stride + gi
     left = n_horizontal + gj * v_stride + gi
@@ -445,30 +569,18 @@ def _contour_refined(
         for edge, x_val, y_val in zip(edge_ids.tolist(), x_vals.tolist(), y_vals.tolist()):
             points[int(edge)] = (float(x_val), float(y_val))
 
-    t = _interp_t(fine[aj, lj, li], fine[aj, lj, li + 1], level)
-    put(
-        bottom,
-        xf[aj, li] + t * (xf[aj, li + 1] - xf[aj, li]),
-        yf[aj, lj],
-    )
-    t = _interp_t(fine[aj, lj, li + 1], fine[aj, lj + 1, li + 1], level)
-    put(
-        right,
-        xf[aj, li + 1],
-        yf[aj, lj] + t * (yf[aj, lj + 1] - yf[aj, lj]),
-    )
-    t = _interp_t(fine[aj, lj + 1, li], fine[aj, lj + 1, li + 1], level)
-    put(
-        top,
-        xf[aj, li] + t * (xf[aj, li + 1] - xf[aj, li]),
-        yf[aj, lj + 1],
-    )
-    t = _interp_t(fine[aj, lj, li], fine[aj, lj + 1, li], level)
-    put(
-        left,
-        xf[aj, li],
-        yf[aj, lj] + t * (yf[aj, lj + 1] - yf[aj, lj]),
-    )
+    x0, x1 = xf[aj, li], xf[aj, li + 1]
+    y0, y1 = yf[aj, lj], yf[aj, lj + 1]
+    f00, f10 = fine[aj, lj, li], fine[aj, lj, li + 1]
+    f01, f11 = fine[aj, lj + 1, li], fine[aj, lj + 1, li + 1]
+    t = _edge_root(sample, f00, f10, x0, y0, x1, y0, level)
+    put(bottom, x0 + t * (x1 - x0), y0)
+    t = _edge_root(sample, f10, f11, x1, y0, x1, y1, level)
+    put(right, x1, y0 + t * (y1 - y0))
+    t = _edge_root(sample, f01, f11, x0, y1, x1, y1, level)
+    put(top, x0 + t * (x1 - x0), y1)
+    t = _edge_root(sample, f00, f01, x0, y0, x0, y1, level)
+    put(left, x0, y0 + t * (y1 - y0))
 
     def point_of(edge: int) -> tuple[float, float]:
         return points[edge]

plot3/expr.py

@@ -434,6 +434,14 @@ def _parse_math(
         code_tree = ast.BinOp(left=lhs_tree, op=ast.Sub(), right=rhs_tree)
         # Names only on the left still count (already in ``free``).
 
+    if len(free) > 2 and defer_missing and "x" in free and "y" in free:
+        # ``z = sin(r - t)`` or ``x^2 + y^2 = r^2``: x and y are the axes, so
+        # any other letter is a coefficient a slider or transition will
+        # sweep. Unswept ones fail at build time like any missing coefficient.
+        pending.extend(name for name in free if name not in ("x", "y"))
+        free = [name for name in free if name in ("x", "y")]
+        if mode == "explicit" and lhs_tree is None:
+            dependent = "z"
     if len(free) > 2:
         listed = ", ".join(free)
         raise ExprError(

plot3/geoms.py

@@ -417,7 +417,8 @@ class geom_isosurface(_Geom):
         Density grid bins per axis (8–64). Overridden by a preceding
         :class:`stat_density_3d` if present on the figure.
     colour_by:
-        ``"level"`` colours mesh vertices by isolevel index (default).
+        ``"level"`` colours each surface by its level (default), on the
+        same 0–1 scale as ``levels``.
     wireframe, alpha:
         Same idea as :class:`geom_surface`.
     """
@@ -2066,12 +2067,17 @@ class scale_x_log10:
     Positions are encoded in log10 space, so a decade is a constant distance
     and a tween along the axis moves in log space. Non-positive values are
     omitted. Tick labels stay in the original units (1, 10, 100, …).
+    ``name``, ``limits``, ``breaks``, and ``labels`` work as in
+    ``scale_x_continuous``.
     """
 
     axis = "x"
 
+    def __init__(self, name=None, *, limits=None, breaks=None, labels=None):
+        self.name, self.limits, self.breaks, self.labels = name, limits, breaks, labels
 
-class scale_y_log10:
+
+class scale_y_log10(scale_x_log10):
     """Base-10 logarithmic scale for y. See :class:`scale_x_log10`."""
 
     axis = "y"

plot3/ggplot.py

@@ -355,22 +355,23 @@ class ggplot:
             g.coord = other
         elif isinstance(other, stat_density_3d):
             g.stat_density_3d = other
-        elif isinstance(other, scale_x_log10):
-            g.scale_x = other
-        elif isinstance(other, scale_y_log10):
-            g.scale_y = other
+        elif isinstance(other, scale_x_log10):  # also scale_y_log10
+            g = g + _scaling.PositionScale(
+                other.axis, "continuous", name=other.name, limits=other.limits,
+                breaks=other.breaks, labels=other.labels, trans="log10",
+            )
         elif isinstance(other, _scaling._Lims):
             for part in other:
                 g = g + part
         elif isinstance(other, _scaling.PositionScale):
             if other.axis == "x":
                 g.xscale = other
-                g.scale_x = scale_x_log10() if other.trans == "log10" else (
+                g.scale_x = scale_x_log10(other.name) if other.trans == "log10" else (
                     None if other.kind == "continuous" else g.scale_x
                 )
             else:
                 g.yscale = other
-                g.scale_y = scale_y_log10() if other.trans == "log10" else (
+                g.scale_y = scale_y_log10(other.name) if other.trans == "log10" else (
                     None if other.kind == "continuous" else g.scale_y
                 )
         elif isinstance(other, _scaling.ColourScale):

plot3/static.py

@@ -1065,6 +1065,10 @@ def _draw_2d(
     box = _box_2d(spec, x, y, w, h, labs, fonts, extra_right, extra_bottom)
     scales = spec.get("scales") or {}
     window = _view_window(spec, box[2], box[3])
+    scales = dict(scales)
+    for axis, u_lo, u_hi in (("x", window[0], window[1]), ("y", window[2], window[3])):
+        if axis in scales:
+            scales[axis] = _window_ticks(scales[axis], u_lo, u_hi)
     surface = theme.get("surface") or "#0b1020"
     grid = theme.get("grid") or "#1c2742"
     axis = theme.get("axis") or "#2e3a5c"
@@ -1429,6 +1433,15 @@ def _draw_3d(
         # labels the same room as the others.
         inner = _inset_box(box, layout["pad"])
         project, centre = _fit_projector(base, ext, inner, zoom)
+    if not void and centre is not None:
+        # A long axis title ("elevation") beside a short edge can reach past
+        # the canvas: narrow the cube on that side to make room for it.
+        spots = _axis_title_spots(ext, project, centre, labs, fonts, layout)
+        left, right = _title_overflow(spots, fonts, (x, y, w, h))
+        if left > 0.5 or right > 0.5:
+            ix, iy, iw, ih = inner
+            inner = (ix + left, iy, max(4.0, iw - left - right), ih)
+            project, centre = _fit_projector(base, ext, inner, zoom)
     ink = theme.get("ink") or "#ffffff"
     gz = bool(spec.get("gz"))
     min_dim = min(box[2], box[3])
@@ -2449,6 +2462,16 @@ def _clamp_point(px: float, py: float, bounds) -> tuple[float, float]:
     )
 
 
+def _clamp_label(px, py, text, size, anchor, baseline, bounds) -> tuple[float, float]:
+    """``(px, py)`` moved so the whole label, not only its anchor, stays in ``bounds``."""
+    px, py = _clamp_point(px, py, bounds)
+    left, top, width, height = _label_box(px, py, text, size, anchor, baseline)
+    x, y, w, h = bounds
+    dx = max(0.0, x + 3.0 - left) - max(0.0, left + width - (x + w - 3.0))
+    dy = max(0.0, y + 3.0 - top) - max(0.0, top + height - (y + h - 3.0))
+    return px + dx, py + dy
+
+
 def _thin_marks(marks, air: float) -> list:
     """Every k-th tick, the smallest k whose labels do not touch, keeping
     round values (0, 5, 10 rather than 1, 4, 7) when the ticks allow."""
@@ -2472,6 +2495,41 @@ def _thin_marks(marks, air: float) -> list:
     return marks[:1]
 
 
+def _axis_title_spots(ext, project, centre, labs, fonts, layout) -> list:
+    """``(text, x, y, anchor, baseline)`` for each 3D axis title, unclamped."""
+    if centre is None:
+        return []
+    corners = _cube_corners(project, ext)
+    hull = _hull_edge_set(corners)
+    spots = []
+    for axis in ("x", "y", "z"):
+        text = labs.get(axis) or ""
+        if not text:
+            continue
+        pair = _visible_axis_edge(axis, hull, corners, centre)
+        if corners[pair[0]] is None or corners[pair[1]] is None:
+            continue
+        nx, ny = _outward_normal(corners[pair[0]], corners[pair[1]], centre)
+        anchor, baseline = _outside_anchor(nx, ny)
+        mid = project(_corner_xyz(pair[0], ext) * 0.5 + _corner_xyz(pair[1], ext) * 0.5)
+        if mid is None:
+            continue
+        gap = layout["title_gap"]
+        spots.append((text, mid[0] + nx * gap, mid[1] + ny * gap, anchor, baseline))
+    return spots
+
+
+def _title_overflow(spots, fonts, bounds) -> tuple[float, float]:
+    """How far the axis titles reach past the left and right of ``bounds``."""
+    x, _y, w, _h = bounds
+    left = right = 0.0
+    for text, lx, ly, anchor, baseline in spots:
+        bx, _by, bw, _bh = _label_box(lx, ly, text, fonts[0], anchor, baseline)
+        left = max(left, x + 3.0 - bx)
+        right = max(right, bx + bw - (x + w - 3.0))
+    return left, right
+
+
 def _draw_3d_axes(spec, ext, project, centre, commands, theme, fonts, labs, bounds, layout) -> None:
     """Tick numbers and axis names just outside the three visible edges."""
     if centre is None:
@@ -2482,7 +2540,6 @@ def _draw_3d_axes(spec, ext, project, centre, commands, theme, fonts, labs, boun
     hull = _hull_edge_set(corners)
     scales = spec.get("scales") or {}
     tick_gap = layout["tick_gap"]
-    title_gap = layout["title_gap"]
     placed: list[tuple[float, float, float, float]] = []  # label boxes, all axes
     for axis in ("x", "y", "z"):
         pair = _visible_axis_edge(axis, hull, corners, centre)
@@ -2504,7 +2561,10 @@ def _draw_3d_axes(spec, ext, project, centre, commands, theme, fonts, labs, boun
             hit = project(_corner_xyz(pair[0], ext) * (1.0 - u) + _corner_xyz(pair[1], ext) * u)
             if hit is None:
                 continue
-            tx, ty = _clamp_point(hit[0] + nx * tick_gap, hit[1] + ny * tick_gap, bounds)
+            tx, ty = _clamp_label(
+                hit[0] + nx * tick_gap, hit[1] + ny * tick_gap, str(lab), fonts[0],
+                anchor, baseline, bounds,
+            )
             box = _label_box(tx, ty, str(lab), fonts[0], anchor, baseline)
             marks.append((value, str(lab), hit, tx, ty, box))
         reach = max(3.0, tick_gap - 2.0)
@@ -2522,13 +2582,8 @@ def _draw_3d_axes(spec, ext, project, centre, commands, theme, fonts, labs, boun
                 "text", tx, ty, lab, fonts[0], muted,
                 anchor, baseline, 0, 400,
             ))
-        text = labs.get(axis) or ""
-        if not text:
-            continue
-        mid = project(_corner_xyz(pair[0], ext) * 0.5 + _corner_xyz(pair[1], ext) * 0.5)
-        if mid is None:
-            continue
-        lx, ly = _clamp_point(mid[0] + nx * title_gap, mid[1] + ny * title_gap, bounds)
+    for text, lx, ly, anchor, baseline in _axis_title_spots(ext, project, centre, labs, fonts, layout):
+        lx, ly = _clamp_label(lx, ly, text, fonts[0], anchor, baseline, bounds)
         commands.append((
             "text", lx, ly, text, fonts[0], ink2, anchor, baseline, 0, 400,
         ))
@@ -2609,6 +2664,30 @@ def _view_window(spec, plot_w, plot_h):
     return (0.5 - nx / 2, 0.5 + nx / 2, 0.5 - ny / 2, 0.5 + ny / 2)
 
 
+def _window_ticks(scale: dict, u_lo: float, u_hi: float) -> dict:
+    """Ticks across the visible window when coord_equal widens an axis.
+
+    The scale's ticks span the data. Equal aspect can show far more than
+    that (``y^2 = x^3`` is 4.6 wide and 20 tall), and the data's ticks then
+    bunch in a strip. The viewer re-ticks whatever is visible; so does this.
+    Breaks the user chose (``fixed``) are kept.
+    """
+    if (
+        scale.get("kind") != "num" or scale.get("fixed") or scale.get("trans") == "log10"
+        or (u_hi - u_lo) <= 1.2 * (1 + 2 * _PAD)
+    ):
+        return scale
+    from plot3.scales import fmt_ticks, nice_ticks
+
+    lo = float(scale.get("lo", 0.0))
+    span = float(scale.get("hi", 1.0)) - lo or 1.0
+    v_lo, v_hi = lo + u_lo * span, lo + u_hi * span
+    values = [v for v in nice_ticks(v_lo, v_hi, 5) if v_lo <= v <= v_hi]
+    if not values:
+        return scale
+    return dict(scale, ticks=[[v, label] for v, label in zip(values, fmt_ticks(values))])
+
+
 def _ticks(scale: dict) -> list:
     if not scale:
         return []