plot3 0.6.7__tar.gz → 0.7.0__tar.gz

{plot3-0.6.7 → plot3-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plot3
-Version: 0.6.7
+Version: 0.7.0
 Summary: ggplot2 grammar of graphics for Python: interactive WebGL figures and journal-ready PNG, SVG, and PDF
 Author: Rigoberto Leyva Salmeron
 License-Expression: MIT

plot3-0.7.0/plot3/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.7.0"

{plot3-0.6.7 → plot3-0.7.0}/plot3/build.py

@@ -10,6 +10,7 @@ import pandas as pd
 import copy
 import os
 
+from plot3.kde import EXACT_WORK, gaussian_1d
 from plot3.encode import encode_codes, encode_norm, pack_u16, pack_u32, pack_u8
 from plot3.mathtext import split_math
 from plot3.geoms import (
@@ -100,6 +101,11 @@ def _kde_1d(
     if hi <= lo:
         hi = lo + 1.0
     grid = np.linspace(lo, hi, n)
+    if x.size * n > EXACT_WORK:
+        # Large inputs: linear binning and an FFT, as R's density() does.
+        sums = gaussian_1d(x, lo, hi, n, bw)
+        if sums is not None:
+            return grid, sums / x.size
     # (n_grid, n_obs)
     u = (grid[:, None] - x[None, :]) / bw
     dens = np.exp(-0.5 * u * u).sum(axis=1) / (
@@ -1522,6 +1528,26 @@ def _rug_series(rug, g):
     return out
 
 
+def _remap_codes(codes, remap: dict, default) -> np.ndarray:
+    """``remap.get(int(c), default)`` for every code, as one table lookup."""
+    c = np.asarray(codes)
+    if c.dtype.kind not in "biuf" or (c.dtype.kind == "f" and not np.isfinite(c).all()):
+        # Same per-value rule, errors included (int() of NaN raises).
+        return np.array([remap.get(int(x), default) for x in c.ravel()]).reshape(c.shape)
+    ints = c.astype(np.int64)
+    out = np.full(ints.shape, default)
+    if remap and ints.size:
+        keys = np.fromiter(remap.keys(), dtype=np.int64, count=len(remap))
+        values = np.array(list(remap.values()))
+        order = np.argsort(keys)
+        keys, values = keys[order], values[order]
+        at = np.clip(np.searchsorted(keys, ints), 0, len(keys) - 1)
+        hit = keys[at] == ints
+        out = out.astype(np.result_type(out, values))
+        out[hit] = values[at[hit]]
+    return out
+
+
 def _rug_positions(scale, series) -> np.ndarray:
     """Values in the scale's own units; NaN where they have no place."""
     kind, pos, cats = col_values(series)
@@ -1531,6 +1557,13 @@ def _rug_positions(scale, series) -> np.ndarray:
             lookup = np.array([index.get(c, np.nan) for c in cats] + [np.nan], dtype=np.float64)
             codes = np.where(np.isfinite(pos), pos, len(cats)).astype(np.int64)
             return lookup[codes]
+        values = np.asarray(series)
+        # float32 prints differently as a NumPy scalar than as a float.
+        if values.dtype.kind in "biu" or values.dtype == np.float64:
+            # One text lookup per distinct value (NaN included), not per row.
+            codes, uniques = pd.factorize(values, use_na_sentinel=False)
+            lookup = np.array([index.get(str(u), np.nan) for u in uniques.tolist()], dtype=np.float64)
+            return lookup[codes] if len(codes) else np.array([], dtype=np.float64)
         return np.array([index.get(str(v), np.nan) for v in series], dtype=np.float64)
     if kind == "cat":
         return np.full(len(pos), np.nan)
@@ -1726,7 +1759,8 @@ def _formula_legend(legend, formula_geoms, has_title: bool):
     """Tidy the legend rows that function curves add.
 
     * One curve under a title of your own: the title already names it, so
-      the curve gets no row (ggplot2 draws no legend for an unmapped layer).
+      the curve gets no row (ggplot2 draws no legend for an unmapped layer),
+      unless a tangent, derivative or other row sits beside it.
     * Several curves of one formula (a loop over ``a``): the formula moves
       to the legend title and each row lists only its values.
 
@@ -1744,7 +1778,7 @@ def _formula_legend(legend, formula_geoms, has_title: bool):
         return legend, None
     if has_title and len(formula_geoms) == 1:
         kept = [entry for entry in legend if not any(entry is p for p in primary)]
-        return kept or None, None
+        return (legend if kept else None), None
     if len(primary) < 2 or len(primary) != len(formula_geoms):
         return legend, None
     geoms = [entry["_geom"] for entry in primary]
@@ -2210,10 +2244,8 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
             }
             out = np.full(np.size(v), np.nan, dtype=np.float64)
             flat = np.asarray(v, dtype=np.float64).ravel()
-            for i, c in enumerate(flat):
-                if not math.isfinite(c):
-                    continue
-                out[i] = remap.get(int(c), -1)
+            finite = np.isfinite(flat)
+            out[finite] = _remap_codes(flat[finite], remap, -1)
             v = out.reshape(np.shape(v))
             sc.cats = merged
         else:
@@ -2871,6 +2903,28 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
         source = getattr(geom, "_inherit_from", None)
         if source and source in labeled:
             geom.const_color = labeled[source]
+    # Clicking a legend row hides every layer it names: a tangent's line and
+    # its point, a curve and the area shaded under it.
+    legend_keys: dict[int, str] = {}
+    key_of: dict[str, str] = {}
+    for geom, _mapped in resolved:
+        label = getattr(geom, "_legend_label", None)
+        if not label or geom.const_color is None:
+            continue
+        color_key = getattr(geom, "_color_key", None)
+        key = key_of.get(str(label)) or str(color_key or label)
+        legend_keys[id(geom)] = key
+        key_of.setdefault(str(label), key)
+        if color_key:
+            key_of.setdefault(str(color_key), key)
+    for geom, _mapped in resolved:
+        source = getattr(geom, "_inherit_from", None)
+        if id(geom) not in legend_keys and source and str(source) in key_of:
+            legend_keys[id(geom)] = key_of[str(source)]
+    # Stable short keys, so the same figure always builds the same spec.
+    stable: dict[str, str] = {}
+    for gid, key in legend_keys.items():
+        legend_keys[gid] = stable.setdefault(key, f"k{len(stable)}")
 
     payloads: list[tuple[str, str]] = []
     layer_specs = []
@@ -3066,9 +3120,7 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
                             i: color_scale[1].index(c)
                             for i, c in enumerate(local)
                         }
-                        codes = np.array(
-                            [remap.get(int(c), 0) for c in cv], dtype="<u2"
-                        )
+                        codes = _remap_codes(cv, remap, 0).astype("<u2")
                         payloads.append((pid, pack_u16(codes, g.compress)))
                         spec_l["ocolor"] = {
                             "id": pid, "dtype": "u16", "kind": "cat"
@@ -3098,8 +3150,7 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
                 # remap onto the global cat list
                 local = vals["color"][2]
                 remap = {i: color_scale[1].index(c) for i, c in enumerate(local)}
-                codes = np.array([remap.get(int(c), 0) for c in cv[order]],
-                                 dtype="<u2")
+                codes = _remap_codes(cv[order], remap, 0).astype("<u2")
                 payloads.append((pid, pack_u16(codes, g.compress)))
                 spec_l["color"] = {"id": pid, "dtype": "u16", "kind": "cat"}
             else:
@@ -3117,9 +3168,7 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
             if ckind == "cat":
                 local = vals["color"][2]
                 remap = {i: color_scale[1].index(c) for i, c in enumerate(local)}
-                codes = np.array(
-                    [remap.get(int(c), 0) for c in cv[order]], dtype="<u2"
-                )
+                codes = _remap_codes(cv[order], remap, 0).astype("<u2")
                 payloads.append((pid, pack_u16(codes, g.compress)))
                 spec_l["color"] = {"id": pid, "dtype": "u16", "kind": "cat"}
             else:
@@ -3299,10 +3348,7 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
                     flat = np.full(raw.shape, 65535, dtype=np.uint16)
                     ok = np.isfinite(raw) & (raw >= 0)
                     if ok.any():
-                        mapped = np.array(
-                            [remap.get(int(c), 0) for c in raw[ok]],
-                            dtype=np.uint16,
-                        )
+                        mapped = _remap_codes(raw[ok], remap, 0).astype(np.uint16)
                         flat[np.flatnonzero(ok)] = mapped
                     enc = encode_codes(flat, g.compress)
                     pid = f"p{li}fc"
@@ -3362,6 +3408,8 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
             if tip_latex:
                 tip["latex"] = str(tip_latex)
             spec_l["tip"] = tip
+        if id(geom) in legend_keys:
+            spec_l["lk"] = legend_keys[id(geom)]
         layer_specs.append(spec_l)
 
     # color spec + legend
@@ -3402,6 +3450,8 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
             if not label or not geom.const_color:
                 continue
             entry = {"label": str(label), "color": geom.const_color}
+            if id(geom) in legend_keys:
+                entry["lk"] = legend_keys[id(geom)]
             if getattr(geom, "_is_formula", False):
                 entry["formula"] = True
                 entry["_geom"] = geom
@@ -3439,7 +3489,9 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
     raw_title = g.labs.get("title") or ""
     # One function and no title of your own: the formula is the title.
     # A shaded area, a tangent, or roots stay in the legend when they
-    # have a label of their own. The curve's row would only repeat the title.
+    # have a label of their own. The curve keeps its row beside them, so the
+    # legend says which line is the curve; alone, its row would only repeat
+    # the title.
     if not str(raw_title).strip() and len(formula_geoms) == 1:
         shown = formula_geoms[0]
         # Symbolic formula, not the value list. That list stays in the legend
@@ -3456,11 +3508,11 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
         elif title_latex:
             labs_math["title"] = [{"text": title, "latex": str(title_latex)}]
         if legend:
-            legend = [
+            others = [
                 entry for entry in legend
                 if not (entry.get("formula") and entry.get("label") == title)
             ]
-            if not legend:
+            if not others:
                 legend = None
     else:
         title = _take("title", raw_title)

{plot3-0.6.7 → plot3-0.7.0}/plot3/encode.py

@@ -7,6 +7,10 @@ import gzip as _gzip
 
 import numpy as np
 
+# gzip is lossless at every level. Level 1 builds large payloads several
+# times faster than 6 for a few percent more bytes.
+_LEVEL = 1
+
 def delta_u16(a: np.ndarray) -> np.ndarray:
     """Column-wise delta mod 2^16 (lossless; tiny values on ordered data)."""
     d = a.astype(np.int32)
@@ -21,7 +25,7 @@ def pack_u16(q: np.ndarray, compress: bool) -> str:
         raw = _gzip.compress(
             np.ascontiguousarray(d[:, 0]).tobytes()
             + np.ascontiguousarray(d[:, 1]).tobytes(),
-            6,
+            compresslevel=_LEVEL, mtime=0,
         )
     else:
         raw = np.ascontiguousarray(q, dtype="<u2").tobytes()
@@ -31,7 +35,7 @@ def pack_u16(q: np.ndarray, compress: bool) -> str:
 def pack_f32(v: np.ndarray, compress: bool) -> str:
     raw = np.ascontiguousarray(v, dtype="<f4").tobytes()
     if compress:
-        raw = _gzip.compress(raw, 6)
+        raw = _gzip.compress(raw, _LEVEL, mtime=0)
     return base64.b64encode(raw).decode("ascii")
 
 
@@ -55,7 +59,7 @@ def pack_u8(values: np.ndarray, compress: bool) -> str:
     """uint8 array -> base64 (optional gzip; no delta)."""
     raw = np.ascontiguousarray(values, dtype=np.uint8).tobytes()
     if compress:
-        raw = _gzip.compress(raw, 6)
+        raw = _gzip.compress(raw, _LEVEL, mtime=0)
     return base64.b64encode(raw).decode("ascii")
 
 
@@ -63,6 +67,6 @@ def pack_u32(values: np.ndarray, compress: bool) -> str:
     """uint32 array -> base64 (optional gzip; no delta)."""
     raw = np.ascontiguousarray(values, dtype="<u4").tobytes()
     if compress:
-        raw = _gzip.compress(raw, 6)
+        raw = _gzip.compress(raw, _LEVEL, mtime=0)
     return base64.b64encode(raw).decode("ascii")
 

plot3-0.7.0/plot3/kde.py

@@ -0,0 +1,124 @@
+"""Binned Gaussian kernel density sums (linear binning + FFT convolution).
+
+R's ``density()`` bins too. Values are spread onto a fine grid (at least
+four points per output interval, at most 1/20 of a bandwidth apart in
+1D and 1/4 in 2D),
+convolved with the kernel by FFT, and read back at the output points. The
+relative error is far below what a plot shows. Values more than
+``_REACH`` bandwidths past the output range add nothing in float64 and are
+left out. The callers keep the exact sum for small inputs, and these
+helpers return None when the fine grid would be too large.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+# Below this many (observations x output points) the exact sum is cheap.
+EXACT_WORK = 2_000_000
+# The fine spacing is at most this fraction of the bandwidth (1D, 2D), and
+# the fine grid has at least four points per output interval. Linear
+# binning's error grows with the square of that fraction.
+_MAX_STEP_1D = 0.05
+_MAX_STEP_2D = 0.25
+_MIN_FINE = 4
+# Past this many bandwidths a kernel underflows to zero in float64.
+_REACH = 40.0
+# Largest fine grid (points, or cells in 2D) worth binning onto.
+_MAX_CELLS = 1 << 22
+
+
+def _fine_axis(values: np.ndarray, lo: float, hi: float, n: int, h: float, max_step: float):
+    """``(origin, step, size, first, fine)`` of a fine grid through the output points.
+
+    The output point ``k`` sits at fine index ``first + k * fine``. The grid
+    covers every value within ``_REACH`` bandwidths of the output range;
+    values farther out add nothing to the sums.
+    """
+    if n < 2 or not hi > lo or not h > 0 or not values.size:
+        return None
+    fine = max(_MIN_FINE, int(np.ceil((hi - lo) / ((n - 1) * max_step * h))))
+    step = (hi - lo) / ((n - 1) * fine)
+    low = max(float(values.min()), lo - _REACH * h)
+    high = min(float(values.max()), hi + _REACH * h)
+    below = max(0, int(np.ceil((lo - low) / step)))
+    above = max(0, int(np.ceil((high - hi) / step)))
+    size = (n - 1) * fine + 1 + below + above
+    if size > _MAX_CELLS:
+        return None
+    return lo - below * step, step, size, below, fine
+
+
+def _within(values: np.ndarray, origin: float, step: float, size: int) -> np.ndarray:
+    return (values >= origin) & (values <= origin + (size - 1) * step)
+
+
+def _linear_bins(values: np.ndarray, origin: float, step: float, size: int):
+    """Indices and weights of the two fine points around each value."""
+    pos = (values - origin) / step
+    left = np.clip(np.floor(pos).astype(np.int64), 0, size - 2)
+    frac = np.clip(pos - left, 0.0, 1.0)
+    return left, frac
+
+
+def _kernel_fft(step: float, size: int, h: float, length: int) -> np.ndarray:
+    offsets = np.arange(-(size - 1), size) * step
+    kernel = np.exp(-0.5 * (offsets / h) ** 2) / (h * np.sqrt(2.0 * np.pi))
+    return np.fft.rfft(kernel, length)
+
+
+def _fft_length(size: int) -> int:
+    return 1 << int(np.ceil(np.log2(3 * size - 2)))
+
+
+def _convolve(weights: np.ndarray, step: float, size: int, h: float, axis: int) -> np.ndarray:
+    """``sum_i w[i] K((j - i) step)`` for every fine index ``j`` along *axis*."""
+    length = _fft_length(size)
+    spectrum = np.fft.rfft(weights, length, axis=axis)
+    shape = [1] * weights.ndim
+    shape[axis] = -1
+    full = np.fft.irfft(spectrum * _kernel_fft(step, size, h, length).reshape(shape), length, axis=axis)
+    return np.take(full, np.arange(size - 1, 2 * size - 1), axis=axis)
+
+
+def gaussian_1d(x: np.ndarray, lo: float, hi: float, n: int, h: float) -> np.ndarray | None:
+    """``sum_i phi((g - x_i) / h) / h`` at ``linspace(lo, hi, n)``, or None."""
+    axis = _fine_axis(x, lo, hi, n, h, _MAX_STEP_1D)
+    if axis is None:
+        return None
+    origin, step, size, first, fine = axis
+    x = x[_within(x, origin, step, size)]
+    left, frac = _linear_bins(x, origin, step, size)
+    weights = np.bincount(left, 1.0 - frac, size) + np.bincount(left + 1, frac, size)
+    sums = _convolve(weights, step, size, h, axis=0)
+    return np.maximum(sums[first:first + (n - 1) * fine + 1:fine], 0.0)
+
+
+def gaussian_2d(
+    xs: np.ndarray, ys: np.ndarray, x_lims: tuple[float, float], y_lims: tuple[float, float],
+    n: int, hx: float, hy: float,
+) -> np.ndarray | None:
+    """``sum_i phi_x(gx - x_i) phi_y(gy - y_i)`` as an ``(n, n)`` (y, x) grid, or None."""
+    ax = _fine_axis(xs, x_lims[0], x_lims[1], n, hx, _MAX_STEP_2D)
+    ay = _fine_axis(ys, y_lims[0], y_lims[1], n, hy, _MAX_STEP_2D)
+    if ax is None or ay is None:
+        return None
+    (x_origin, x_step, x_size, x_first, x_fine), (y_origin, y_step, y_size, y_first, y_fine) = ax, ay
+    # Two FFT passes over the fine grid must beat n exponentials per value
+    # on each axis; a grid stretched over wide limits does not.
+    if x_size * y_size > _MAX_CELLS or x_size * y_size * 16 > xs.size * n:
+        return None
+    keep = _within(xs, x_origin, x_step, x_size) & _within(ys, y_origin, y_step, y_size)
+    xs, ys = xs[keep], ys[keep]
+    xl, xf = _linear_bins(xs, x_origin, x_step, x_size)
+    yl, yf = _linear_bins(ys, y_origin, y_step, y_size)
+    cells = y_size * x_size
+    weights = np.zeros(cells)
+    for dy, wy in ((0, 1.0 - yf), (1, yf)):
+        for dx, wx in ((0, 1.0 - xf), (1, xf)):
+            weights += np.bincount((yl + dy) * x_size + xl + dx, wy * wx, cells)
+    weights = weights.reshape(y_size, x_size)
+    sums = _convolve(_convolve(weights, x_step, x_size, hx, axis=1), y_step, y_size, hy, axis=0)
+    rows = slice(y_first, y_first + (n - 1) * y_fine + 1, y_fine)
+    cols = slice(x_first, x_first + (n - 1) * x_fine + 1, x_fine)
+    return np.maximum(sums[rows, cols], 0.0)

{plot3-0.6.7 → plot3-0.7.0}/plot3/scales.py

@@ -288,9 +288,19 @@ def ordered_levels(values, *, keep_order: bool = False) -> list:
     "10" before "4"); anything else sorts as text.
     """
     values = list(values)
-    present = [v for v in values if not _is_na(v)]
-    missing = len(present) != len(values)
-    distinct = list(dict.fromkeys(present))
+    try:
+        # Drop repeats first, then test the distinct values for missing:
+        # one isna() call per level instead of one per row.
+        keys = list(dict.fromkeys(values))
+    except TypeError:  # an NA whose comparison has no truth value
+        keys = None
+    if keys is None:
+        present = [v for v in values if not _is_na(v)]
+        missing = len(present) != len(values)
+        distinct = list(dict.fromkeys(present))
+    else:
+        distinct = [v for v in keys if not _is_na(v)]
+        missing = len(distinct) != len(keys)
     if not keep_order:
         if all(isinstance(v, (bool, np.bool_)) for v in distinct):
             distinct.sort(key=bool)

{plot3-0.6.7 → plot3-0.7.0}/plot3/stat2d.py

@@ -19,6 +19,7 @@ import numpy as np
 import pandas as pd
 
 from plot3.geoms import _Geom, aes
+from plot3.kde import EXACT_WORK, gaussian_2d
 from plot3.scales import col_values, ordered_levels, resolution
 from plot3.special import qt
 from plot3.table import has_column, materialize_columns
@@ -1334,6 +1335,11 @@ def _kde2d(xs, ys, n, lims=None, h=None):
     y0, y1 = (ys.min(), ys.max()) if lims is None else lims[2:]
     gx, gy = np.linspace(x0, x1, n), np.linspace(y0, y1, n)
     hx, hy = (_bandwidth(xs), _bandwidth(ys)) if h is None else (float(h[0]) / 4, float(h[1]) / 4)
+    if xs.size * n > EXACT_WORK:
+        # Large inputs: bilinear binning and FFT convolution.
+        sums = gaussian_2d(xs, ys, (float(x0), float(x1)), (float(y0), float(y1)), n, hx, hy)
+        if sums is not None:
+            return gx, gy, sums / xs.size
     kx = np.exp(-0.5 * ((gx[:, None] - xs[None, :]) / hx) ** 2) / (hx * math.sqrt(2 * math.pi))
     ky = np.exp(-0.5 * ((gy[:, None] - ys[None, :]) / hy) ** 2) / (hy * math.sqrt(2 * math.pi))
     z = (ky @ kx.T) / xs.size  # (ny, nx), the shape the contour code takes

{plot3-0.6.7 → plot3-0.7.0}/plot3/viewer.py

@@ -338,8 +338,14 @@ function regCat(ci, obj) {
   if (!catObjs.has(ci)) catObjs.set(ci, []);
   catObjs.get(ci).push(obj);
 }
+// legend click on a formula row (tangent, derivative, curve): row key ->
+// every three.js object its layers drew, e.g. a tangent's line and its point
+const hiddenKeys = new Set();
+const keyObjs = new Map();
+let currentLK = null;   // the key of the layer being drawn, while it draws
+function layerHidden(L) { return L.lk != null && hiddenKeys.has(L.lk); }
 let redraw = () => {};   // 2D assigns its draw(); 3D renders continuously
-window.__plot3 = { hiddenCats, catObjs };
+window.__plot3 = { hiddenCats, catObjs, hiddenKeys, keyObjs };
 function showLegendBox() {
   // theme(legend_position="none"), and all but one panel of a facet_grid.
   if (S.legendPosition === 'none') return;
@@ -414,15 +420,23 @@ if (S.legend) {
   legEl.innerHTML = (S.labs.color ? '<b style="color:'+T.ink+'">' +
       richLabel('color', S.labs.color) + '</b>' : '') +
     S.legend.map((e, i) => '<div class="lg-e" data-ci="' + (e.ci != null ? e.ci : i) +
+      (e.lk != null ? '" data-lk="' + plot3Esc(e.lk) : '') +
       '">' + keyHTML(e, e.color) +
       legendLabel(e) + '</div>').join('') + barHTML() + szHTML;
   legEl.addEventListener('click', ev => {
     const row = ev.target.closest('.lg-e');
     if (!row) return;
-    const ci = +row.dataset.ci;
-    if (hiddenCats.has(ci)) hiddenCats.delete(ci); else hiddenCats.add(ci);
-    row.style.opacity = hiddenCats.has(ci) ? 0.35 : 1;
-    for (const o of (catObjs.get(ci) || [])) o.visible = !hiddenCats.has(ci);
+    const lk = row.dataset.lk;
+    if (lk != null) {
+      if (hiddenKeys.has(lk)) hiddenKeys.delete(lk); else hiddenKeys.add(lk);
+      row.style.opacity = hiddenKeys.has(lk) ? 0.35 : 1;
+      for (const o of (keyObjs.get(lk) || [])) o.visible = !hiddenKeys.has(lk);
+    } else {
+      const ci = +row.dataset.ci;
+      if (hiddenCats.has(ci)) hiddenCats.delete(ci); else hiddenCats.add(ci);
+      row.style.opacity = hiddenCats.has(ci) ? 0.35 : 1;
+      for (const o of (catObjs.get(ci) || [])) o.visible = !hiddenCats.has(ci);
+    }
     if (window.__plot3.afterLegend) window.__plot3.afterLegend();
     tip.style.display = 'none';
     redraw();
@@ -607,6 +621,16 @@ renderer.setPixelRatio(window.devicePixelRatio);
 renderer.setClearColor(0x000000, 0);
 host.appendChild(renderer.domElement);
 const scene = new THREE.Scene();
+{
+  const add0 = scene.add.bind(scene);
+  scene.add = (...objs) => {
+    if (currentLK != null) {
+      if (!keyObjs.has(currentLK)) keyObjs.set(currentLK, []);
+      keyObjs.get(currentLK).push(...objs);
+    }
+    return add0(...objs);
+  };
+}
 const lineMats = [];
 
 // Point symbols (aes(shape=) / geom_point(shape=)) as white sprites tinted
@@ -1614,6 +1638,7 @@ if (!S.is3d) {
     return addToScene(...objs);
   };
   for (const L of S.layers) {
+    currentLK = L.lk != null ? L.lk : null;
     if (L.blank) continue;  // geom_blank: on the scales only
     paintOrder += 1;
     const n = L.n;
@@ -1937,6 +1962,7 @@ if (!S.is3d) {
       });
     }
   }
+  currentLK = null;
   scene.add = addToScene;
 
   function drawAxes() {
@@ -2267,6 +2293,7 @@ if (!S.is3d) {
       if (!best || score < best.score) best = { score, sx, sy, html, hold: !!hold };
     }
     for (const L of S.layers) {
+      if (layerHidden(L)) continue;
       if (L.kind === 'col') {
         // Full bar rectangle (not just the top-center point).
         const hw = (L.width || 0.08) * 0.5;
@@ -2445,6 +2472,7 @@ if (!S.is3d) {
   }
 
   for (const L of S.layers) {
+    currentLK = L.lk != null ? L.lk : null;
     if (L.blank) continue;  // geom_blank: on the scales only
     const n = L.n;
     const cols = layerColors(L, hex2rgb(T.cat[0]));
@@ -2528,6 +2556,7 @@ if (!S.is3d) {
       }
     }
   }
+  currentLK = null;
 
   // Axes box as matplotlib and plotly draw it: the three far walls with
   // grid lines, refreshed as the camera orbits. The edges at the near
@@ -2706,6 +2735,7 @@ if (!S.is3d) {
     let best = null, bestD = Infinity;
     const maxScan = 80000;
     for (const { L } of pickLayers) {
+      if (layerHidden(L)) continue;
       const n = L._stepN != null ? L._stepN : L.n;
       const step = n > maxScan ? Math.ceil(n / maxScan) : 1;
       const xs = L._x || L.x.data;

{plot3-0.6.7 → plot3-0.7.0}/plot3.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plot3
-Version: 0.6.7
+Version: 0.7.0
 Summary: ggplot2 grammar of graphics for Python: interactive WebGL figures and journal-ready PNG, SVG, and PDF
 Author: Rigoberto Leyva Salmeron
 License-Expression: MIT

{plot3-0.6.7 → plot3-0.7.0}/plot3.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ plot3/geoms.py
 plot3/ggplot.py
 plot3/io.py
 plot3/jupyter.py
+plot3/kde.py
 plot3/latexin.py
 plot3/masking.py
 plot3/mathtext.py
@@ -48,6 +49,7 @@ tests/test_contour.py
 tests/test_everyday_ggplot2.py
 tests/test_expr.py
 tests/test_facets_compose.py
+tests/test_fast_paths.py
 tests/test_geom_function.py
 tests/test_geoms_ds.py
 tests/test_ggplot2_extras2.py

plot3-0.7.0/tests/test_fast_paths.py

@@ -0,0 +1,106 @@
+"""Vectorised level, code and density paths match the per-value rules."""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+import pandas as pd
+import pytest
+
+import plot3.build as build
+import plot3.stat2d as stat2d
+from plot3.build import _kde_1d, _remap_codes, _rug_positions
+from plot3.scales import Scale, _is_na, ordered_levels
+from plot3.stat2d import _kde2d
+
+
+def _levels_per_value(values, keep_order=False):
+    """ordered_levels as it was: test every row for missing, then dedupe."""
+    values = list(values)
+    present = [v for v in values if not _is_na(v)]
+    distinct = list(dict.fromkeys(present))
+    out = ordered_levels(distinct, keep_order=keep_order)
+    return out + ([None] if len(present) != len(values) else [])
+
+
+@pytest.mark.parametrize("values", [
+    ["Adelie", "Gentoo", None, "Adelie", "Chinstrap", float("nan"), "Gentoo"] * 500,
+    [4.0, 6.0, np.nan, 8.0, 10.0, 6.0] * 500,
+    [True, False, None, True] * 500,
+    [3, 1.0, 1, 2, np.int64(3)] * 500,
+    ["Biscoe", pd.NA, "Dream", pd.NA, pd.NaT, "Biscoe"] * 500,
+    [float("nan")] * 50 + ["Torgersen"],
+    [],
+])
+@pytest.mark.parametrize("keep_order", [False, True])
+def test_ordered_levels_matches_the_per_row_rule(values, keep_order):
+    assert ordered_levels(values, keep_order=keep_order) == _levels_per_value(values, keep_order)
+
+
+def test_remap_codes_matches_the_dict_rule():
+    rng = np.random.default_rng(0)
+    remap = {0: 2, 1: 0, 3: 1}
+    for codes in (rng.integers(-1, 5, 1000).astype(float), rng.integers(0, 4, 1000), np.array([], dtype=float)):
+        expected = np.array([remap.get(int(c), 7) for c in codes])
+        assert np.array_equal(_remap_codes(codes, remap, 7), expected)
+    assert np.array_equal(_remap_codes(np.array([1.9, -0.5]), remap, 7), [0, 2])
+    assert np.array_equal(_remap_codes(np.array([2.0]), {}, 0), [0])
+    with pytest.raises(ValueError):
+        _remap_codes(np.array([0.0, np.nan]), remap, 0)
+
+
+@pytest.mark.parametrize("series", [
+    pd.Series([4.0, 6.0, np.nan, 8.0, 4.0]),
+    pd.Series([4, 6, 8, 6]),
+    pd.Series([True, False, True]),
+    pd.Series(np.array([4.0, 6.5], dtype=np.float32)),
+])
+def test_rug_positions_on_a_discrete_scale_match_text_lookup(series):
+    scale = Scale("cat")
+    scale.cats = ["4", "6", "8", "True", "4.0", "6.0", "6.5", "nan"]
+    index = {c: i for i, c in enumerate(scale.cats)}
+    expected = np.array([index.get(str(v), np.nan) for v in series], dtype=np.float64)
+    np.testing.assert_array_equal(_rug_positions(scale, series), expected)
+
+
+def _exact(module, fn, *args, **kwargs):
+    saved = module.EXACT_WORK
+    module.EXACT_WORK = math.inf
+    try:
+        return fn(*args, **kwargs)
+    finally:
+        module.EXACT_WORK = saved
+
+
+@pytest.mark.parametrize("values, adjust", [
+    (np.random.default_rng(1).normal(4200, 800, 20_000), 1.0),
+    (np.random.default_rng(2).lognormal(0, 1.5, 20_000), 1.0),
+    (np.random.default_rng(3).normal(17, 2, 20_000), 0.2),
+    (np.r_[np.random.default_rng(4).normal(0, 1, 20_000), [1e6]], 1.0),
+    (np.random.default_rng(5).integers(2007, 2010, 20_000).astype(float), 1.0),
+])
+def test_binned_density_matches_the_exact_sum(values, adjust):
+    grid, dens = _kde_1d(values, adjust=adjust)
+    exact_grid, exact = _exact(build, _kde_1d, values, adjust=adjust)
+    np.testing.assert_array_equal(grid, exact_grid)
+    assert np.max(np.abs(dens - exact)) <= 2e-4 * exact.max()
+
+
+def test_small_densities_keep_the_exact_sum():
+    values = np.random.default_rng(6).normal(44, 5, 300)
+    np.testing.assert_array_equal(_kde_1d(values)[1], _exact(build, _kde_1d, values)[1])
+    xs, ys = np.random.default_rng(7).normal(0, 1, (2, 300))
+    np.testing.assert_array_equal(_kde2d(xs, ys, 50)[2], _exact(stat2d, _kde2d, xs, ys, 50)[2])
+
+
+@pytest.mark.parametrize("lims, h", [(None, None), (None, (2.0, 1.0)), ((-1, 1, -0.5, 0.5), None)])
+def test_binned_2d_density_matches_the_exact_sum(lims, h):
+    rng = np.random.default_rng(8)
+    xs, ys = rng.normal(44, 5, 60_000), rng.exponential(2, 60_000)
+    gx, gy, z = _kde2d(xs, ys, 100, lims, h)
+    ex, ey, exact = _exact(stat2d, _kde2d, xs, ys, 100, lims, h)
+    np.testing.assert_array_equal(gx, ex)
+    np.testing.assert_array_equal(gy, ey)
+    # A quarter-bandwidth grid: the error stays under 0.2% of the peak.
+    assert np.max(np.abs(z - exact)) <= 2e-3 * exact.max()

{plot3-0.6.7 → plot3-0.7.0}/tests/test_math_layers.py

@@ -13,6 +13,7 @@ from plot3 import (
     geom_vector_field,
     ggplot,
     ggsave,
+    labs,
     slider,
     tangent,
 )
@@ -134,6 +135,39 @@ def test_tangent_at_one_has_slope_two():
     assert any(entry["label"] == "tangent" for entry in spec["legend"])
 
 
+def test_legend_rows_name_the_layers_a_click_hides():
+    # The viewer hides every layer whose key matches the clicked row: the
+    # tangent row covers its line and the point at x = 1.
+    spec, _payloads = build_spec(
+        ggplot() + geom_function("y = x^3 - 3x") + tangent(at=1) + derivative()
+    )
+    keys = {entry["label"]: entry["lk"] for entry in spec["legend"]}
+    tangent_layers = [layer for layer in spec["layers"] if layer.get("lk") == keys["tangent"]]
+    assert sorted(layer["kind"] for layer in tangent_layers) == ["line", "point"]
+    assert len(set(keys.values())) == 3
+    # Stable keys: the same figure builds the same spec.
+    again, _payloads = build_spec(
+        ggplot() + geom_function("y = x^3 - 3x") + tangent(at=1) + derivative()
+    )
+    assert [entry["lk"] for entry in again["legend"]] == list(keys.values())
+
+
+def test_curve_keeps_its_row_beside_a_tangent_and_derivative():
+    spec, _payloads = build_spec(
+        ggplot() + geom_function("y = x^3 - 3x") + tangent(at=1) + derivative()
+    )
+    labels = [entry["label"] for entry in spec["legend"]]
+    assert labels[0] == spec["labs"]["title"]
+    assert "tangent" in labels and len(labels) == 3
+    titled, _payloads = build_spec(
+        ggplot() + geom_function("y = x^2") + tangent(at=1) + labs(title="Slope")
+    )
+    assert len(titled["legend"]) == 2
+    # Alone, the curve's row would only repeat the title.
+    alone, _payloads = build_spec(ggplot() + geom_function("y = x^2"))
+    assert alone["legend"] is None
+
+
 def test_derivative_is_the_slope_curve():
     layers = _layers(ggplot() + geom_function("y = x^2", xlim=(-2, 2), n=11) + derivative())
     curve = next(

plot3-0.6.7/plot3/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.6.7"