anyplotlib 0.4.0__tar.gz → 0.4.2__tar.gz

{anyplotlib-0.4.0 → anyplotlib-0.4.2}/CHANGELOG.rst

@@ -10,6 +10,37 @@ Fragment files in ``upcoming_changes/`` are assembled into this file by
 
 .. towncrier release notes start
 
+0.4.1 (2026-07-26)
+==================
+
+New Features
+------------
+
+- Added ``max_extent=`` to :class:`~anyplotlib.widgets.RangeWidget` and
+  :class:`~anyplotlib.widgets.RectangleWidget` (and the matching
+  ``add_range_widget`` / ``add_rectangle_widget`` factories) — a size cap enforced
+  *while dragging*, so the widget physically stops growing instead of being
+  clamped after the fact. The dragged edge/corner pins and the opposite one stays
+  put, so the selection never jumps under the cursor. ``RangeWidget`` takes a span
+  width in data units; ``RectangleWidget`` takes a scalar (both axes) or a
+  ``(max_w, max_h)`` pair. Default ``None`` leaves widgets unbounded.
+
+  Use it when a widget's size drives real downstream work — e.g. an integrating
+  selector whose span is a number of frames to read.
+
+
+Bug Fixes
+---------
+
+- Fixed the band-style :class:`~anyplotlib.widgets.RangeWidget` being impossible
+  to drag by its body when narrow. Each edge claimed a fixed ±12 px grab zone, so
+  a band under ~24 px wide on screen (routine when zoomed out, or when its span is
+  capped) had no grabbable middle: aiming at the body to translate the band caught
+  an edge and resized it instead. Each edge now takes at most a third of the
+  band's width, leaving the middle third for the move handle. Wide bands are
+  unaffected.
+
+
 0.4.0 (2026-07-18)
 ==================
 

{anyplotlib-0.4.0 → anyplotlib-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anyplotlib
-Version: 0.4.0
+Version: 0.4.2
 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.4.0 → anyplotlib-0.4.2}/anyplotlib/figure_esm.js

@@ -3185,6 +3185,15 @@ function render({ model, el, onResize }) {
         const [rx,ry]=_imgToCanvas2d(w.x,w.y,st,imgW,imgH);
         const rw=w.w*scale, rh=w.h*scale;
         ovCtx.strokeRect(rx,ry,rw,rh);
+        // Canvas-space geometry readback for Playwright (same role as
+        // window._aplTiming). A test cannot derive a handle's page position from
+        // figure padding: the image->canvas mapping depends on the zoom/extent
+        // state, and the grab radius is only HR px — so a hard-coded corner
+        // silently grabs the BODY instead, and a resize test then asserts
+        // nothing. Publishing the drawn corners lets a test aim at a real handle.
+        if(!window._aplWidgetGeom) window._aplWidgetGeom={};
+        if(!window._aplWidgetGeom[p.id]) window._aplWidgetGeom[p.id]={};
+        window._aplWidgetGeom[p.id][w.id]={type:'rectangle',rx,ry,rw,rh};
         if(_handles){
           _drawHandle2d(ovCtx,rx,ry,w.color);_drawHandle2d(ovCtx,rx+rw,ry,w.color);
           _drawHandle2d(ovCtx,rx,ry+rh,w.color);_drawHandle2d(ovCtx,rx+rw,ry+rh,w.color);
@@ -7214,22 +7223,28 @@ fn fs(in : VsOut) -> @location(0) vec4<f32> {
         w.r_inner = newR;
       }
     } else if (w.type === 'rectangle') {
+      // max_w / max_h cap the rectangle DURING the drag, so it physically stops
+      // growing rather than being silently clamped afterwards. Each branch pins
+      // the size and leaves the OPPOSITE corner where it is, so the anchor never
+      // shifts and the rectangle cannot jump out from under the cursor.
+      const capW = (v) => (w.max_w == null ? v : Math.min(v, w.max_w));
+      const capH = (v) => (w.max_h == null ? v : Math.min(v, w.max_h));
       if (d.mode === 'move') {
         w.x = s.x + dix; w.y = s.y + diy;
       } else if (d.mode === 'resize_br') {
-        w.w = Math.max(1, s.w + dix); w.h = Math.max(1, s.h + diy);
+        w.w = capW(Math.max(1, s.w + dix)); w.h = capH(Math.max(1, s.h + diy));
       } else if (d.mode === 'resize_bl') {
-        const newW = Math.max(1, s.w - dix);
+        const newW = capW(Math.max(1, s.w - dix));
         w.x = s.x + (s.w - newW); w.w = newW;
-        w.h = Math.max(1, s.h + diy);
+        w.h = capH(Math.max(1, s.h + diy));
       } else if (d.mode === 'resize_tr') {
-        w.w = Math.max(1, s.w + dix);
-        const newH = Math.max(1, s.h - diy);
+        w.w = capW(Math.max(1, s.w + dix));
+        const newH = capH(Math.max(1, s.h - diy));
         w.y = s.y + (s.h - newH); w.h = newH;
       } else if (d.mode === 'resize_tl') {
-        const newW = Math.max(1, s.w - dix);
+        const newW = capW(Math.max(1, s.w - dix));
         w.x = s.x + (s.w - newW); w.w = newW;
-        const newH = Math.max(1, s.h - diy);
+        const newH = capH(Math.max(1, s.h - diy));
         w.y = s.y + (s.h - newH); w.h = newH;
       }
     } else if (w.type === 'crosshair') {
@@ -7307,9 +7322,16 @@ fn fs(in : VsOut) -> @location(0) vec4<f32> {
           if(Math.hypot(mx-px1b,my-pyHalf)<=HR+5)
             return{idx:i,mode:'edge1',wtype:'range',startMX:mx,snapW:{...w}};
         } else {
-          if(Math.abs(mx-px0)<=HR+5) return{idx:i,mode:'edge0',wtype:'range',startMX:mx,snapW:{...w}};
-          if(Math.abs(mx-px1b)<=HR+5) return{idx:i,mode:'edge1',wtype:'range',startMX:mx,snapW:{...w}};
+          // Band style. The edge grab zones are ±(HR+5)=12 px each, so on a
+          // NARROW band (< ~24 px on screen — routine when the span is capped, or
+          // just zoomed out) the two zones meet and swallow the body: the user
+          // aims at the middle to translate the band and gets an edge resize
+          // instead. Give each edge at most a THIRD of the band, so the middle
+          // third always belongs to 'move' no matter how narrow the band gets.
           const left=Math.min(px0,px1b),right=Math.max(px0,px1b);
+          const grab=Math.min(HR+5,(right-left)/3);
+          if(Math.abs(mx-px0)<=grab) return{idx:i,mode:'edge0',wtype:'range',startMX:mx,snapW:{...w}};
+          if(Math.abs(mx-px1b)<=grab) return{idx:i,mode:'edge1',wtype:'range',startMX:mx,snapW:{...w}};
           if(mx>=left&&mx<=right&&my>=r.y&&my<=r.y+r.h) return{idx:i,mode:'move',wtype:'range',startMX:mx,snapW:{...w}};
         }
       }
@@ -7329,8 +7351,21 @@ fn fs(in : VsOut) -> @location(0) vec4<f32> {
     if(w.type==='vline'){w.x=xUnit;}
     else if(w.type==='hline'){w.y=st.data_max-((py-r.y)/(r.h||1))*(st.data_max-st.data_min);}
     else if(w.type==='range'){
-      if(d.mode==='edge0') w.x0=xUnit;
-      else if(d.mode==='edge1') w.x1=xUnit;
+      // max_extent caps the span DURING the drag. The edge NOT being dragged is
+      // the anchor and never moves, so the span stops growing at the cap without
+      // the range jumping. (Clamping afterwards by rewriting whichever endpoint
+      // happens to be numerically smaller moves the edge the user is not holding
+      // — that reads as phantom movement.) Dragging the whole band is unaffected:
+      // a translation can't change the width.
+      const cap = (w.max_extent == null ? null : Math.abs(w.max_extent));
+      if(d.mode==='edge0'){
+        w.x0 = (cap!=null && Math.abs(w.x1-xUnit) > cap)
+          ? w.x1 + (xUnit < w.x1 ? -cap : cap) : xUnit;
+      }
+      else if(d.mode==='edge1'){
+        w.x1 = (cap!=null && Math.abs(xUnit-w.x0) > cap)
+          ? w.x0 + (xUnit < w.x0 ? -cap : cap) : xUnit;
+      }
       else {
         const snapPx=_fracToPx1d(xArr.length>=2?_axisValToFrac(xArr,s.x0):0,x0,x1,r);
         const dxUnit=xArr.length>=2?_axisFracToVal(xArr,_canvasXToFrac1d(snapPx+(mx-d.startMX),x0,x1,r))-s.x0:(mx-d.startMX)/(r.w||1);

{anyplotlib-0.4.0 → anyplotlib-0.4.2}/anyplotlib/plot1d/_plot1d.py

@@ -756,6 +756,7 @@ class Plot1D(_BasePlot, _PanelMixin, _MarkerMixin):
                          style: str = "band",
                          y: float = 0.0,
                          linewidth: float = 2,
+                         max_extent: float | None = None,
                          _push: bool = True) -> _RangeWidget:
         """Add a draggable range overlay to this panel.
 
@@ -775,6 +776,10 @@ class Plot1D(_BasePlot, _PanelMixin, _MarkerMixin):
             ``style='fwhm'``.  Ignored when ``style='band'``.  Default 0.
         linewidth : float, optional
             Line stroke width in px.  Default 2.
+        max_extent : float, optional
+            Maximum span width in data units.  The span physically stops growing
+            at this width while dragging (the dragged edge pins, the opposite
+            edge stays put).  ``None`` (default) leaves it unbounded.
         _push : bool, optional
             Push state to JS immediately. Set to ``False`` when adding
             several widgets at once; call :meth:`_push` manually afterward.
@@ -787,7 +792,7 @@ class Plot1D(_BasePlot, _PanelMixin, _MarkerMixin):
         """
         widget = _RangeWidget(lambda: None, x0=float(x0), x1=float(x1),
                               color=color, style=style, y=float(y),
-                              linewidth=linewidth)
+                              linewidth=linewidth, max_extent=max_extent)
         widget._push_fn = self._make_widget_push_fn(widget)
         self._widgets[widget.id] = widget
         if _push:

{anyplotlib-0.4.0 → anyplotlib-0.4.2}/anyplotlib/plot2d/_plot2d.py

@@ -568,13 +568,17 @@ class Plot2D(_BasePlot, _PanelMixin, _MarkerMixin):
             self._state["base_width"] = int(ow)
             self._state["base_height"] = int(oh)
             self._overview_stale = False
-            _TLOG.debug(
-                "[TILEDBG] overview refresh: overview=%s u8[min=%d max=%d] "
-                "display=(%s,%s) base_wh=(%d,%d) image_wh=(%s,%s)", (oh, ow),
-                int(img_u8.min()), int(img_u8.max()),
-                self._state.get("display_min"), self._state.get("display_max"),
-                ow, oh, self._state.get("image_width"),
-                self._state.get("image_height"))
+            # min/max are two more full passes over the overview — same guard rule
+            # as the FETCH diagnostic below (they are .debug() ARGUMENTS, so lazy
+            # formatting does not skip them).
+            if _TLOG.isEnabledFor(logging.DEBUG):
+                _TLOG.debug(
+                    "[TILEDBG] overview refresh: overview=%s u8[min=%d max=%d] "
+                    "display=(%s,%s) base_wh=(%d,%d) image_wh=(%s,%s)", (oh, ow),
+                    int(img_u8.min()), int(img_u8.max()),
+                    self._state.get("display_min"), self._state.get("display_max"),
+                    ow, oh, self._state.get("image_width"),
+                    self._state.get("image_height"))
         except Exception as e:
             _TLOG.warning("[TILEDBG] overview refresh FAILED: %s", e)
 
@@ -648,28 +652,47 @@ class Plot2D(_BasePlot, _PanelMixin, _MarkerMixin):
             else:
                 out_h, out_w = dh, max(1, int(round(dh * aspect)))
             b = self._tile_backend
-            # DIAGNOSTIC: the raw native region straight from the backend, BEFORE
-            # sampling — its shape + distinct-value count tells us whether the backend
-            # actually holds native pixels. If region is 82×82 but the raw crop has
-            # only ~100 distinct values, the backend source is a downsample (bug).
-            _raw = np.asarray(b._a[y0:y1, x0:x1]) if hasattr(b, "_a") else None
             tile = self._tile_backend.sample(
                 x0, x1, y0, y1, out_w, out_h, self._integration_method)
             if b.origin == "lower":
                 tile = np.flipud(tile)
             self.set_detail(np.ascontiguousarray(tile), x0, x1, y0, y1)
-            _bshape = b.full_shape if hasattr(b, "full_shape") else "?"
-            _rawinfo = ("raw_crop=%s distinct=%d" % (
-                _raw.shape, int(np.unique(_raw).size))) if _raw is not None else "raw=?"
-            _tileinfo = "tile_distinct=%d" % int(np.unique(np.asarray(tile)).size)
+            # The FETCH diagnostic sorts the raw native crop and the tile
+            # (np.unique) — 259 ms on a 4096² frame at the zoom where VIEW_OVERFETCH
+            # makes the crop the whole image. Those were arguments to a .debug()
+            # call, so lazy %-formatting did NOT save them: every pan paid for them
+            # at any log level. Guard the whole block, never inline it again.
+            if _TLOG.isEnabledFor(logging.DEBUG):
+                self._log_fetch_diagnostic(
+                    b, tile, zoom, x0, x1, y0, y1, rw, rh, out_w, out_h)
+        except Exception as e:
+            _TLOG.warning("[TILEDBG] view_changed tile update FAILED: %s", e)
+
+    def _log_fetch_diagnostic(self, b, tile, zoom, x0, x1, y0, y1, rw, rh,
+                              out_w, out_h) -> None:
+        """The expensive [TILEDBG] FETCH line — only ever call this behind an
+        ``isEnabledFor(DEBUG)`` guard.
+
+        The distinct-value counts are the point of it: if the requested region is
+        82×82 but the backend's raw crop has only ~100 distinct values, the backend
+        source is a downsample rather than native pixels (a real bug this caught).
+        Both counts are full sorts of up to 16 M pixels, hence the guard."""
+        try:
+            raw = np.asarray(b._a[y0:y1, x0:x1]) if hasattr(b, "_a") else None
+            rawinfo = ("raw_crop=%s distinct=%d"
+                       % (raw.shape, int(np.unique(raw).size))
+                       ) if raw is not None else "raw=?"
+            arr = np.asarray(tile)
             _TLOG.debug(
                 "[TILEDBG] view_changed FETCH zoom=%.2f region=[x %d:%d y %d:%d] "
-                "(%dx%d logical) BACKEND_shape=%s %s → tile=%dx%d %s "
-                "u8[min=%d max=%d]",
-                zoom, x0, x1, y0, y1, rw, rh, _bshape, _rawinfo, out_w, out_h,
-                _tileinfo, int(np.asarray(tile).min()), int(np.asarray(tile).max()))
+                "(%dx%d logical) BACKEND_shape=%s %s → tile=%dx%d "
+                "tile_distinct=%d u8[min=%d max=%d]",
+                zoom, x0, x1, y0, y1, rw, rh,
+                b.full_shape if hasattr(b, "full_shape") else "?", rawinfo,
+                out_w, out_h, int(np.unique(arr).size),
+                int(arr.min()), int(arr.max()))
         except Exception as e:
-            _TLOG.warning("[TILEDBG] view_changed tile update FAILED: %s", e)
+            _TLOG.debug("[TILEDBG] FETCH diagnostic failed: %s", e)
 
     @staticmethod
     def _encode_bytes(arr: np.ndarray) -> str:
@@ -1610,16 +1633,38 @@ class Plot2D(_BasePlot, _PanelMixin, _MarkerMixin):
     def add_rectangle_widget(self, x: float | None = None, y: float | None = None,
                               w: float | None = None, h: float | None = None,
                               color: str = "#00e5ff", linewidth: float = 2,
-                              show_handles: bool = True) -> RectangleWidget:
-        """Add a draggable rectangle overlay."""
+                              show_handles: bool = True,
+                              max_extent=None) -> RectangleWidget:
+        """Add a draggable rectangle overlay.
+
+        ``max_extent`` caps the rectangle's size in the widget's coordinates —
+        a scalar caps both axes, a ``(max_w, max_h)`` pair caps them separately.
+        The rectangle then physically stops growing at the cap while dragging
+        (the dragged corner pins, the opposite corner stays put).
+        """
         iw, ih = self._state["image_width"], self._state["image_height"]
+        # The DEFAULT size honours max_extent. Without this a capped rectangle is
+        # born at half the image and then snaps down to the cap on first use —
+        # the ROI visibly appears huge and collapses, which looks like a bug.
+        def _cap(axis_default, cap):
+            return axis_default if cap is None else min(axis_default, float(cap))
+
+        if max_extent is None:
+            cap_w = cap_h = None
+        elif isinstance(max_extent, (tuple, list)):
+            cap_w, cap_h = max_extent[0], max_extent[1]
+        else:
+            cap_w = cap_h = max_extent
+        def_w = _cap(iw * 0.5, cap_w)
+        def_h = _cap(ih * 0.5, cap_h)
         widget = RectangleWidget(lambda: None,
                                  x=float(x) if x is not None else iw * 0.25,
                                  y=float(y) if y is not None else ih * 0.25,
-                                 w=float(w) if w is not None else iw * 0.5,
-                                 h=float(h) if h is not None else ih * 0.5,
+                                 w=float(w) if w is not None else def_w,
+                                 h=float(h) if h is not None else def_h,
                                  color=color, linewidth=linewidth,
-                                 show_handles=show_handles)
+                                 show_handles=show_handles,
+                                 max_extent=max_extent)
         widget._push_fn = self._make_widget_push_fn(widget)
         self._widgets[widget.id] = widget
         self._push()