anyplotlib 0.1.0b1__tar.gz → 0.3.0__tar.gz

{anyplotlib-0.1.0b1 → anyplotlib-0.3.0}/.github/workflows/prepare_release.yml

@@ -11,12 +11,13 @@ on:
         required: true
         type: choice
         options:
+          - finalize      # drop the bN suffix: release the current beta's base as stable (0.3.0b2 -> 0.3.0)
           - minor
           - bugfix
           - major
           - pre-release   # increments the bN counter on the current base version
       beta:
-        description: "Mark as beta pre-release (adds bN suffix; always true for pre-release)"
+        description: "Mark as beta pre-release (adds bN suffix). Ignored for 'pre-release' (always beta) and 'finalize' (always stable)."
         required: false
         type: boolean
         default: false
@@ -67,17 +68,42 @@ jobs:
           minor  = int(m.group(2))
           patch  = int(m.group(3))
           beta_n = int(m.group(4)) if m.group(4) else None
-
-          if bump == "major":
+          on_beta = beta_n is not None
+
+          if bump == "finalize":
+              # Release the current beta's base as stable: just drop the bN
+              # suffix, keep major.minor.patch. e.g. 0.3.0b2 -> 0.3.0.
+              if not on_beta:
+                  raise SystemExit(
+                      f"'finalize' requires a beta base version, but current "
+                      f"version {current!r} has no bN suffix. Use minor / bugfix "
+                      f"/ major to start a new release instead."
+                  )
+              is_beta = False
+          elif bump == "pre-release":
+              # Keep the same base; just walk the beta counter forward.
+              is_beta = True
+              beta_n  = (beta_n or 0) + 1
+          elif on_beta:
+              # We are on a beta of the NEXT release (e.g. 0.3.0b2). The base
+              # major.minor.patch is that upcoming version, so minor/bugfix/major
+              # must bump relative to the LAST STABLE (base - the in-progress
+              # component), not skip a whole version. The common intent from a
+              # beta is 'finalize', so steer the user there rather than guess.
+              raise SystemExit(
+                  f"Current version {current!r} is a beta of the upcoming "
+                  f"{major}.{minor}.{patch} release. To ship it, use bump="
+                  f"'finalize' (-> {major}.{minor}.{patch}). A '{bump}' bump from "
+                  f"a beta would skip {major}.{minor}.{patch} entirely "
+                  f"(e.g. -> {'%d.%d.0' % (major, minor + 1) if bump == 'minor' else '...'}); "
+                  f"that is almost never intended."
+              )
+          elif bump == "major":
               major, minor, patch = major + 1, 0, 0
           elif bump == "minor":
               minor, patch = minor + 1, 0
           elif bump == "bugfix":
               patch += 1
-          elif bump == "pre-release":
-              # Keep the same base; just walk the beta counter forward.
-              is_beta = True
-              beta_n  = (beta_n or 0) + 1
 
           if is_beta:
               if bump != "pre-release":
@@ -88,10 +114,15 @@ jobs:
           PYEOF
           )
 
+          # Derive is_beta from the COMPUTED version (ends in bN?), not the raw
+          # input — so 'finalize' is always treated as stable and a mismatched
+          # beta checkbox can't mislabel the switcher / skip the root redirect.
+          if [[ "$NEW_VERSION" =~ b[0-9]+$ ]]; then IS_BETA_OUT=true; else IS_BETA_OUT=false; fi
+
           echo "new_version=$NEW_VERSION"                  >> "$GITHUB_OUTPUT"
           echo "tag=v$NEW_VERSION"                         >> "$GITHUB_OUTPUT"
           echo "branch=release/v$NEW_VERSION"              >> "$GITHUB_OUTPUT"
-          echo "is_beta=${{ inputs.beta }}"                >> "$GITHUB_OUTPUT"
+          echo "is_beta=$IS_BETA_OUT"                      >> "$GITHUB_OUTPUT"
           echo "Bumping (${{ inputs.bump }}): $CURRENT → $NEW_VERSION"
 
       # ── Bump version strings ─────────────────────────────────────────────
@@ -118,7 +149,7 @@ jobs:
       - name: Update docs/switcher.json
         env:
           VERSION_TAG: ${{ steps.version.outputs.tag }}
-          IS_BETA: ${{ inputs.beta }}
+          IS_BETA: ${{ steps.version.outputs.is_beta }}
         shell: python
         run: |
           import json, re, pathlib, os
@@ -144,7 +175,7 @@ jobs:
 
       # ── Update root redirect for stable releases ─────────────────────────
       - name: Update root redirect (stable releases only)
-        if: ${{ inputs.beta == false && inputs.bump != 'pre-release' }}
+        if: ${{ steps.version.outputs.is_beta == 'false' && inputs.bump != 'pre-release' }}
         env:
           VERSION_TAG: ${{ steps.version.outputs.tag }}
         shell: python
@@ -200,7 +231,7 @@ jobs:
           - Version bumped to \`${TAG}\` in \`pyproject.toml\` and \`docs/conf.py\`
           - \`CHANGELOG.rst\` updated from towncrier fragments
           - \`docs/_root/switcher.json\` updated with the new version entry
-          $([ '${{ inputs.beta }}' = 'false' ] && echo '- Root redirect updated to point to this release' || echo '')
+          $([ '${{ steps.version.outputs.is_beta }}' = 'false' ] && echo '- Root redirect updated to point to this release' || echo '')
 
           ### Review checklist
           - [ ] \`CHANGELOG.rst\` reads well — edit the fragment text directly if needed

{anyplotlib-0.1.0b1 → anyplotlib-0.3.0}/CHANGELOG.rst

@@ -10,6 +10,148 @@ Fragment files in ``upcoming_changes/`` are assembled into this file by
 
 .. towncrier release notes start
 
+0.3.0b1 (2026-07-13)
+====================
+
+New Features
+------------
+
+- Added :class:`~anyplotlib.widgets.ArrowWidget` (draggable arrow overlay, tail
+  at ``(x, y)`` and head at ``(x + u, y + v)``) via ``Plot2D.add_arrow_widget`` /
+  ``add_widget("arrow")``, and a ``show_handles`` option (default ``True``) on
+  every 2-D overlay widget to hide the grab-handle dots without affecting drag.
+- Added figure-level edit-mode chrome to :class:`~anyplotlib.Figure`: the
+  ``edit_chrome`` and ``selected_panel`` traits (per-panel hover / selection
+  outlines), figure-background click events, and a figure-level annotation layer
+  (``set_figure_markers`` / ``figure_markers``, positioned in figure fractions and
+  always included in ``exportPNG``) with figure-level callbacks via
+  ``add_event_handler``.
+- Extended :class:`~anyplotlib.Figure` edit-mode interaction:
+
+  * Circle and rectangle overlay widgets are now **resizable via visible nodes** —
+    a circle draws a centre (move) node and an east-point radius node; a rectangle
+    draws all four corner nodes (opposite corner anchored on drag).  Drawn only
+    when ``show_handles`` is ``True``, with matching resize cursors.
+  * :class:`~anyplotlib.widgets.ArrowWidget` **tail is now a reshape node**:
+    dragging the tail moves it while the head stays anchored (dragging the shaft
+    still moves the whole arrow; the head node still re-aims it).
+  * The selected-panel and hover **outlines are fully inset** (``outline-offset:
+    -2px``) so an edge/corner panel's ring is no longer clipped at the figure's
+    right/bottom edge.
+  * **Panel drag-swap** under ``edit_chrome``: each grid panel shows a move grip
+    in its top-left corner; dragging it over a *different* panel emits a
+    figure-level ``pointer_up`` event with ``panel_swap: true`` and
+    ``source_panel_id`` / ``target_panel_id`` (new :class:`~anyplotlib.Event`
+    fields).  anyplotlib performs no layout change itself — the host swaps and
+    rebuilds.  Releasing on the source panel or empty space cancels cleanly; the
+    grip is inert when ``edit_chrome`` is off.
+  * The JS ``mount()`` embedding entry point accepts an ``onResize({width,
+    height})`` callback, fired (debounced) when the **root container resizes**, so
+    an embedding host can relayout the figure to its new box.
+
+
+0.2.0 (2026-07-10)
+==================
+
+New Features
+------------
+
+- 2-D scalar images can now render on the **GPU via WebGPU** (``imshow(...,
+  gpu="auto"|True|False)``): the image uploads as an R8 texture and a WGSL fragment
+  shader applies the colormap LUT + contrast (clim) in one draw, replacing the
+  per-pixel JavaScript colormap loop. Large images (≳1 megapixel) take the GPU path
+  automatically; everything below the threshold, RGB images, ``gpu=False``, and any
+  device without WebGPU keep the identical Canvas2D path. ``plot.gpu_active`` reports
+  which path ran. Verified on an NVIDIA Pascal GPU.
+- Arbitrarily large images can now display through **tile mode**
+  (``imshow(..., tile="auto")``): the figure shows a downsampled overview as its
+  base and, after each zoom/pan settles, samples a high-resolution detail tile of
+  just the visible region at panel resolution — deep zooms stay crisp without
+  ever shipping the full-resolution frame. ``Plot2D.enable_tile`` /
+  ``update_tile_source`` swap the underlying frame while the zoom and
+  subselection persist (live-data contract), and a pluggable ``TileBackend``
+  (default: a fast vectorised numpy box-mean) lets out-of-core or GPU sources
+  own the sampling.
+- Markers gained a ``clip_display`` option controlling whether they draw
+  outside the current axes view or are clipped to it.
+- ``set_extent`` now updates the axes state (calibrated units / scale bar), so
+  applying a calibrated extent after figure creation renders labelled axes
+  instead of bare pixels.
+- Regular ``pcolormesh`` meshes are detected and rasterized to an image for
+  display (fast IPF-style heatmaps) instead of drawing per-quad.
+
+
+Bug Fixes
+---------
+
+- Fixed a display freeze under the Electron binary pixel transport: the routing
+  layer stripped the pixel key out of the slimmed geom JSON, so the renderer's
+  "unchanged → skip re-upload" caches (Canvas2D blit cache, WebGPU texture,
+  overlay-mask cache) fell back to a 4-sampled-byte fingerprint of the buffer —
+  two frames differing anywhere else collided and the display stayed frozen on
+  the old frame (seen as a stale overview after a movie scrub). The slimmed geom
+  now carries a small ``\x00bin:<checksum>`` content token under the pixel key,
+  binary buffers are additionally stamped with an arrival sequence as a fallback
+  key, and the overlay-mask draw path now reads the binary byte side-channel
+  (it previously only decoded base64, so masks never displayed over the binary
+  transport).
+- Fixed the WebGPU 2-D image path sampling a vertically MIRRORED window when the
+  view was panned off-centre: the shader applied a global ``1 - v`` flip after
+  interpolating the ``[v0, v1]`` uv window, which sampled ``[1-v1, 1-v0]``
+  instead — correct only for a full or vertically-centred view. Symptoms: pan-y
+  moved the image the wrong way on GPU-rendered panels, and markers/widgets
+  (drawn by the shared Canvas2D overlay transform, which was always correct)
+  appeared detached from the image features they marked. The base and
+  detail-tile passes share the shader, so both are fixed. GPU-vs-CPU screenshot
+  parity tests (zoom, pan, markers, widgets, detail tile) now run on real WebGPU
+  in headless Chromium (``channel="chromium"`` + ``--enable-unsafe-webgpu``) and
+  skip on machines with no adapter.
+- ``Plot2D.set_data`` no longer makes a float64 copy of every incoming frame.
+  The float64 cast now happens lazily in the ``.data`` property (the only reader),
+  so a frame stream — e.g. scrubbing an in-situ movie — keeps the source dtype and
+  skips a ~12 ms float64 copy of a 4k frame per tick. ``.data`` still returns a
+  read-only float64 copy, unchanged for callers.
+- The Electron binary pixel transport now ships the RAW uint8 image bytes end to
+  end, instead of base64-encoding them in ``set_data`` only to base64-decode them
+  straight back in the routing layer. ``Plot2D.set_data`` stashes the raw bytes on
+  the Figure's ``_raw_pixels`` side-table and leaves a tiny content-checksum
+  change-token in ``image_b64``; ``_electron._route_change`` ships those bytes to a
+  PLOTBIN frame directly. This removes the ~20 ms base64 encode, the ~17 ms decode,
+  and the megabyte ``json.dumps`` of the pixel string from every scrub frame — a
+  2.2x faster ``set_data`` (≈98 ms → ≈44 ms on a 2048² frame) and ~25% less
+  bytes-on-wire. Non-Electron hosts (Jupyter / Pyodide / standalone / ``save_html``)
+  are unchanged: they have no PLOTBIN channel, so the token is resolved back to
+  inline base64 via ``Plot2D.resolve_pixel_tokens`` when the figure state is
+  serialised for them.
+- Tile mode: a data update while zoomed in (``update_tile_source`` with a detail
+  tile shown) refreshes only the detail tile, leaving the overview base on the
+  old frame — zooming out then flashed the pre-update frame. The skipped
+  overview is now marked stale and re-sampled once on the next view settle
+  (riding the same push as the detail/clear), preserving the per-frame skip
+  optimisation while never exposing stale base pixels.
+- Interactive zoom/pan on a 2-D image no longer re-serialises (and re-transmits)
+  the full image on every mouse tick. The wheel/pan/orbit handlers write only the
+  light *view* state back to the ``panel_<id>_json`` trait now, excluding the
+  cached geometry (pixels, colormap LUT) that ``_applyGeom`` splices into the panel
+  state for drawing. Previously the whole frame was ``JSON.stringify``-d per tick —
+  catastrophically so on the binary transport, where the pixel buffer is a
+  ``Uint8Array`` that stringifies to a ``{"0":..,"1":..}`` object with one key per
+  byte — which stalled zoom on large images.
+- Fixed a first-paint race under the Electron binary transport: binary
+  side-table bytes that arrived before ``render()`` attached its listeners were
+  stranded, leaving the first frame blank until the next update — they are now
+  spliced into the initial paint.
+
+
+Maintenance
+-----------
+
+- ``anyplotlib.__version__`` is now exposed from the package metadata.
+- Per-frame hot-path costs trimmed: the colormap LUT is cached instead of being
+  rebuilt every frame (~100 ms), and small-range data rescales in float32
+  (~60 ms → ~27 ms per 2048² frame).
+
+
 0.1.0 (2026-06-24)
 ==================
 

anyplotlib-0.3.0/Examples/Interactive/plot_figure_annotations.py

@@ -0,0 +1,87 @@
+"""
+Interactive figure annotations — double-click to add, drag to place
+===================================================================
+
+anyplotlib has a *figure-level* annotation layer that floats above the panels,
+positioned in **figure fractions** (0…1, origin top-left) rather than any
+panel's data coordinates.  Set it with
+:meth:`~anyplotlib.Figure.set_figure_markers`; the supported kinds are
+``"text"``, ``"circle"``, ``"rect"`` and ``"arrow"``.
+
+Turn on ``fig.edit_chrome`` and every annotation becomes draggable in the
+browser.  Combine that with a ``double_click`` handler and you get a simple
+annotate-by-clicking workflow: double-click a feature to drop a labelled
+arrow, then drag it to line it up.  Positions round-trip back to Python via
+:attr:`~anyplotlib.Figure.figure_markers`.
+"""
+import numpy as np
+import anyplotlib as apl
+
+rng  = np.random.default_rng(7)
+data = rng.standard_normal((160, 160)).cumsum(0).cumsum(1)
+data = (data - data.min()) / (data.max() - data.min())
+
+fig, ax = apl.subplots(1, 1, figsize=(520, 520))
+v = ax.imshow(data, cmap="magma", units="px")
+
+# Enable the editable-annotation ("report builder") mode so figure markers are
+# hit-testable and draggable, and the figure emits background/marker events.
+fig.edit_chrome = True
+
+# %%
+# Seed a couple of annotations
+# ----------------------------
+# Each marker is a dict with a ``kind`` and fraction-space geometry.  A text
+# label and an arrow pointing into the image to start with.
+
+fig.set_figure_markers([
+    {"kind": "text", "x": 0.5, "y": 0.06,
+     "text": "Double-click a feature to annotate it",
+     "color": "#ffffff", "fontsize": 14},
+    {"kind": "arrow", "x": 0.20, "y": 0.30, "u": 0.12, "v": 0.12,
+     "color": "#ffd54f", "linewidth": 2},
+])
+
+fig
+
+# %%
+# Double-click to drop a new annotation
+# -------------------------------------
+# On a single-panel figure the panel nearly fills the canvas, so we turn the
+# click's device pixels into a figure fraction with the panel's
+# ``display_width`` / ``display_height`` and append an arrow + label there.
+# Because ``edit_chrome`` is on, the new marker is immediately draggable.
+
+
+def _on_double_click(event):
+    if event.x is None or event.display_width is None:
+        return
+    fx = float(np.clip(event.x / event.display_width, 0.02, 0.98))
+    fy = float(np.clip(event.y / event.display_height, 0.02, 0.98))
+    markers = fig.figure_markers            # current list (a copy)
+    n = sum(1 for m in markers if m["kind"] == "text")
+    markers.append({"kind": "arrow", "x": fx, "y": fy,
+                    "u": 0.08, "v": -0.08, "color": "#40c4ff", "linewidth": 2})
+    markers.append({"kind": "text", "x": fx + 0.08, "y": fy - 0.10,
+                    "text": f"mark {n}", "color": "#40c4ff", "fontsize": 13})
+    fig.set_figure_markers(markers)
+
+
+v.add_event_handler(_on_double_click, "double_click")
+
+fig.set_help(
+    "Double-click on the image to drop a labelled arrow.\n"
+    "Drag any annotation to reposition it (edit mode is on)."
+)
+
+fig  # Interactive
+
+# %%
+# Read the placements back
+# ------------------------
+# After the user drags things around, ``fig.figure_markers`` reflects the
+# current fraction positions — persist them, export them, or feed them into a
+# report.
+
+for m in fig.figure_markers:
+    print(m["kind"], round(m["x"], 3), round(m["y"], 3))

{anyplotlib-0.1.0b1 → anyplotlib-0.3.0}/Examples/Interactive/plot_voxel_grain_explorer.py

@@ -29,7 +29,7 @@ import anyplotlib as apl
 rng = np.random.default_rng(11)
 
 # ── 1. Synthetic 3-D polycrystal: nearest-seed voxel grain map ──────────────
-N = 48                       # volume is N³ voxels, indexed V[z, y, x]
+N = 24                       # volume is N³ voxels, indexed V[z, y, x]
 N_GRAINS = 40
 
 seeds = rng.uniform(0, N, size=(N_GRAINS, 3))            # (z, y, x)
@@ -76,7 +76,8 @@ grain_rgb_u8 = (rgb * 255).astype(np.uint8)               # (N_GRAINS, 3)
 # planes.  This anchors the highlight exactly where the slices intersect,
 # shows real slice contents in 3-D, and scales: the on-plane count is
 # ~3·(N/step)² regardless of N, so it stays fast even for a 256³ volume.
-VSTEP = max(1, N // 48)        # in-plane downsample → ~48² cubes per plane
+VSTEP = max(1, N // 48)        # in-plane downsample, capping at ~48² cubes/plane
+                               # for large N (no downsampling at this N=24)
 
 # Voxel cube size in data units.  A touch larger than VSTEP so the three
 # slabs read as solid sheets rather than a dotted grid.
@@ -140,6 +141,8 @@ v_vol = ax_vol.voxels(
     size=VOXSIZE, alpha=0.55,
     x_label="x", y_label="y", z_label="z",
     bounds=((0, N - 1),) * 3, zoom=1.1,
+    # gpu="auto" (default): ~1.7k cubes is over the ~1k voxel threshold, so the
+    # WebGPU instanced path handles each drag re-slice when WebGPU is present.
 )
 v_vol.set_title("Grain volume — drag a plane to re-slice")
 

anyplotlib-0.3.0/Examples/Markers/plot_transform_markers.py

@@ -0,0 +1,49 @@
+"""
+Coordinate transforms — pin markers to the axes or the screen
+=============================================================
+
+Every ``add_*`` marker method takes a ``transform`` that decides which
+coordinate system its positions live in:
+
+- ``"data"`` (default) — data coordinates; the marker moves and scales with
+  zoom / pan, staying glued to the underlying data.
+- ``"axes"`` — axes-normalised ``(0, 0)`` bottom-left … ``(1, 1)`` top-right;
+  the marker stays in the same corner of the panel no matter how you zoom.
+- ``"display"`` — raw CSS pixels within the panel; a fixed-size decoration.
+
+The ``"axes"`` and ``"display"`` transforms are how you build overlays that
+should *not* track the data — a navigation index in the corner, a scale bar, a
+persistent legend chip.
+"""
+import numpy as np
+import anyplotlib as apl
+
+rng  = np.random.default_rng(1)
+data = rng.standard_normal((128, 128)).cumsum(0).cumsum(1)
+data = (data - data.min()) / (data.max() - data.min())
+xy   = np.linspace(0, 10, 128)
+
+fig, ax = apl.subplots(1, 1, figsize=(480, 480))
+v = ax.imshow(data, axes=[xy, xy], units="nm")
+
+# Data-anchored label — sits at (5, 5) in nm and rides along on zoom/pan.
+v.add_texts(offsets=[(5, 5)], texts=["feature @ (5, 5)"],
+            color="#ffffff", fontsize=12, name="data_label")
+
+# Axes-anchored index — stays pinned to the top-left corner of the panel
+# regardless of zoom (0, 1 = top-left in axes fractions).
+v.add_texts(offsets=[(0.04, 0.96)], texts=["frame 3 / 20"],
+            transform="axes", color="#ffd54f", fontsize=13, name="nav_index")
+
+fig
+
+# %%
+# Try it
+# ------
+# Zoom into the image: the white ``feature`` label moves with the data, while
+# the yellow ``frame 3 / 20`` index stays locked to the corner — because it is
+# positioned in ``"axes"`` coordinates.
+
+fig.set_help("Zoom in: the corner index stays put; the data label moves.")
+
+fig  # Interactive

anyplotlib-0.3.0/Examples/PlotTypes/plot_gpu_voxels.py

@@ -0,0 +1,82 @@
+"""
+GPU-accelerated voxels
+======================
+
+:meth:`~anyplotlib.Axes.voxels` renders shaded translucent cubes for a
+volumetric field.  With ``gpu="auto"`` (the default) anyplotlib uses WebGPU
+instancing when a GPU is available and the cube count is large, so hundreds of
+thousands of voxels stay interactive; otherwise it falls back to the Canvas2D
+path.  Read :attr:`~anyplotlib.Plot3D.gpu_active` after the first frame to see
+which path was chosen.
+
+Here we build a dense spherical shell — enough cubes that the WebGPU path
+kicks in — and drop a draggable :class:`~anyplotlib.PlaneWidget` through it as
+a slice selector.
+"""
+import numpy as np
+import anyplotlib as apl
+
+# %%
+# Build a volumetric field
+# ------------------------
+# Voxel *centres* are passed as three flat coordinate arrays (not a dense 3-D
+# grid), so you only send the cubes you actually want drawn.  We keep the
+# voxels inside a spherical shell and colour them by radius.
+
+N = 64
+g = np.arange(N)
+Z, Y, X = np.meshgrid(g, g, g, indexing="ij")
+r = np.sqrt((X - N / 2) ** 2 + (Y - N / 2) ** 2 + (Z - N / 2) ** 2)
+shell = (r > N * 0.30) & (r < N * 0.42)   # a hollow sphere
+
+xs, ys, zs = X[shell], Y[shell], Z[shell]
+print(f"{xs.size:,} voxels")  # tens of thousands → GPU path under gpu='auto'
+
+# Colour by radius with the viridis-ish default cycle mapped through intensity.
+t = (r[shell] - r[shell].min()) / (np.ptp(r[shell]) + 1e-9)
+colors = np.stack([0.2 + 0.8 * t, 0.4 * np.ones_like(t), 1.0 - 0.8 * t], axis=1)
+
+fig, ax = apl.subplots(1, 1, figsize=(560, 520))
+vol = ax.voxels(
+    xs, ys, zs, colors=colors,
+    size=1.0, alpha=0.35,
+    bounds=((0, N - 1),) * 3,
+    azimuth=-55, elevation=28, zoom=1.1,
+    gpu="auto",                 # WebGPU when available, Canvas2D otherwise
+)
+vol.set_title("Spherical shell — drag to rotate, scroll to zoom")
+
+# %%
+# Add a slice-selector plane
+# --------------------------
+# A :class:`~anyplotlib.PlaneWidget` is a draggable axis-aligned plane.  Voxels
+# lying on it render more opaque, so the current slice pops out of the
+# translucent volume.  Drag it along z in the browser, or move it from Python.
+
+plane = vol.add_widget("plane", axis="z", position=N // 2,
+                       color="#40c4ff", alpha=0.18)
+
+
+@plane.add_event_handler("pointer_move")
+def _on_slice(event):
+    # Fires while the plane is dragged; pw.position holds the live slice index.
+    print("slice at z =", round(plane.position, 1))
+
+
+fig.set_help(
+    "Drag: rotate · Scroll: zoom · R: reset view\n"
+    "Drag the blue plane to slide the z-slice through the shell."
+)
+
+fig  # Interactive
+
+# %%
+# Which render path ran?
+# ----------------------
+# ``gpu_active`` is populated once the browser reports back after the first
+# frame.  It is ``True`` when the WebGPU instanced path is live, ``False`` on
+# the Canvas2D fallback, and ``None`` before the first frame (as when this
+# gallery page is built headlessly).  Force a path with ``gpu=True`` /
+# ``gpu=False`` if you need determinism.
+
+print("gpu_active:", vol.gpu_active)

anyplotlib-0.3.0/Examples/PlotTypes/plot_step_and_log.py

@@ -0,0 +1,43 @@
+"""
+Step lines and log-scale spectra
+================================
+
+Two 1-D options that suit spectral data: a **mid-riser step** line (constant
+within each bin, jumping at bin midpoints) via ``linestyle="step-mid"``, and a
+**logarithmic y-axis** via :meth:`~anyplotlib.Axes.semilogy` (or
+``ax.plot(..., yscale="log")``).
+"""
+import numpy as np
+import anyplotlib as apl
+
+# A noisy binned spectrum.
+rng = np.random.default_rng(0)
+energy = np.linspace(0, 20, 60)
+counts = (np.exp(-(energy - 6) ** 2 / 4) * 1000
+          + np.exp(-(energy - 13) ** 2 / 8) * 400
+          + rng.uniform(0, 20, energy.size))
+
+# %%
+# Step line
+# ---------
+# ``linestyle="step-mid"`` draws a horizontal segment centred on each x value
+# with vertical risers between them — the standard way to show histogram-like
+# spectra without implying interpolation between channels.
+
+fig, ax = apl.subplots(1, 1, figsize=(560, 340))
+ax.plot(counts, axes=[energy], color="#4fc3f7",
+        linestyle="step-mid", label="counts")
+
+fig
+
+# %%
+# Log y-axis
+# ----------
+# ``semilogy`` is shorthand for a log y-scale, which brings out the small
+# secondary peak that the linear plot flattens.  Combine it with the step line
+# for a classic spectroscopy view.
+
+fig2, ax2 = apl.subplots(1, 1, figsize=(560, 340))
+ax2.semilogy(counts, axes=[energy], color="#ff7043", linestyle="step-mid")
+
+fig2