anyplotlib 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

anyplotlib/_binary_frame.py

@@ -0,0 +1,78 @@
+"""
+_binary_frame.py — a tiny length-prefixed binary wire format for shipping raw
+image pixels to an Electron host without base64-in-JSON.
+
+Used ONLY by the Electron transport (``_electron.py``); Jupyter / Pyodide /
+standalone keep the base64-in-JSON path untouched. The format is a single
+self-describing frame written to a byte stream (stdout), interleaved with the
+existing text ``PLOTAPP:{json}\\n`` lines:
+
+    PLOTBIN:<header_len>:<payload_len>\\n<header_json_bytes><payload_bytes>
+
+- ``PLOTBIN:`` is the ASCII marker (distinct from ``PLOTAPP:``) so a host reading
+  the raw stream can tell a binary frame from a text line.
+- ``<header_len>`` / ``<payload_len>`` are ASCII decimal byte counts.
+- ``<header_json_bytes>`` is UTF-8 JSON: ``{fig_id, key, ...metadata}`` (dims,
+  dtype, clim — everything the renderer needs EXCEPT the pixels).
+- ``<payload_bytes>`` is the raw payload (e.g. the single-channel uint8 image),
+  exactly ``payload_len`` bytes, NO base64, NO JSON.
+
+Both the Python producer and the JS host use this one definition, so the wire
+format has a single source of truth and can be unit-tested in isolation (the
+producer's ``encode_frame`` round-trips through ``decode_frame`` without any
+Electron / stdout involved).
+"""
+from __future__ import annotations
+
+import json
+
+MARKER = b"PLOTBIN:"
+
+
+def encode_frame(fig_id: str, key: str, header: dict, payload: bytes) -> bytes:
+    """Serialise one binary frame to bytes (marker + lengths + header + payload).
+
+    ``header`` is arbitrary JSON-able metadata; ``fig_id`` and ``key`` are merged
+    in (so the decoder always recovers them). ``payload`` is the raw bytes."""
+    hdr = dict(header or {})
+    hdr["fig_id"] = fig_id
+    hdr["key"] = key
+    hdr_bytes = json.dumps(hdr, default=str).encode("utf-8")
+    prefix = MARKER + f"{len(hdr_bytes)}:{len(payload)}\n".encode("ascii")
+    return prefix + hdr_bytes + bytes(payload)
+
+
+def decode_frame(buf: bytes):
+    """Parse ONE complete frame from ``buf`` (as produced by ``encode_frame``).
+
+    Returns ``(header_dict, payload_bytes, n_consumed)`` where ``n_consumed`` is
+    the number of bytes the frame occupied. Raises ``ValueError`` if ``buf`` does
+    not begin with a complete frame. (A streaming host uses ``parse_prefix`` +
+    incremental reads instead; this is the whole-buffer convenience for tests.)"""
+    if not buf.startswith(MARKER):
+        raise ValueError("not a PLOTBIN frame")
+    nl = buf.find(b"\n")
+    if nl < 0:
+        raise ValueError("incomplete PLOTBIN prefix (no newline)")
+    prefix = buf[len(MARKER):nl].decode("ascii")
+    hdr_len_s, pay_len_s = prefix.split(":")
+    hdr_len, pay_len = int(hdr_len_s), int(pay_len_s)
+    start = nl + 1
+    end_hdr = start + hdr_len
+    end_pay = end_hdr + pay_len
+    if len(buf) < end_pay:
+        raise ValueError("incomplete PLOTBIN frame (truncated body)")
+    header = json.loads(buf[start:end_hdr].decode("utf-8"))
+    payload = buf[end_hdr:end_pay]
+    return header, payload, end_pay
+
+
+def parse_prefix(line: bytes):
+    """Parse a ``PLOTBIN:<hlen>:<plen>`` prefix line (the bytes up to, not
+    including, the newline). Returns ``(header_len, payload_len)``. For a
+    streaming host that reads the prefix line, then exactly ``header_len +
+    payload_len`` more bytes."""
+    if not line.startswith(MARKER):
+        raise ValueError("not a PLOTBIN prefix")
+    hdr_len_s, pay_len_s = line[len(MARKER):].decode("ascii").split(":")
+    return int(hdr_len_s), int(pay_len_s)

anyplotlib/_electron.py

@@ -9,12 +9,109 @@ send interaction events back to Python.
 """
 from __future__ import annotations
 
+import base64
 import json
+import os
 import sys
 import uuid
+import zlib
+
+from anyplotlib._binary_frame import encode_frame
 
 _figures: dict[str, object] = {}   # fig_id -> Figure
 
+# Opt-in binary transport for large image pixels (Electron host only). When on,
+# the big ``image_b64`` / ``overlay_mask_b64`` pixel traits are shipped as a raw
+# PLOTBIN binary frame (no base64, no JSON for the pixels) instead of a giant
+# base64 string in the state_update JSON — the base64 encode + 5.6MB JSON line +
+# JS atob cost ~200 ms/frame on a 4k movie. Off by default (base64 path) so this
+# is zero-risk until the host opts in; SpyDE sets APL_BINARY_TRANSPORT=1.
+_BINARY_TRANSPORT = os.environ.get("APL_BINARY_TRANSPORT") == "1"
+# State keys whose value is a base64 pixel string worth sending as binary.
+# detail_b64 is the zoom DETAIL TILE — it MUST be here too, else with binary
+# transport on its _encode_pixels "\x00bin:<checksum>" token stays in the geom JSON
+# and the real bytes are never shipped, so the renderer can't decode it and the crisp
+# zoom tile never displays (you only ever see the downsampled overview base).
+_BINARY_KEYS = frozenset({"image_b64", "overlay_mask_b64", "detail_b64"})
+
+
+def _route_change(fig_id: str, name: str, value) -> None:
+    """Forward ONE trait change to the host — as a raw PLOTBIN binary frame for a
+    large image pixel trait (when binary transport is enabled), else as a
+    base64-in-JSON ``state_update``. Extracted from the observer so it's unit-
+    testable without a real Figure/stdout."""
+    # Binary fast path: ship large image pixels as a raw PLOTBIN frame (the
+    # renderer rebuilds the bytes from the ArrayBuffer — no atob).
+    #
+    # The pixel keys ride INSIDE a panel geometry trait — ``panel_<pid>_geom`` is
+    # a JSON string ``{"image_b64": <token|b64>, "colormap_data": …, …}`` (see
+    # Figure._push). Two producer modes:
+    #   • RAW (Plot2D.set_data with binary transport): the geom carries a tiny
+    #     ``"\x00bin:<n>"`` change-token, and the real uint8 bytes sit in the
+    #     Figure's ``_raw_pixels`` side-table. We emit those bytes directly —
+    #     NO json-parse of a megabyte string, NO base64 decode. This is the hot
+    #     scrub path (a 4k movie frame every tick).
+    #   • BASE64 (initial __init__ frame / non-set_data pushes / robustness): the
+    #     geom carries a real base64 string, which we decode once here.
+    # Either way the REST of the geom (LUT + flags, small) goes as a normal JSON
+    # state_update with the pixels removed. A bare pixel trait is handled too.
+    if _BINARY_TRANSPORT and isinstance(value, str) and value:
+        if name.startswith("panel_") and name.endswith("_geom"):
+            try:
+                geom = json.loads(value)
+            except Exception:
+                geom = None
+            if isinstance(geom, dict) and any(k in geom for k in _BINARY_KEYS):
+                panel_id = name[len("panel_"):-len("_geom")]
+                fig = _figures.get(fig_id)
+                raw_tbl = getattr(fig, "_raw_pixels", None)
+                sent_binary = False
+                for k in list(geom.keys()):
+                    if k not in _BINARY_KEYS or not isinstance(geom[k], str) or not geom[k]:
+                        continue
+                    raw = None
+                    if geom[k].startswith("\x00bin:") and raw_tbl is not None:
+                        # RAW fast path: bytes are in the side-table (no decode).
+                        raw = raw_tbl.get((panel_id, k))
+                    if raw is None:
+                        # BASE64 path (initial frame / fallback): decode once.
+                        try:
+                            raw = base64.b64decode(geom[k])
+                        except Exception:
+                            continue   # leave it in geom → goes via JSON below
+                    # Replace the pixel value with a small content TOKEN instead of
+                    # popping the key: the renderer's caches (blitCache, GPU
+                    # texture, maskCache) key their "unchanged → skip re-upload"
+                    # checks on this string. Popping it left st.<key> empty in JS,
+                    # whose fallback fingerprint samples only 4 bytes of the
+                    # buffer — two frames differing anywhere else COLLIDED and the
+                    # skip froze the display on the old frame (found: a movie
+                    # overview refresh that only moved a mid-frame feature).
+                    tok = geom[k]
+                    if not tok.startswith("\x00bin:"):
+                        tok = f"\x00bin:{zlib.adler32(raw) & 0xFFFFFFFF}"
+                    geom[k] = tok
+                    # key carries which pixel field; geom= the trait name so the
+                    # renderer routes it back into the right panel state.
+                    emit_binary(fig_id, k,
+                                {"nbytes": len(raw), "geom": name}, raw)
+                    sent_binary = True
+                if sent_binary:
+                    # Send the slimmed geom (LUT etc., pixels removed) as JSON.
+                    emit({"type": "state_update", "fig_id": fig_id, "key": name,
+                          "value": json.dumps(geom)})
+                    return
+        elif name in _BINARY_KEYS:
+            try:
+                raw = base64.b64decode(value)
+                emit_binary(fig_id, name, {"nbytes": len(raw)}, raw)
+                return
+            except Exception:
+                pass   # fall back to the base64-in-JSON path below
+    if isinstance(value, (bytes, bytearray)):
+        value = {"buffer": base64.b64encode(value).decode()}
+    emit({"type": "state_update", "fig_id": fig_id, "key": name, "value": value})
+
 
 def register(fig) -> str:
     """Register *fig* for bidirectional state sync and return its fig_id."""
@@ -22,12 +119,7 @@ def register(fig) -> str:
     _figures[fig_id] = fig
 
     def _on_change(change):
-        name = change["name"]
-        value = change["new"]
-        if isinstance(value, (bytes, bytearray)):
-            import base64
-            value = {"buffer": base64.b64encode(value).decode()}
-        emit({"type": "state_update", "fig_id": fig_id, "key": name, "value": value})
+        _route_change(fig_id, change["name"], change["new"])
 
     for name in fig.traits(sync=True):
         if not name.startswith("_"):
@@ -72,3 +164,25 @@ def dispatch_event(fig_id: str, event_json: str) -> None:
 def emit(obj: dict) -> None:
     sys.stdout.write(f"PLOTAPP:{json.dumps(obj, default=str)}\n")
     sys.stdout.flush()
+
+
+def emit_binary(fig_id: str, key: str, header: dict, payload: bytes) -> None:
+    """Write a raw PLOTBIN binary frame to stdout (pixels, no base64/JSON).
+
+    Goes to the RAW ``sys.stdout.buffer`` so the payload is bytes on the wire; the
+    Electron host demuxes ``PLOTBIN:`` frames from the same stdout stream that
+    carries the text ``PLOTAPP:`` lines. Flushed so the host sees it promptly."""
+    frame = encode_frame(fig_id, key, header, payload)
+    buf = getattr(sys.stdout, "buffer", None)
+    if buf is None:            # no binary stdout (unusual) → base64 fallback
+        emit({"type": "state_update", "fig_id": fig_id, "key": key,
+              "value": base64.b64encode(payload).decode()})
+        return
+    # NOTE: a host that redirects sys.stdout (e.g. SpyDE points sys.stdout at
+    # stderr to keep the protocol channel clean) MUST patch emit_binary to write
+    # to its real protocol stdout — otherwise these bytes go to the wrong stream.
+    # Flush the TEXT stream first so any pending PLOTAPP: line is on the wire
+    # before this binary frame — the host demuxes a single ordered byte stream.
+    sys.stdout.flush()
+    buf.write(frame)
+    buf.flush()

anyplotlib/_repr_utils.py

@@ -207,11 +207,49 @@ import(blobUrl).then(mod => {{
 
 // ── Inbound state updates from parent-page Pyodide ───────────────────────────
 window.addEventListener('message', (e) => {{
-  if (!e.data || e.data.type !== 'awi_state') return;
-  _fromParent = true;
-  model.set(e.data.key, e.data.value);
-  model.save_changes();
-  _fromParent = false;
+  if (!e.data) return;
+  if (e.data.type === 'awi_state') {{
+    _fromParent = true;
+    const _t0 = performance.now();
+    model.set(e.data.key, e.data.value);
+    model.save_changes();
+    if (e.data.key === 'image_b64') {{
+      try {{
+        globalThis.__apl_paint_ms = performance.now() - _t0;
+        globalThis.__apl_paint_n = (globalThis.__apl_paint_n || 0) + 1;
+        globalThis.__apl_paint_kind = 'base64';
+      }} catch (_) {{}}
+    }}
+    _fromParent = false;
+    return;
+  }}
+  // Binary image frame (raw pixels, no base64). Set the bytes under a parallel
+  // `<key>_bytes` trait (a Uint8Array) that the draw path uses directly — no atob.
+  // We also bump the base64 key to a short token so listeners keyed on it still
+  // fire, without carrying the (large) base64 string.
+  if (e.data.type === 'awi_state_binary') {{
+    _fromParent = true;
+    const _t0 = performance.now();
+    const hdr = e.data.header || {{}};
+    const bytes = e.data.buffer instanceof Uint8Array
+      ? e.data.buffer : new Uint8Array(e.data.buffer);
+    // Stash the raw bytes in a global side-table (the anywidget model does NOT
+    // round-trip a Uint8Array set on an ad-hoc trait — model.get returns
+    // undefined), then bump a small TOKEN trait to fire the ESM's change: event,
+    // which reads the bytes from the side-table. Key = "<geom_trait>::<pixelKey>".
+    const slot = (hdr.geom ? hdr.geom : 'fig') + '::' + e.data.key;
+    (globalThis.__apl_pixbytes || (globalThis.__apl_pixbytes = {{}}))[slot] = bytes;
+    model.set(slot, (bytes ? bytes.length : 0) + ':' + (globalThis.__apl_paint_n || 0));
+    model.save_changes();                            // triggers the paint synchronously
+    // Paint-latency telemetry (message receipt → draw done) for the binary path.
+    try {{
+      globalThis.__apl_paint_ms = performance.now() - _t0;
+      globalThis.__apl_paint_n = (globalThis.__apl_paint_n || 0) + 1;
+      globalThis.__apl_paint_kind = 'binary';
+    }} catch (_) {{}}
+    _fromParent = false;
+    return;
+  }}
 }});
 </script>
 </body>

anyplotlib/_utils.py

@@ -6,6 +6,8 @@ Shared low-level utilities used across plot subpackages.
 
 from __future__ import annotations
 
+import functools
+
 import numpy as np
 
 _LINESTYLE_ALIASES: dict[str, str] = {
@@ -79,20 +81,48 @@ def _to_rgba_u8(data: np.ndarray) -> np.ndarray:
     return np.ascontiguousarray(data)
 
 
-def _normalize_image(data: np.ndarray):
-    """Normalise data to uint8, returning (img_u8, vmin, vmax)."""
-    img = data.astype(np.float64, copy=False)
-    vmin = float(np.nanmin(img))
-    vmax = float(np.nanmax(img))
-    if vmax > vmin:
-        buf = np.empty_like(img)
-        np.subtract(img, vmin, out=buf)
-        np.divide(buf, vmax - vmin, out=buf)
-        np.multiply(buf, 255.0, out=buf)
-        img_u8 = buf.astype(np.uint8)
+def _normalize_image(data: np.ndarray, clim: "tuple | None" = None):
+    """Normalise data to uint8, returning (img_u8, vmin, vmax) where vmin/vmax are
+    the QUANTISATION endpoints the 8-bit codes span (the caller stores them as
+    raw_min/raw_max so the renderer can reconstruct each code's value).
+
+    When ``clim=(lo, hi)`` is given, quantise over THAT range instead of the raw
+    data min/max, clipping outliers to 0/255. This is what makes a single hot pixel
+    (or the saturating zero-order beam) NOT crush the real signal: without it the
+    256 codes are stretched across the full data range, so a 60000-count hot pixel
+    over a 0-4000 signal leaves the signal only ~12 distinct codes (≈3.5-bit) before
+    it ever reaches the display window; clipping to the robust display range instead
+    gives the signal the full 256 codes and just saturates the outlier. When no
+    clim is given the behaviour is unchanged (quantise over raw min/max).
+
+    Uses float32 for the rescale when the data range is small enough that float32's
+    ~7 significant digits don't lose low bits (the common case: uint8/uint16 movie
+    frames), else float64. float32 halves the memory bandwidth of the subtract/
+    divide/multiply passes (~60ms → ~27ms on a 2048² frame — this runs every movie
+    frame) with a byte-identical result. vmin/vmax are always returned as full-
+    precision Python floats."""
+    if clim is not None:
+        vmin, vmax = float(clim[0]), float(clim[1])
     else:
-        img_u8 = np.zeros(data.shape, dtype=np.uint8)
-    return img_u8, vmin, vmax
+        vmin = float(np.nanmin(data))
+        vmax = float(np.nanmax(data))
+    if vmax <= vmin:
+        return np.zeros(data.shape, dtype=np.uint8), vmin, vmax
+    # float32 is safe when |values| and the span are within its ~1.6e7 exact-integer
+    # range with headroom; a huge-magnitude float source keeps float64 to avoid
+    # banding. (subtract of two near-equal large float32s loses precision.)
+    span = vmax - vmin
+    use32 = (max(abs(vmin), abs(vmax)) < 1e6) and (span > 1e-6)
+    dt = np.float32 if use32 else np.float64
+    img = data.astype(dt, copy=False)
+    buf = np.empty_like(img)
+    np.subtract(img, dt(vmin), out=buf)
+    np.divide(buf, dt(span), out=buf)
+    np.multiply(buf, dt(255.0), out=buf)
+    # Clip into [0, 255] BEFORE the uint8 cast so out-of-clim values saturate
+    # instead of wrapping (a hot pixel above vmax would otherwise overflow uint8).
+    np.clip(buf, 0.0, 255.0, out=buf)
+    return buf.astype(np.uint8), vmin, vmax
 
 
 # Mapping from common matplotlib colormap names to their nearest colorcet
@@ -115,9 +145,15 @@ _CMAP_ALIASES: dict[str, str] = {
 }
 
 
+@functools.lru_cache(maxsize=64)
 def _build_colormap_lut(name: str) -> list:
     """Return a 256-entry ``[[r, g, b], ...]`` LUT for the named colormap.
 
+    CACHED (lru_cache) — it's a pure function of ``name`` but costs ~100 ms
+    (colorcet lookup + 256 hex parses), and it was being rebuilt on EVERY frame of
+    a movie scrub even though the colormap doesn't change. The returned list is
+    treated as read-only by callers (they JSON-serialise it); do NOT mutate it.
+
     Priority order:
 
     1. **colorcet** — preferred; common matplotlib names are remapped via

anyplotlib/axes/_axes.py

@@ -33,13 +33,18 @@ class Axes:
         self._plot: "Plot1D | Plot2D | None" = None
 
     # ------------------------------------------------------------------
-    def imshow(self, data: np.ndarray,
+    def imshow(self, data,
                axes: list | None = None,
                units: str = "px",
                cmap: str | None = None,
                vmin: float | None = None,
                vmax: float | None = None,
-               origin: str = "upper") -> "Plot2D":
+               origin: str = "upper",
+               gpu: "str | bool" = "auto",
+               tile: "str | bool" = "auto",
+               integration_method: str = "mean",
+               overview_method: str = "mean",
+               tile_backend=None) -> "Plot2D":
         """Attach a 2-D image to this axes cell.
 
         Parameters
@@ -74,7 +79,10 @@ class Axes:
         x_axis = axes[0] if axes and len(axes) > 0 else None
         y_axis = axes[1] if axes and len(axes) > 1 else None
         plot = Plot2D(data, x_axis=x_axis, y_axis=y_axis, units=units,
-                      cmap=cmap, vmin=vmin, vmax=vmax, origin=origin)
+                      cmap=cmap, vmin=vmin, vmax=vmax, origin=origin, gpu=gpu,
+                      tile=tile, integration_method=integration_method,
+                      overview_method=overview_method,
+                      tile_backend=tile_backend)
         self._attach(plot)
         return plot
 

anyplotlib/callbacks.py

@@ -24,7 +24,7 @@ from typing import Any, Callable
 VALID_EVENT_TYPES = frozenset({
     "pointer_down", "pointer_up", "pointer_move", "pointer_settled",
     "pointer_enter", "pointer_leave", "double_click", "wheel",
-    "key_down", "key_up", "close", "*",
+    "key_down", "key_up", "close", "view_changed", "*",
 })
 
 
@@ -79,6 +79,14 @@ class Event:
     # Wheel
     dx: float | None = None
     dy: float | None = None
+    # View (view_changed events — the current zoom/pan viewport)
+    zoom: float | None = None
+    center_x: float | None = None
+    center_y: float | None = None
+    image_width: int | None = None
+    image_height: int | None = None
+    display_width: int | None = None    # panel device px (JS) → tile output resolution
+    display_height: int | None = None
     # Key
     key: str | None = None
     last_widget_id: str | None = None

anyplotlib/figure/_figure.py

@@ -24,6 +24,16 @@ _HERE = pathlib.Path(__file__).parent.parent
 _ESM_SOURCE = (_HERE / "figure_esm.js").read_text(encoding="utf-8")
 
 
+def _binary_wire() -> bool:
+    """True when the Electron binary pixel transport is live, so a pixel
+    change-token in the panel state should stay a token (the real bytes ride
+    PLOTBIN) rather than being resolved to inline base64. Read fresh from the
+    environment — the same gate ``Plot2D._encode_pixels`` uses — so producer and
+    serializer never disagree."""
+    import os
+    return os.environ.get("APL_BINARY_TRANSPORT") == "1"
+
+
 class Figure(anywidget.AnyWidget):
     """Multi-panel interactive figure widget.
 
@@ -124,6 +134,14 @@ class Figure(anywidget.AnyWidget):
         # when its values genuinely change.
         self._geom_rev: dict = {}
         self._geom_last: dict = {}
+        # Raw pixel side-table for the Electron BINARY transport: maps
+        # ``(panel_id, pixel_key)`` → the raw ``bytes`` of the current frame.
+        # When binary transport is active, ``Plot2D.set_data`` stashes the
+        # uint8 image bytes here (and puts a tiny change-token in the geom
+        # field instead of a 5.6 MB base64 string), so ``_electron._route_change``
+        # ships them straight to a PLOTBIN frame with NO base64 encode/decode
+        # and NO megabyte JSON. Empty (and ignored) on every non-Electron path.
+        self._raw_pixels: dict = {}
         with self.hold_trait_notifications():
             self.fig_width     = figsize[0]
             self.fig_height    = figsize[1]
@@ -279,6 +297,14 @@ class Figure(anywidget.AnyWidget):
         state = plot.to_state_dict()
         geom_keys = getattr(plot, "_GEOM_KEYS", None)
         gname = f"panel_{panel_id}_geom"
+        # ``state`` may carry a ``"\x00bin:…"`` pixel change-token (binary
+        # transport: the real bytes ride PLOTBIN via ``_route_change``). Keep
+        # the token when that channel is live; otherwise — a standalone /
+        # save_html / Jupyter figure with no binary channel — materialise the
+        # real base64 inline so the pixels actually travel. ``_binary_wire``
+        # matches the producer's gate (``Plot2D._encode_pixels``).
+        if geom_keys and not _binary_wire() and hasattr(plot, "resolve_pixel_tokens"):
+            plot.resolve_pixel_tokens(state)
         if geom_keys and self.has_trait(gname):
             # Split heavy geometry into its own channel.  Detect change by
             # comparing the geom values themselves (the b64 strings / LUT
@@ -501,8 +527,21 @@ class Figure(anywidget.AnyWidget):
 
         plot = self._plots_map.get(panel_id)
         if plot is None:
+            if event_type == "view_changed":
+                import logging
+                # WARNING so SpyDE's log stream forwards it (it drops non-spyde.* INFO).
+                logging.getLogger("anyplotlib.tile").warning(
+                    "[TILE] view_changed for UNKNOWN panel %r (have %r) — dropped",
+                    panel_id, list(self._plots_map.keys()))
             return
 
+        if event_type == "view_changed":
+            import logging
+            logging.getLogger("anyplotlib.tile").warning(
+                "[TILE] view_changed RECEIVED panel=%s zoom=%s center=(%s,%s) disp=(%s,%s)",
+                panel_id, msg.get("zoom"), msg.get("center_x"), msg.get("center_y"),
+                msg.get("display_width"), msg.get("display_height"))
+
         # GPU activation status echo (WebGPU path) — not a user event.
         if event_type == "gpu_status":
             if hasattr(plot, "_set_gpu_active"):
@@ -537,6 +576,13 @@ class Figure(anywidget.AnyWidget):
                 group_index=msg.get("group_index"),
                 dx=msg.get("dx"),
                 dy=msg.get("dy"),
+                zoom=msg.get("zoom"),
+                center_x=msg.get("center_x"),
+                center_y=msg.get("center_y"),
+                image_width=msg.get("image_width"),
+                image_height=msg.get("image_height"),
+                display_width=msg.get("display_width"),
+                display_height=msg.get("display_height"),
                 key=msg.get("key"),
                 last_widget_id=msg.get("last_widget_id"),
             )