plotpress 0.23.2__py3-none-any.whl

plotpress/png.py

@@ -0,0 +1,93 @@
+"""Minimal PNG encoder built only on the standard library (``zlib``).
+
+Used to rasterize ``pcolormesh`` / image layers into a single ``<image>``
+element embedded in the SVG as a base64 data URI. PNG's container format is
+simple enough that no third-party dependency is needed; the heavy lifting is a
+single vectorized ``zlib.compress`` call.
+"""
+
+from __future__ import annotations
+
+import base64
+import struct
+import zlib
+
+import numpy as np
+
+
+def _chunk(tag: bytes, data: bytes) -> bytes:
+    out = struct.pack(">I", len(data)) + tag + data
+    crc = zlib.crc32(tag + data) & 0xFFFFFFFF
+    return out + struct.pack(">I", crc)
+
+
+_SIG = b"\x89PNG\r\n\x1a\n"
+
+
+def encode_png(rgba: np.ndarray) -> bytes:
+    """Encode an ``(H, W, 3|4)`` uint8 array as 8-bit PNG bytes.
+
+    Colormapped output is emitted as **indexed** colour when it fits in 256
+    entries, which every mesh does: the colours come from a 256-entry colormap
+    LUT, so a field of any size still draws from at most 256 distinct RGBA
+    values. That stores one byte per pixel plus a small palette instead of four
+    bytes per pixel, and the whole raster travels inside the interactive HTML,
+    so the saving lands directly on the file a reader downloads. Anything with
+    more colours -- a Gouraud mesh interpolates between nodes, so it does --
+    falls back to RGBA.
+    """
+    arr = np.ascontiguousarray(rgba)
+    if arr.dtype != np.uint8:
+        arr = np.clip(arr, 0, 255).astype(np.uint8)
+    h, w = arr.shape[:2]
+    if arr.shape[2] == 3:
+        arr = np.concatenate([arr, np.full((h, w, 1), 255, np.uint8)], axis=2)
+
+    indexed = _encode_indexed(arr, h, w)
+    return indexed if indexed is not None else _encode_rgba(arr, h, w)
+
+
+def _encode_rgba(arr: np.ndarray, h: int, w: int) -> bytes:
+    # Prepend a per-scanline filter byte (0 = None).
+    raw = np.empty((h, 1 + w * 4), dtype=np.uint8)
+    raw[:, 0] = 0
+    raw[:, 1:] = arr.reshape(h, w * 4)
+    ihdr = struct.pack(">IIBBBBB", w, h, 8, 6, 0, 0, 0)   # 8-bit RGBA
+    return (_SIG + _chunk(b"IHDR", ihdr)
+            + _chunk(b"IDAT", zlib.compress(raw.tobytes(), level=6))
+            + _chunk(b"IEND", b""))
+
+
+def _encode_indexed(arr: np.ndarray, h: int, w: int):
+    """Indexed-colour PNG, or ``None`` if the image needs more than 256 entries."""
+    flat = arr.reshape(-1, 4)
+    # One uint32 per pixel makes the unique/inverse pass cheap; the byte order
+    # only has to be self-consistent, since the palette is rebuilt from it.
+    keys = flat.view(np.uint32).reshape(-1) if flat.flags["C_CONTIGUOUS"] \
+        else np.ascontiguousarray(flat).view(np.uint32).reshape(-1)
+    palette_keys, index = np.unique(keys, return_inverse=True)
+    if palette_keys.size > 256:
+        return None
+
+    palette = palette_keys.view(np.uint8).reshape(-1, 4)
+    raw = np.empty((h, 1 + w), dtype=np.uint8)
+    raw[:, 0] = 0
+    raw[:, 1:] = index.astype(np.uint8).reshape(h, w)
+
+    chunks = [_chunk(b"IHDR", struct.pack(">IIBBBBB", w, h, 8, 3, 0, 0, 0)),
+              _chunk(b"PLTE", palette[:, :3].tobytes())]
+    alpha = palette[:, 3]
+    if np.any(alpha != 255):
+        # tRNS for indexed PNG is one alpha byte per palette entry; trailing
+        # opaque entries may be omitted, so stop after the last transparent one.
+        last = int(np.nonzero(alpha != 255)[0].max())
+        chunks.append(_chunk(b"tRNS", alpha[:last + 1].tobytes()))
+    chunks.append(_chunk(b"IDAT", zlib.compress(raw.tobytes(), level=6)))
+    chunks.append(_chunk(b"IEND", b""))
+    return _SIG + b"".join(chunks)
+
+
+def png_data_uri(rgba: np.ndarray) -> str:
+    """Return a ``data:image/png;base64,...`` URI for the given RGBA array."""
+    b64 = base64.b64encode(encode_png(rgba)).decode("ascii")
+    return "data:image/png;base64," + b64

plotpress/polar.py

@@ -0,0 +1,240 @@
+"""Polar axes: (theta, r) plotting on top of the Cartesian core.
+
+A :class:`PolarAxes` is an ordinary :class:`~plotpress.axes.Axes` running with
+equal aspect and the rectangular frame turned off. It projects ``(theta, r)``
+data to ``(x, y) = (r cos theta, r sin theta)`` before handing it to the normal
+plotting methods, and it builds its own polar frame -- radial grid circles,
+angular spokes, and tick labels -- entirely out of existing ``plot``/``text``
+artists. Nothing in the SVG or raster renderer needs to know polar exists, in
+the same spirit as ``violinplot``'s inner marks.
+
+Supported so far: ``plot``, ``scatter``, ``fill`` (the plot types that make
+sense on a polar grid), plus ``set_rmax``/``set_rlim``/``set_rticks``,
+``set_thetagrids``, ``set_theta_direction`` and ``set_theta_zero_location``.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .axes import Axes
+from .ticker import nice_ticks
+
+_ZERO_LOC = {"E": 0.0, "N": np.pi / 2, "W": np.pi, "S": -np.pi / 2}
+
+
+def _fmt_r(v):
+    return ("%g" % v)
+
+
+class PolarAxes(Axes):
+    def __init__(self, figure, rect):
+        super().__init__(figure, rect)
+        self._is_polar = True
+        self.set_aspect("equal")
+        self.set_axis_off()
+        self._theta_direction = 1        # +1 counter-clockwise (matplotlib default)
+        self._theta_offset = 0.0         # radians; where theta=0 points
+        self._rmax = None                # None -> autoscale from data
+        self._rmin = 0.0
+        self._rticks = None              # None -> "nice" ticks
+        self._thetagrids = None          # None -> 8 evenly spaced spokes
+        self._rdata = []                 # r arrays seen, for autoscale
+        self._frame_artists = []         # rebuilt whenever data or limits change
+
+    # -- projection ---------------------------------------------------------
+    def _project(self, theta, r):
+        theta = np.asarray(theta, float) * self._theta_direction + self._theta_offset
+        r = np.asarray(r, float)
+        return r * np.cos(theta), r * np.sin(theta)
+
+    def _track_r(self, r):
+        r = np.asarray(r, float)
+        if r.size:
+            self._rdata.append(r)
+
+    def _auto_rmax(self):
+        vals = [np.nanmax(np.abs(r)) for r in self._rdata
+                if r.size and np.isfinite(r).any()]
+        return max(vals) if vals else None
+
+    # -- plotting (project, then delegate to the Cartesian core) ------------
+    def plot(self, theta, r, **kwargs):
+        """Plot ``r`` versus ``theta`` (radians) as a polar line."""
+        theta = np.asarray(theta, dtype=float)
+        r = np.asarray(r, dtype=float)
+        x, y = self._project(theta, r)
+        self._track_r(r)
+        # Carried as pick_values so point-picking reports the polar
+        # coordinates the caller actually plotted, not the Cartesian (x, y)
+        # they got projected to for drawing -- which is what the interactive
+        # HTML reports for anything else built on the Cartesian core, and
+        # meaningless read back on a polar chart.
+        values = {"theta": theta, "r": r}
+        values.update(kwargs.pop("values", None) or {})
+        line = super().plot(x, y, values=values, **kwargs)
+        self._rebuild_frame()
+        return line
+
+    def scatter(self, theta, r, **kwargs):
+        """Scatter ``r`` versus ``theta`` (radians)."""
+        theta = np.asarray(theta, dtype=float)
+        r = np.asarray(r, dtype=float)
+        x, y = self._project(theta, r)
+        self._track_r(r)
+        values = {"theta": theta, "r": r}
+        values.update(kwargs.pop("values", None) or {})
+        coll = super().scatter(x, y, values=values, **kwargs)
+        self._rebuild_frame()
+        return coll
+
+    def fill(self, theta, r, **kwargs):
+        """Fill the polygon traced by ``(theta, r)``."""
+        x, y = self._project(theta, r)
+        self._track_r(r)
+        poly = super().fill(x, y, **kwargs)
+        self._rebuild_frame()
+        return poly
+
+    def set_xscale(self, scale):
+        """Only ``'linear'`` -- the polar projection has no log-axis support."""
+        if scale != "linear":
+            raise NotImplementedError(
+                "PolarAxes does not support non-linear scales (got %r)" % scale)
+        self._xscale = scale
+
+    def set_yscale(self, scale):
+        """Only ``'linear'`` -- the polar projection has no log-axis support."""
+        if scale != "linear":
+            raise NotImplementedError(
+                "PolarAxes does not support non-linear scales (got %r)" % scale)
+        self._yscale = scale
+
+    # -- polar limits / grid API -------------------------------------------
+    def set_rmax(self, rmax):
+        self._rmax = float(rmax)
+        self._rebuild_frame()
+        return self
+
+    def set_rlim(self, rmin=None, rmax=None):
+        if rmin is not None:
+            self._rmin = float(rmin)
+        if rmax is not None:
+            self._rmax = float(rmax)
+        self._rebuild_frame()
+        return self
+
+    def set_rticks(self, ticks):
+        self._rticks = None if ticks is None else [float(t) for t in ticks]
+        self._rebuild_frame()
+        return self
+
+    def set_thetagrids(self, angles):
+        """Place angular gridlines at ``angles`` (degrees), or an int count."""
+        if angles is None or np.ndim(angles) == 0:
+            self._thetagrids = None if angles is None else int(angles)
+        else:
+            self._thetagrids = [float(a) for a in angles]
+        self._rebuild_frame()
+        return self
+
+    def set_theta_direction(self, direction):
+        """``+1``/``'counterclockwise'`` or ``-1``/``'clockwise'``."""
+        if direction in (-1, "clockwise", "cw"):
+            self._theta_direction = -1
+        else:
+            self._theta_direction = 1
+        self._reproject()
+        return self
+
+    def set_theta_zero_location(self, loc):
+        """Point ``theta=0`` at compass location ``'N'``/``'E'``/``'S'``/``'W'``."""
+        self._theta_offset = _ZERO_LOC[loc]
+        self._reproject()
+        return self
+
+    def set_theta_offset(self, offset):
+        """Set the angle (radians) at which ``theta=0`` is drawn."""
+        self._theta_offset = float(offset)
+        self._reproject()
+        return self
+
+    # -- frame construction -------------------------------------------------
+    def _reproject(self):
+        # Changing orientation after data exists would need re-projecting every
+        # artist; keep it simple and supported by requiring orientation to be set
+        # before plotting.
+        if self._rdata:
+            raise RuntimeError(
+                "set orientation (theta direction/zero location/offset) before "
+                "plotting into a polar axes"
+            )
+        self._rebuild_frame()
+
+    def _theta_positions(self):
+        if isinstance(self._thetagrids, list):
+            return np.radians(self._thetagrids)
+        n = self._thetagrids if isinstance(self._thetagrids, int) else 8
+        return np.arange(n) * (2 * np.pi / n)
+
+    def _frame_add(self, artist):
+        self._frame_artists.append(artist)
+        return artist
+
+    def _rebuild_frame(self):
+        """Recompute the polar frame from current data/limit state.
+
+        Frame artists are stripped and rebuilt each call, then moved ahead of the
+        data artists so the grid sits behind the plot (matplotlib z-order).
+        """
+        frame_ids = set(map(id, self._frame_artists))
+        self.artists = [a for a in self.artists if id(a) not in frame_ids]
+        self._frame_artists = []
+
+        rmax = self._rmax if self._rmax is not None else self._auto_rmax()
+        if not rmax or not np.isfinite(rmax) or rmax <= 0:
+            return
+
+        ticks = (self._rticks if self._rticks is not None
+                 else nice_ticks(0.0, rmax))
+        ticks = [t for t in ticks if 0 < t <= rmax * 1.0001]
+
+        ang = np.linspace(0.0, 2 * np.pi, 120)
+        cos_a, sin_a = np.cos(ang), np.sin(ang)
+        grid_c, edge_c, txt_c = "#d0d0d0", "#a0a0a0", "#555555"
+
+        # radial grid circles + outer boundary
+        for t in ticks:
+            self._frame_add(Axes.plot(self, t * cos_a, t * sin_a,
+                                      color=grid_c, linewidth=0.8))
+        self._frame_add(Axes.plot(self, rmax * cos_a, rmax * sin_a,
+                                  color=edge_c, linewidth=1.0))
+
+        # angular spokes + degree labels
+        size = self.style.tick_label_size
+        for th in self._theta_positions():
+            a = th * self._theta_direction + self._theta_offset
+            ca, sa = np.cos(a), np.sin(a)
+            self._frame_add(Axes.plot(self, [0.0, rmax * ca], [0.0, rmax * sa],
+                                      color=grid_c, linewidth=0.8))
+            deg = int(round(np.degrees(th))) % 360
+            self._frame_add(self.text(rmax * 1.12 * ca, rmax * 1.12 * sa,
+                                      f"{deg}°", ha="center", va="center",
+                                      fontsize=size, color=txt_c))
+
+        # radial tick labels, along a lightly off-axis spoke so they clear it
+        la = 0.12 + self._theta_offset
+        for t in ticks:
+            self._frame_add(self.text(t * np.cos(la), t * np.sin(la), _fmt_r(t),
+                                      ha="center", va="center", fontsize=size,
+                                      color=txt_c))
+
+        # move the frame behind the data, and fix an equal, symmetric view
+        fid = set(map(id, self._frame_artists))
+        data = [a for a in self.artists if id(a) not in fid]
+        frame = [a for a in self.artists if id(a) in fid]
+        self.artists = frame + data
+
+        pad = rmax * 1.25
+        Axes.set_xlim(self, -pad, pad)
+        Axes.set_ylim(self, -pad, pad)

plotpress/primitives.py

@@ -0,0 +1,335 @@
+"""Backend-agnostic drawing primitives in **pixel space**.
+
+The geometry of an artist (applying the transform, splitting on NaN, decimating
+huge lines, computing quad corners) is computed *once* here, producing a small
+fixed vocabulary of primitives. Each backend (:mod:`plotpress.svg`,
+:mod:`plotpress.raster`) then only needs to know how to draw those few
+primitive types -- so a new artist that emits, say, a filled polygon needs no
+new code in either backend.
+
+``artist_to_prims(artist, tr, ai, k)`` returns the primitives for a migrated
+artist, or ``None`` if the artist still uses its legacy per-backend renderer.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+import numpy as np
+
+from .artists import (
+    AxLine, FillBetween, HLine, Image, Line2D, LineCollection, Polygon,
+    PolyCollection, QuadMesh, Rug, ScatterCollection, Span, VLine,
+)
+
+# Lines longer than this are min/max-decimated per pixel column before drawing
+# (monotonic x only), the pure-Python analogue of matplotlib's path
+# simplification: huge time-series lines draw ~7x faster and ~40x smaller with
+# no visible change, keeping the output vector.
+_DECIMATE_MIN_POINTS = 5000
+
+
+def _is_monotonic(x: np.ndarray) -> bool:
+    d = np.diff(x)
+    return bool(np.all(d >= 0) or np.all(d <= 0))
+
+
+def _decimate_minmax(x, y, ncols):
+    """Keep first/last/min-y/max-y per pixel column (monotonic x only)."""
+    n = x.size
+    if n <= 4 * ncols or ncols < 1:
+        return x, y
+    x0, x1 = float(x[0]), float(x[-1])
+    span = (x1 - x0) or 1.0
+    col = np.clip(((x - x0) / span * ncols).astype(np.intp), 0, ncols - 1)
+    keep = np.zeros(n, bool)
+    runstart = np.empty(n, bool); runstart[0] = True; runstart[1:] = col[1:] != col[:-1]
+    runend = np.empty(n, bool); runend[-1] = True; runend[:-1] = col[1:] != col[:-1]
+    keep |= runstart | runend
+    order = np.lexsort((y, col))
+    sc = col[order]
+    lo = np.empty(n, bool); lo[0] = True; lo[1:] = sc[1:] != sc[:-1]
+    hi = np.empty(n, bool); hi[-1] = True; hi[:-1] = sc[1:] != sc[:-1]
+    keep[order[lo]] = True
+    keep[order[hi]] = True
+    idx = np.flatnonzero(keep)
+    return x[idx], y[idx]
+
+
+def _finite_subpaths(pts):
+    """Split an (N,2) pixel array into contiguous finite runs."""
+    mask = np.isfinite(pts).all(axis=1)
+    if mask.all():
+        return [pts] if len(pts) else []
+    out = []
+    n = len(pts)
+    i = 0
+    while i < n:
+        if not mask[i]:
+            i += 1
+            continue
+        j = i
+        while j < n and mask[j]:
+            j += 1
+        out.append(pts[i:j])
+        i = j
+    return out
+
+
+# -- primitive vocabulary ---------------------------------------------------
+@dataclass
+class Path:
+    """A stroked and/or filled path of one or more subpaths (pixel coords)."""
+    subpaths: List[np.ndarray]
+    closed: bool = False
+    element: str = "path"          # "path" or "polygon" (single closed subpath)
+    stroke: Optional[str] = None
+    stroke_width: float = 1.0
+    linestyle: str = "-"
+    stroke_opacity: float = 1.0
+    stroke_round: bool = False
+    fill: Optional[str] = None
+    fill_opacity: float = 1.0
+    series_id: Optional[str] = None
+    label: str = ""
+
+
+@dataclass
+class Line:
+    """A single straight segment (axvline / axhline / axline)."""
+    p0: tuple
+    p1: tuple
+    stroke: str
+    stroke_width: float
+    linestyle: str = "-"
+    stroke_opacity: float = 1.0
+    label: str = ""
+
+
+@dataclass
+class Rect:
+    """An axis-aligned filled rectangle (axhspan / axvspan)."""
+    x: float
+    y: float
+    w: float
+    h: float
+    fill: str
+    fill_opacity: float = 1.0
+    label: str = ""
+
+
+@dataclass
+class Segments:
+    """A batch of independent line segments (hlines / vlines)."""
+    segs: np.ndarray               # (N, 4): x0, y0, x1, y1
+    stroke: str
+    stroke_width: float
+    linestyle: str = "-"
+    stroke_opacity: float = 1.0
+    label: str = ""
+
+
+@dataclass
+class PolygonBatch:
+    """Many filled polygons with per-polygon colors (hexbin)."""
+    polys: List[np.ndarray]        # list of (k, 2)
+    fills: list                    # per-poly color (str or rgb triple)
+    edge: Optional[str] = None
+    edge_width: float = 0.4
+    alpha: float = 1.0
+    label: str = ""
+
+
+@dataclass
+class ImagePrim:
+    """An RGBA raster placed at a pixel rect (pcolormesh / imshow / contourf)."""
+    rgba: np.ndarray               # (H, W, 4) uint8
+    x: float
+    y: float
+    w: float
+    h: float
+    smooth: bool = False           # False = image-rendering:pixelated (the default)
+    label: str = ""                 # legend/toggle label, same as every other series
+
+
+@dataclass
+class Markers:
+    """A batch of round point markers (scatter), constant-size in pixels."""
+    points: np.ndarray             # (N, 2) pixel centers (may contain NaN)
+    diameters: np.ndarray          # (N,) pixel diameters
+    colors: list                   # per-point color strings (len N)
+    single_color: bool = True      # all points share one color (fewer nodes)
+    alpha: float = 1.0
+    series_id: Optional[str] = None
+    label: str = ""
+    edgecolor: Optional[str] = None   # one outline color for the whole batch
+    edgewidth: float = 0.0            # pixel outline width; 0 draws no outline
+
+
+# -- artist -> primitives ---------------------------------------------------
+def artist_to_prims(artist, tr, ai, k, size_scale=1.0):
+    """Primitives for a migrated artist, or None to use its legacy renderer.
+
+    ``size_scale`` converts marker sizes from points to this backend's pixels
+    (``dpi/72`` for SVG, ``dpi/72 * S`` for the supersampled raster).
+    """
+    a = artist
+    lbl = a.label or "" if getattr(a, "label", None) else ""
+
+    if isinstance(a, ScatterCollection):
+        pts = tr.xy(a.x, a.y)
+        diam = np.broadcast_to(np.asarray(a.s, float), a.x.shape).astype(float) * size_scale
+        fc = a.face_colors()
+        colors = fc if fc is not None else [a.color] * a.x.size
+        return [Markers(pts, diam, list(colors), single_color=(fc is None),
+                        alpha=a.alpha, series_id=f"s{ai}_{k}", label=lbl,
+                        edgecolor=a.edgecolor,
+                        edgewidth=(a.linewidths or 0.0) * size_scale)]
+
+    if isinstance(a, Line2D):
+        x, y = a.x, a.y
+        if x.size > _DECIMATE_MIN_POINTS and _is_monotonic(x):
+            x, y = _decimate_minmax(x, y, int(round(tr.px_w)))
+        subs = _finite_subpaths(tr.xy(x, y))
+        if not subs:
+            return []
+        # linestyle="none" (matplotlib's "markers only" idiom) means no
+        # connecting line at all -- omitting the Path prim here, once, is
+        # what makes every backend honor that, the same way errorbar()'s own
+        # renderers already special-case "none" to skip their line.
+        prims = ([] if a.linestyle == "none" else
+                 [Path(subpaths=subs, stroke=a.color, stroke_width=a.linewidth,
+                      linestyle=a.linestyle, stroke_opacity=a.alpha,
+                      stroke_round=True, series_id=f"s{ai}_{k}", label=lbl)])
+        if a.marker:
+            # Reuses the exact same constant-pixel-size Markers primitive
+            # scatter() already draws with -- a line's own markers are just
+            # a dot at each vertex, no new rendering needed in either
+            # backend. Ordinarily no series_id: these are the same points
+            # the Path above already made pickable, not a second series of
+            # their own -- except when linestyle="none" omitted that Path
+            # entirely (markers-only), in which case this Markers prim is
+            # the *only* element for the series and has to carry the id
+            # itself, or nothing in the output identifies it as series k.
+            pts = tr.xy(x, y)
+            diam = np.full(x.shape, (a.markersize or 6.0) * size_scale, dtype=float)
+            face = a.markerfacecolor or a.color
+            # One color per point, not one total -- the raster backend zips
+            # colors against points/diameters and silently truncates to
+            # whichever is shortest (see ScatterCollection's own [a.color] *
+            # a.x.size just above, the same reason it does this).
+            prims.append(Markers(
+                pts, diam, [face] * x.size, single_color=True, alpha=a.alpha,
+                label=lbl,
+                series_id=(f"s{ai}_{k}" if a.linestyle == "none" else None)))
+        return prims
+
+    # VLine/HLine/AxLine are pure reference lines -- no marker, no other
+    # geometry -- so linestyle="none" leaves genuinely nothing to draw for
+    # any of the three, the same "omit the prim" fix as Line2D above.
+    if isinstance(a, VLine):
+        if a.linestyle == "none":
+            return []
+        x = float(tr.x(a.x))
+        return [Line((x, tr.px_top), (x, tr.px_top + tr.px_h), a.color,
+                     a.linewidth, a.linestyle, a.alpha, lbl)]
+
+    if isinstance(a, HLine):
+        if a.linestyle == "none":
+            return []
+        y = float(tr.y(a.y))
+        return [Line((tr.px_left, y), (tr.px_left + tr.px_w, y), a.color,
+                     a.linewidth, a.linestyle, a.alpha, lbl)]
+
+    if isinstance(a, AxLine):
+        if a.linestyle == "none":
+            return []
+        if not np.isfinite(a.slope):
+            x = float(tr.x(a.x1))
+            p0, p1 = (x, tr.px_top), (x, tr.px_top + tr.px_h)
+        else:
+            xmin, xmax = tr.xmin, tr.xmax
+            y0 = a.y1 + a.slope * (xmin - a.x1)
+            y1 = a.y1 + a.slope * (xmax - a.x1)
+            p0 = (float(tr.x(xmin)), float(tr.y(y0)))
+            p1 = (float(tr.x(xmax)), float(tr.y(y1)))
+        return [Line(p0, p1, a.color, a.linewidth, a.linestyle, a.alpha, lbl)]
+
+    if isinstance(a, Span):
+        if a.orientation == "vertical":
+            p, q = float(tr.x(a.lo)), float(tr.x(a.hi))
+            x, w, yy, h = min(p, q), abs(q - p), tr.px_top, tr.px_h
+        else:
+            p, q = float(tr.y(a.lo)), float(tr.y(a.hi))
+            yy, h, x, w = min(p, q), abs(q - p), tr.px_left, tr.px_w
+        return [Rect(x, yy, w, h, a.color, a.alpha, lbl)]
+
+    if isinstance(a, FillBetween):
+        top = tr.xy(a.x, a.y1)
+        bot = tr.xy(a.x[::-1], a.y2[::-1])
+        pts = np.vstack([top, bot])
+        return [Path(subpaths=[pts], closed=True, fill=a.color,
+                     fill_opacity=a.alpha, stroke=a.edgecolor,
+                     stroke_width=a.linewidth, series_id=f"s{ai}_{k}", label=lbl)]
+
+    if isinstance(a, Polygon):
+        pts = tr.xy(a.x, a.y)
+        return [Path(subpaths=[pts], closed=True, element="polygon",
+                     fill=a.color, fill_opacity=a.alpha,
+                     stroke=a.edgecolor, stroke_width=a.linewidth,
+                     series_id=f"s{ai}_{k}", label=lbl)]
+
+    if isinstance(a, LineCollection):
+        # hlines()/vlines()' own bare segments -- linestyle="none" leaves
+        # nothing to draw, same as the reference-line artists above.
+        if a.linestyle == "none":
+            return []
+        segs = np.column_stack([
+            tr.x(a.segments[:, 0]), tr.y(a.segments[:, 1]),
+            tr.x(a.segments[:, 2]), tr.y(a.segments[:, 3]),
+        ])
+        return [Segments(segs, a.color, a.linewidth, a.linestyle, a.alpha, lbl)]
+
+    if isinstance(a, Rug):
+        n = a.x.size
+        if n == 0:
+            return []
+        # Anchored in pixel space, so the tick length is a fraction of the axes
+        # rather than of the data range.
+        if a.side == "left":
+            y = tr.y(a.x)
+            x0 = np.full(n, tr.px_left)
+            segs = np.column_stack([x0, y, x0 + a.height * tr.px_w, y])
+        else:
+            x = tr.x(a.x)
+            y0 = np.full(n, tr.px_top + tr.px_h)
+            segs = np.column_stack([x, y0, x, y0 - a.height * tr.px_h])
+        return [Segments(segs, a.color, a.linewidth, "-", a.alpha, lbl)]
+
+    if isinstance(a, PolyCollection):
+        polys = [tr.xy(v[:, 0], v[:, 1]) for v in a.verts]
+        return [PolygonBatch(polys, list(a.facecolors), a.edgecolor,
+                             0.4, a.alpha, lbl)]
+
+    if isinstance(a, (QuadMesh, Image)):
+        xmin, xmax, ymin, ymax = a.extent()
+        # Pixel corners of the data extent. On an inverted axis the transform
+        # reverses these, which used to yield a negative width or height --
+        # an error in SVG, so the browser dropped the element and the mesh
+        # simply did not appear. Normalize the rect and mirror the raster to
+        # match, which keeps every pixel over the data it came from.
+        x0, x1 = float(tr.x(xmin)), float(tr.x(xmax))
+        y0, y1 = float(tr.y(ymax)), float(tr.y(ymin))
+        rgba = a.rgba().astype(np.uint8)
+        if x1 < x0:
+            x0, x1 = x1, x0
+            rgba = rgba[:, ::-1]
+        if y1 < y0:
+            y0, y1 = y1, y0
+            rgba = rgba[::-1, :]
+        smooth = getattr(a, "interpolation", "nearest") != "nearest"
+        return [ImagePrim(np.ascontiguousarray(rgba), x0, y0, x1 - x0, y1 - y0, smooth,
+                          label=a.label or "")]
+
+    return None