anyplotlib 0.7.2__py3-none-any.whl → 0.8.0__py3-none-any.whl

anyplotlib/figure_esm.js

@@ -2415,10 +2415,31 @@ function render({ model, el, onResize }) {
     };
   }
 
+  // The quantisation band the uint8 image bytes were encoded over, as [lo, hi].
+  // A DEGENERATE band (raw_max <= raw_min) means DIFFERENT things on the two
+  // encoder paths, and the LUT has to read it the way the bytes were written:
+  //
+  //   plain (_normalize_image): a constant frame quantises to ALL-ZERO bytes and
+  //     reports (c, c) — the band NAMES the single value code 0 stands for, and
+  //     hMin + raw/255 * (range||1) reconstructs it. Keep honouring it.
+  //   tile (_tile_quant_clim): a degenerate band is treated as UNSET and the
+  //     bytes are quantised over the DISPLAY window instead — so they are already
+  //     display-mapped and the LUT must be the identity window over them.
+  //
+  // Reading a tiled degenerate band the plain way is GH #60: a plot that entered
+  // tile mode on a flat placeholder carries the band (0, 0), every code maps to
+  // hMin + raw/255 * 1 in [0, 1], lands below any sane display floor, and the
+  // panel renders solid black beside perfectly healthy stats.
+  function _rawBand(st) {
+    const lo=st.raw_min, hi=st.raw_max;
+    if(lo==null||hi==null) return [st.display_min, st.display_max];
+    if(hi>lo) return [lo,hi];
+    return st.tile_enabled ? [st.display_min, st.display_max] : [lo,hi];
+  }
+
   function _buildLut32(st) {
     const dMin=st.display_min, dMax=st.display_max;
-    const hMin=st.raw_min!=null?st.raw_min:dMin;
-    const hMax=st.raw_max!=null?st.raw_max:dMax;
+    const [hMin,hMax]=_rawBand(st);
     const mode=st.scale_mode||'linear';
     const range=hMax-hMin||1;
     const cmapData=st.colormap_data||[];
@@ -3198,8 +3219,7 @@ function render({ model, el, onResize }) {
 
     // display_min / display_max tick marks
     const dMin=st.display_min, dMax=st.display_max;
-    const hMin=st.raw_min!=null?st.raw_min:dMin;
-    const hMax=st.raw_max!=null?st.raw_max:dMax;
+    const [hMin,hMax]=_rawBand(st);
     const vRange=(hMax-hMin)||1;
     function _vToY(v){return imgH-1-((v-hMin)/vRange)*(imgH-1);}
     ctx.strokeStyle='rgba(255,255,255,0.85)'; ctx.lineWidth=1.5;
@@ -8182,7 +8202,13 @@ fn fs(in : VsOut) -> @location(0) vec4<f32> {
         // outer radius handle
         if (Math.hypot(mx - (ccx + cr), my - ccy) <= HR)
           return { idx:i, mode:'resize_r', snapW:{...w}, startMX:mx, startMY:my };
-        // body (inside ring ± tolerance)
+        // body (inside ring ± tolerance). `lock_center` refuses the grab
+        // outright rather than letting the drag run and correcting afterwards:
+        // a centre snapped back on release still tracks the cursor for the
+        // whole drag, which reads as a broken lock. Refusing here also leaves
+        // the hover cursor at 'default' and lets the drag fall through to the
+        // plot's own pan, so the ring is simply not a handle any more.
+        if (w.lock_center) continue;
         if (Math.abs(Math.hypot(mx-ccx, my-ccy) - cr) <= Math.max(HR, cr*0.18) ||
             Math.hypot(mx-ccx, my-ccy) <= HR)
           return { idx:i, mode:'move', snapW:{...w}, startMX:mx, startMY:my };
@@ -8441,7 +8467,9 @@ fn fs(in : VsOut) -> @location(0) vec4<f32> {
     }
 
     if (w.type === 'circle') {
-      if (d.mode === 'move') {
+      // A drag already in flight when `lock_center` is turned on must not keep
+      // translating the widget: the hit-test gate only runs at grab time.
+      if (d.mode === 'move' && !w.lock_center) {
         w.cx = s.cx + dix; w.cy = s.cy + diy;
       } else if (d.mode === 'resize_r') {
         // distance from centre in image-px

anyplotlib/plot2d/_plot2d.py

@@ -507,11 +507,7 @@ class Plot2D(_BasePlot, _PanelMixin, _MarkerMixin):
         # (raw_min/raw_max fixed, display_min/display_max move) with NO pixel re-encode
         # or re-transfer — set_clim just moves the display window (see set_clim). Set
         # once from the full-res range; keep any existing band on a re-enable.
-        if (self._state.get("raw_min") is None
-                or not (self._state.get("raw_max", 0) > self._state.get("raw_min", 0))):
-            rng = self._backend_display_range(self._tile_backend)
-            if rng is not None:
-                self._state["raw_min"], self._state["raw_max"] = rng
+        self._ensure_tile_band()
         _was_on = self._tile_on
         if not self._tile_on:
             self._tile_on = True
@@ -561,6 +557,13 @@ class Plot2D(_BasePlot, _PanelMixin, _MarkerMixin):
             setter = getattr(self._tile_backend, "set_array", None)
             if setter is not None:
                 setter(array)
+        # The quantisation band is derived ONCE (enable_tile) and then held fixed, so
+        # a contrast change re-windows in the LUT with no pixel re-encode. But if it
+        # was never VALIDLY derived — tile mode started on a flat placeholder, so the
+        # probe refused and the band stayed degenerate — the new data in the backend
+        # is the first chance to get it right. Must run BEFORE the overview/detail are
+        # re-sampled below so they quantise over the corrected band in the SAME push.
+        self._ensure_tile_band()
         reg = self._state.get("detail_region") or []
         has_detail = len(reg) == 4
         # Refresh the overview base ONLY when no detail tile is shown (zoomed out) —
@@ -622,6 +625,70 @@ class Plot2D(_BasePlot, _PanelMixin, _MarkerMixin):
         except Exception as e:
             _TLOG.warning("[TILEDBG] overview refresh FAILED: %s", e)
 
+    def _ensure_tile_band(self) -> bool:
+        """Derive the fixed quantisation band (raw_min/raw_max) from the CURRENT tile
+        backend when it is unset or DEGENERATE, by the same rule _tile_quant_clim
+        uses to read it back. Returns True iff the band was (re-)derived.
+
+        The degenerate case is the one that bites: a plot that entered tile mode on a
+        flat placeholder (e.g. zeros before real data exists) probes a range of
+        (0, 0) — _backend_display_range refuses it, so the band keeps the
+        constructor's raw min/max, which for zeros is also (0, 0). Every later
+        set_data then re-sampled the overview against a band the encoder treated as
+        unset (quantising over the display window) while the frontend LUT honoured
+        (0, 0) literally and painted the panel solid black. Calling this on each data
+        swap re-derives the band as soon as a frame with real range arrives, so the
+        two ends of the protocol agree on what the bytes mean.
+        """
+        lo, hi = self._state.get("raw_min"), self._state.get("raw_max")
+        if lo is not None and hi is not None and hi > lo:
+            return False                      # a valid band is kept, never re-derived
+        if self._tile_backend is None:
+            return False
+        rng = self._backend_display_range(self._tile_backend)
+        if rng is None:
+            # Still flat (an all-constant frame): leave the band unset/degenerate —
+            # _tile_quant_clim and the JS LUT both fall back to the display window.
+            return False
+        self._state["raw_min"], self._state["raw_max"] = rng
+        _TLOG.debug("[TILEDBG] tile band (re-)derived from backend → raw=(%s,%s)",
+                    *rng)
+        return True
+
+    def set_tile_band(self, vmin: float, vmax: float) -> None:
+        """PIN the fixed quantisation band the tile bytes are encoded over.
+
+        Tile mode normally derives this band once, from the full-res data (see
+        ``enable_tile``), and then holds it: a contrast change re-windows in the LUT
+        with no pixel re-encode or re-transfer. A live consumer that already KNOWS the
+        honest range — a camera's bit depth, a detector's saturation point — can pin
+        it here instead of letting the first frame decide, so the contrast doesn't
+        shift when a later frame happens to contain a brighter pixel.
+
+        Pinning also survives what auto-derivation cannot: a source whose first frames
+        are flat (a placeholder, a closed shutter) has no range to derive from, and
+        the band stays unset until a frame with real content arrives.
+
+        Re-samples the overview (and any active detail tile) over the new band in a
+        single push, so the pixels and the band the renderer reads them with never
+        disagree. Raises if the plot is not in tile mode or the range is degenerate."""
+        if not self._tile_on:
+            raise RuntimeError(
+                "set_tile_band requires tile mode — the band is the quantisation "
+                "range for the TILE bytes. Call enable_tile() first (or use "
+                "set_clim() to change the display window on a plain plot).")
+        lo, hi = float(vmin), float(vmax)
+        if not (hi > lo):
+            raise ValueError(
+                f"set_tile_band requires vmax > vmin, got ({lo}, {hi}). A degenerate "
+                f"band is what 'unset' means here — both the encoder and the "
+                f"renderer then fall back to the display window.")
+        self._state["raw_min"], self._state["raw_max"] = lo, hi
+        # Re-encode over the new band. update_tile_source() with no array re-samples
+        # from the backend in place (keeping zoom/center and the detail region) and
+        # pushes — so the band and the bytes it describes ship together.
+        self.update_tile_source()
+
     def _tile_quant_clim(self):
         """The FIXED quantisation band (raw_min/raw_max) the tile bytes are encoded
         over, so a contrast change re-windows in the LUT without re-encoding pixels.
@@ -1470,7 +1537,11 @@ class Plot2D(_BasePlot, _PanelMixin, _MarkerMixin):
         raw frame, not merely re-windowing the existing codes (which are saturated
         outside the previous band and so couldn't widen past it). For an RGB frame
         (no scalar quantisation) or when no raw frame is cached, fall back to a pure
-        display-window update."""
+        display-window update.
+
+        See :meth:`set_display_window` for the non-destructive counterpart — the
+        one to reach for when the pixels must not move (a tiled plot, or a
+        serialised figure being re-windowed with no Python behind it)."""
         new_min = float(vmin) if vmin is not None else self._state.get("display_min")
         new_max = float(vmax) if vmax is not None else self._state.get("display_max")
 
@@ -1512,6 +1583,40 @@ class Plot2D(_BasePlot, _PanelMixin, _MarkerMixin):
             self._state["display_max"] = float(vmax)
         self._push()
 
+    def set_display_window(self, vmin=None, vmax=None) -> None:
+        """Move the display window WITHOUT re-quantising the pixels.
+
+        The non-destructive counterpart to :meth:`set_clim`. Both change the
+        contrast; they differ in what they do to the data behind it:
+
+        ``set_clim``
+            re-encodes the cached raw frame over the new range, so the codes
+            always span exactly the visible band — maximum precision for what is
+            on screen, but the pixels are re-encoded and re-sent, and the old
+            band is gone.
+        ``set_display_window``
+            leaves the codes and their ``raw_min``/``raw_max`` band alone and
+            moves only the window the LUT maps through it. Nothing is re-encoded
+            and nothing travels but two floats.
+
+        Use it when the pixels must stay put: a tiled plot, where re-quantising
+        would re-encode the full-res frame on every drag tick (``set_clim``
+        already routes there internally), or a figure that has been serialised
+        and is being re-windowed with no Python behind it — which is how a saved
+        page gets a working contrast control at all.
+
+        The trade is precision. Quantisation spans ``[raw_min, raw_max]``, so a
+        window much narrower than that band resolves in coarse steps, and one
+        WIDER than it recovers nothing: values outside the band were saturated
+        to 0/255 when the frame was encoded. Quantise over the range you want to
+        be able to reach.
+        """
+        if vmin is not None:
+            self._state["display_min"] = float(vmin)
+        if vmax is not None:
+            self._state["display_max"] = float(vmax)
+        self._push()
+
     def set_detail(self, tile=None, x0=None, x1=None, y0=None, y1=None) -> None:
         """Upload a HIGH-RES detail tile covering the LOGICAL image-pixel rectangle
         ``[x0:x1, y0:y1]`` of the base image (in the SAME orientation as the frame
@@ -1731,15 +1836,24 @@ class Plot2D(_BasePlot, _PanelMixin, _MarkerMixin):
     def add_circle_widget(self, cx: float | None = None, cy: float | None = None,
                           r: float | None = None, color: str = "#00e5ff",
                           linewidth: float = 2,
-                          show_handles: bool = True) -> CircleWidget:
-        """Add a draggable circle overlay."""
+                          show_handles: bool = True,
+                          lock_center: bool = False) -> CircleWidget:
+        """Add a draggable circle overlay.
+
+        ``lock_center`` pins the centre and leaves only the radius draggable —
+        a grab on the ring body is refused and pans the plot instead. Use it
+        when the centre is fixed by the data (a ring on a power spectrum is
+        centred on the DC term), so it cannot be nudged off and silently
+        corrupt every radius measured from it.
+        """
         iw, ih = self._state["image_width"], self._state["image_height"]
         widget = CircleWidget(lambda: None,
                               cx=float(cx) if cx is not None else iw / 2,
                               cy=float(cy) if cy is not None else ih / 2,
                               r=float(r) if r is not None else iw * 0.1,
                               color=color, linewidth=linewidth,
-                              show_handles=show_handles)
+                              show_handles=show_handles,
+                              lock_center=lock_center)
         widget._push_fn = self._make_widget_push_fn(widget)
         self._widgets[widget.id] = widget
         self._push()

anyplotlib/widgets/_widgets2d.py

@@ -74,13 +74,29 @@ class CircleWidget(Widget):
         Outline stroke width in px. Default 2.
     show_handles : bool, optional
         Draw the radius grab handle. Default ``True``.
+    lock_center : bool, optional
+        Pin ``cx, cy`` and let only the radius change. Default ``False``.
+
+        The centre is refused at HIT-TEST time, not corrected afterwards: a
+        grab on the ring body is simply not a widget grab, so it falls through
+        to the plot's own pan and the hover cursor never promises a move.
+        Enforcing it from Python instead — snapping the centre back when the
+        drag settles — cannot work, because the JS drag recomputes the position
+        from its own grab-time snapshot on every frame; the ring tracks the
+        cursor for the whole drag and only jumps back on release.
+
+        Use it when the centre is not a free parameter — a ring on a power
+        spectrum is centred on the DC term, so a draggable centre is a control
+        that can only ever be wrong, and one nudged off-centre silently
+        corrupts every radius measured from it.
     """
     def __init__(self, push_fn, *, cx, cy, r, color="#00e5ff",
-                 linewidth=2, show_handles=True):
+                 linewidth=2, show_handles=True, lock_center=False):
         super().__init__("circle", push_fn,
                          cx=float(cx), cy=float(cy), r=float(r), color=color,
                          linewidth=float(linewidth),
-                         show_handles=bool(show_handles))
+                         show_handles=bool(show_handles),
+                         lock_center=bool(lock_center))
 
 
 class AnnularWidget(Widget):

{anyplotlib-0.7.2.dist-info → anyplotlib-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: anyplotlib
-Version: 0.7.2
+Version: 0.8.0
 Summary: A plotting library using python, javascript and anywidget for performant in browser plotting.
 Project-URL: Homepage, https://cssfrancis.github.io/anyplotlib/
 Project-URL: Repository, https://github.com/CSSFrancis/anyplotlib

{anyplotlib-0.7.2.dist-info → anyplotlib-0.8.0.dist-info}/RECORD

@@ -6,7 +6,7 @@ anyplotlib/_repr_utils.py,sha256=DZM2mTTX7lpg9LaqHjOVNvnYSVRKNaKrJvEYBmdQ5A4,191
 anyplotlib/_utils.py,sha256=fvkMnNiCljG11p6Fsn2engKzsYhI1ILcZE5wog5Rcu0,14584
 anyplotlib/callbacks.py,sha256=lTmL-UYPN6y0VY82MqDKSMTqBgUgezbSM7SoP8t5s0o,14620
 anyplotlib/embed.py,sha256=cSDgjRSwqaJb6OvuJ5g3QFlNg0k0EEQH48VtVaR0K_I,7389
-anyplotlib/figure_esm.js,sha256=bPU56QCD5lA0Ut_kjvWV79PeX9g4ABbrO5kMyTtjWEY,477090
+anyplotlib/figure_esm.js,sha256=j05Ksuz6fC9ZfnjdHbdoLDZOqsxiKXPUwoHHBvK6oNE,478865
 anyplotlib/keys.py,sha256=nmzrppnuuh3K-JYV6rsat-MGWiaZxfJjO-IDN8Ruzdo,9307
 anyplotlib/markers.py,sha256=e6r2t8lFs9c5OjkxeRsV1Le34G7icJRgO2ciPx3e5nM,26870
 anyplotlib/axes/__init__.py,sha256=vsMU_WjFcha17Xozxe7v4_oYQ_6qatk8GZlbwKm-cAc,186
@@ -21,7 +21,7 @@ anyplotlib/plot1d/_plot1d.py,sha256=H0bK4ThKV-3haxs0ish48Ye65M-K9KRNwzoFRNTXjso,
 anyplotlib/plot1d/_plotbar.py,sha256=2hbj3I86TJr5Zds4a179iNQ9CyQTG8ys9MqY8xBTX_Y,17356
 anyplotlib/plot2d/__init__.py,sha256=_BVLJeGKuTmlZPpfPW2d99qRamBvOSyx3hsru7ylTzk,264
 anyplotlib/plot2d/_layer.py,sha256=gONf5R2bYsf_Oymx3Y0RmPrTvFDzVnbDGBKFWkhyAKM,5598
-anyplotlib/plot2d/_plot2d.py,sha256=w1p0eIm_MQnacBZsvZ5yKV9YpR3ybM0qH-aHHwH-7Rc,119353
+anyplotlib/plot2d/_plot2d.py,sha256=522xsJWhx5_ygKa1mRNaoAs4rF4mMsbLwzsXuZAggHs,125937
 anyplotlib/plot2d/_plotmesh.py,sha256=qXOsiQQ13yhPar5KToAIz02sqivdKz3eXcHI7QZsv04,4547
 anyplotlib/plot2d/_tile_backend.py,sha256=BfJ0X-AbWJvImeNcBW9PzkO3b-JQ_CDBP3vOfdNocOw,7225
 anyplotlib/plot3d/__init__.py,sha256=m851XQKGzx5bywIbBK0qntBxzJU7zwxqf6xnOQ8pD1M,138
@@ -38,9 +38,9 @@ anyplotlib/sphinx_anywidget/static/anywidget_overlay.css,sha256=TlIWo4OUsEZFNROH
 anyplotlib/widgets/__init__.py,sha256=uzGX0R_X4xw8c2MJTGPBeaoOucJznWN1Vzcj2YNRGG8,723
 anyplotlib/widgets/_base.py,sha256=WMY_s_KKNVpd-3VceAwZeY5JHhtvJp1nuVbYkmqNiBw,9512
 anyplotlib/widgets/_widgets1d.py,sha256=SXnBDm25th1u9lPHlpQIdVACaQcVCvKUeF-ZJ9VMeVs,7784
-anyplotlib/widgets/_widgets2d.py,sha256=XZmqmgRq7g0P2-xkC2hMRPfZFtq8t-nfjbRc7w2wIXA,19938
+anyplotlib/widgets/_widgets2d.py,sha256=mP0m6yA4cSB2hD71AVpik_FwUHzPCiLYBfju21G5DWk,20930
 anyplotlib/widgets/_widgets3d.py,sha256=zRd2q5O2KePxU5raCnvO-LatMlpGQjnDMPhG61d40Ks,1638
-anyplotlib-0.7.2.dist-info/METADATA,sha256=IyT9uH8qJxx6r-0zp3yeeayG9yBxI0B3DXk9rfImZY0,7163
-anyplotlib-0.7.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-anyplotlib-0.7.2.dist-info/licenses/LICENSE,sha256=NonSXCjWxcYbaMxPnkgFzPpP0bVBTwUDpuDKyKC2uvQ,1071
-anyplotlib-0.7.2.dist-info/RECORD,,
+anyplotlib-0.8.0.dist-info/METADATA,sha256=aePD0Ago3czgs60CU-Fu5D8vUVC9Jw0YXQ-nBeaF5pE,7163
+anyplotlib-0.8.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+anyplotlib-0.8.0.dist-info/licenses/LICENSE,sha256=NonSXCjWxcYbaMxPnkgFzPpP0bVBTwUDpuDKyKC2uvQ,1071
+anyplotlib-0.8.0.dist-info/RECORD,,

{anyplotlib-0.7.2.dist-info → anyplotlib-0.8.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.31.0
+Generator: hatchling 1.32.0
 Root-Is-Purelib: true
 Tag: py3-none-any