plopp 25.10.0__py3-none-any.whl → 26.2.0__py3-none-any.whl

plopp/__init__.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
-# ruff: noqa: E402, F401, I
+# ruff: noqa: RUF100, E402, F401, I
 
 import importlib.metadata
 

plopp/backends/matplotlib/canvas.py

@@ -112,7 +112,7 @@ class Canvas:
         grid: bool = False,
         user_vmin: sc.Variable | float | None = None,
         user_vmax: sc.Variable | float | None = None,
-        aspect: Literal['auto', 'equal', None] = None,
+        aspect: Literal['auto', 'equal'] | None = None,
         cbar: bool = False,
         legend: bool | tuple[float, float] = True,
         xmin: sc.Variable | float | None = None,
@@ -123,7 +123,7 @@ class Canvas:
         logy: bool = False,
         xlabel: str | None = None,
         ylabel: str | None = None,
-        norm: Literal['linear', 'log', None] = None,
+        norm: Literal['linear', 'log'] | None = None,
         **ignored,
     ):
         # Note on the `**ignored`` keyword arguments: the figure which owns the canvas
@@ -515,7 +515,7 @@ class Canvas:
         """
         self.fig.canvas.toolbar.pan()
 
-    def panzoom(self, value: Literal['pan', 'zoom', None]):
+    def panzoom(self, value: Literal['pan', 'zoom'] | None):
         """
         Activate or deactivate the pan or zoom tool, depending on the input value.
         """

plopp/backends/plotly/canvas.py

@@ -46,7 +46,7 @@ class Canvas:
         logy: bool | None = None,
         xlabel: str | None = None,
         ylabel: str | None = None,
-        norm: Literal['linear', 'log', None] = None,
+        norm: Literal['linear', 'log'] | None = None,
         **ignored,
     ):
         # Note on the `**ignored`` keyword arguments: the figure which owns the canvas
@@ -326,7 +326,7 @@ class Canvas:
         """
         self.fig.update_layout(dragmode='pan')
 
-    def panzoom(self, value: Literal['pan', 'zoom', None]):
+    def panzoom(self, value: Literal['pan', 'zoom'] | None):
         """
         Activate or deactivate the pan or zoom tool, depending on the input value.
         """

plopp/graphics/colormapper.py

@@ -55,7 +55,12 @@ def _get_cmap(colormap: str | Colormap, nan_color: str | None = None) -> Colorma
         else:
             cmap = mpl.cm.get_cmap(colormap)
     except (KeyError, ValueError):
+        # Case where we have just a single color
         cmap = LinearSegmentedColormap.from_list('tmp', [colormap, colormap])
+        cmap.set_over(colormap)
+        cmap.set_under(colormap)
+        cmap.set_bad(colormap)
+        return cmap
 
     # Add under and over values to the cmap
     delta = 0.15
@@ -141,7 +146,7 @@ class ColorMapper:
         clabel: str | None = None,
         nan_color: str | None = None,
         figsize: tuple[float, float] | None = None,
-        norm: Literal['linear', 'log', None] = None,
+        norm: Literal['linear', 'log'] | None = None,
         vmin: sc.Variable | float | None = None,
         vmax: sc.Variable | float | None = None,
     ):
@@ -152,9 +157,14 @@ class ColorMapper:
         self._canvas = canvas
         self.cax = self._canvas.cax if hasattr(self._canvas, 'cax') else None
         self.cmap = _get_cmap(cmap, nan_color=nan_color)
-        self.mask_cmap = _get_cmap(
-            mask_cmap if mask_color is None else mask_color, nan_color=nan_color
-        )
+        self.mask_cmap = _get_cmap(mask_cmap if mask_color is None else mask_color)
+        if mask_color is None:
+            # If no single color was used for masks, it means a colormap was used
+            # instead. However, `nan_color` was not passed to get_cmap for the masks
+            # (it only applied to non-masked data), so we still need to set the 'bad'
+            # color here. We choose to set it to the 'over' color for a lack of a
+            # better idea.
+            self.mask_cmap.set_bad(self.mask_cmap.get_over())
 
         # Inside the autoscale, we need to distinguish between a min value that was set
         # by the user and one that was found by looping over all the data.

plopp/graphics/graphicalview.py

@@ -51,11 +51,11 @@ class GraphicalView(View):
         mask_cmap: str = 'gray',
         mask_color: str | None = None,
         cbar: bool = False,
-        norm: Literal['linear', 'log', None] = None,
+        norm: Literal['linear', 'log'] | None = None,
         vmin: sc.Variable | float | None = None,
         vmax: sc.Variable | float | None = None,
         scale: dict[str, str] | None = None,
-        aspect: Literal['auto', 'equal', None] = None,
+        aspect: Literal['auto', 'equal'] | None = None,
         grid: bool = False,
         title: str | None = None,
         figsize: tuple[float, float] | None = None,
@@ -312,5 +312,6 @@ class GraphicalView(View):
         self.artists[key].remove()
         del self.artists[key]
         self.canvas.update_legend()
-        self.fit_to_data()
-        self.canvas.draw()
+        if self._autoscale:
+            self.fit_to_data()
+            self.canvas.draw()

plopp/plotting/common.py

@@ -319,7 +319,7 @@ def input_to_nodes(obj: PlottableMulti, processor: Callable) -> list[Node]:
         to_nodes = obj.items()
     else:
         to_nodes = [(getattr(obj, "name", None), obj)]
-    nodes = [Node(processor, inp, name=name) for name, inp in to_nodes]
+    nodes = [Node(processor, inp, name=str(name)) for name, inp in to_nodes]
     for node in nodes:
         if hasattr(processor, 'func'):
             node.pretty_name = processor.func.__name__
@@ -347,7 +347,7 @@ def raise_multiple_inputs_for_2d_plot_error(origin):
 
 
 def categorize_args(
-    aspect: Literal['auto', 'equal', None] = None,
+    aspect: Literal['auto', 'equal'] | None = None,
     autoscale: bool = True,
     cbar: bool = True,
     clabel: str | None = None,
@@ -364,7 +364,7 @@ def categorize_args(
     mask_cmap: str = 'gray',
     mask_color: str = 'black',
     nan_color: str | None = None,
-    norm: Literal['linear', 'log', None] = None,
+    norm: Literal['linear', 'log'] | None = None,
     scale: dict[str, str] | None = None,
     title: str | None = None,
     vmax: sc.Variable | float | None = None,

plopp/plotting/inspector.py

@@ -3,6 +3,7 @@
 
 from typing import Literal
 
+import numpy as np
 import scipp as sc
 
 from ..core import Node
@@ -34,11 +35,40 @@ def _slice_xy(da: sc.DataArray, xy: dict[str, dict[str, int]]) -> sc.DataArray:
     return da[y['dim'], y['value']][x['dim'], x['value']]
 
 
+def _coord_to_centers(da: sc.DataArray, dim: str) -> sc.Variable:
+    coord = da.coords[dim]
+    if da.coords.is_edges(dim, dim=dim):
+        return sc.midpoints(coord, dim=dim)
+    return coord
+
+
+def _mask_outside_polygon(
+    da: sc.DataArray, poly: dict[str, dict[str, sc.Variable]]
+) -> sc.DataArray:
+    from matplotlib.path import Path
+
+    xdim = poly['x']['dim']
+    ydim = poly['y']['dim']
+    x = _coord_to_centers(da, xdim)
+    y = _coord_to_centers(da, ydim)
+    vx = poly['x']['value'].to(unit=x.unit).values
+    vy = poly['y']['value'].to(unit=y.unit).values
+    verts = np.column_stack([vx, vy])
+    path = Path(verts)
+    xx = sc.broadcast(x, sizes={**x.sizes, **y.sizes})
+    yy = sc.broadcast(y, sizes={**x.sizes, **y.sizes})
+    points = np.column_stack([xx.values.ravel(), yy.values.ravel()])
+    inside = sc.array(
+        dims=yy.dims, values=path.contains_points(points).reshape(yy.shape)
+    )
+    return da.assign_masks(__inside_polygon=~inside).sum({*x.dims, *y.dims})
+
+
 def inspector(
     obj: Plottable,
     dim: str | None = None,
     *,
-    aspect: Literal['auto', 'equal', None] = None,
+    aspect: Literal['auto', 'equal'] | None = None,
     autoscale: bool = True,
     cbar: bool = True,
     clabel: str | None = None,
@@ -49,17 +79,19 @@ def inspector(
     grid: bool = False,
     legend: bool | tuple[float, float] = True,
     logc: bool | None = None,
-    logy: bool | None = None,
     mask_cmap: str = 'gray',
     mask_color: str = 'black',
+    mode: Literal['point', 'polygon'] = 'point',
     nan_color: str | None = None,
-    norm: Literal['linear', 'log', None] = None,
+    norm: Literal['linear', 'log'] | None = None,
     operation: Literal['sum', 'mean', 'min', 'max'] = 'sum',
     orientation: Literal['horizontal', 'vertical'] = 'horizontal',
     title: str | None = None,
     vmax: sc.Variable | float | None = None,
     vmin: sc.Variable | float | None = None,
     xlabel: str | None = None,
+    xmax: sc.Variable | float | None = None,
+    xmin: sc.Variable | float | None = None,
     ylabel: str | None = None,
     ymax: sc.Variable | float | None = None,
     ymin: sc.Variable | float | None = None,
@@ -69,16 +101,29 @@ def inspector(
     Inspector takes in a three-dimensional input and applies a reduction operation
     (``'sum'`` by default) along one of the dimensions specified by ``dim``.
     It displays the result as a two-dimensional image.
-    In addition, an 'inspection' tool is available in the toolbar which allows to place
-    markers on the image which perform slicing at that position to retain only the third
-    dimension and displays the resulting one-dimensional slice on the right hand side
-    figure.
-
-    Controls:
-    - Click to make new point
-    - Drag existing point to move it
+    In addition, an 'inspection' tool is available in the toolbar. In ``mode='point'``
+    it allows placing point markers on the image to slice at that position, retaining
+    only the third dimension and displaying the resulting one-dimensional slice in the
+    right-hand side figure. In ``mode='polygon'`` it allows drawing a polygon to compute
+    the total intensity inside the polygon as a function of the third dimension.
+
+    Controls (point mode):
+    - Left-click to make new points
+    - Left-click and hold on point to move point
     - Middle-click to delete point
 
+    Controls (polygon mode):
+    - Left-click to make new polygons
+    - Left-click and hold on polygon vertex to move vertex
+    - Right-click and hold to drag/move the entire polygon
+    - Middle-click to delete polygon
+
+    Notes
+    -----
+
+    Almost all the arguments for plot customization apply to the two-dimensional image
+    (unless specified).
+
     Parameters
     ----------
     obj:
@@ -93,13 +138,13 @@ def inspector(
     autoscale:
         Automatically scale the axes/colormap on updates if ``True``.
     cbar:
-        Show colorbar if ``True`` (2d figure).
+        Show colorbar if ``True``.
     clabel:
-        Label for colorscale (2d figure).
+        Label for colorscale.
     cmax:
-        Upper limit for colorscale (2d figure).
+        Upper limit for colorscale.
     cmin:
-        Lower limit for colorscale (2d figure).
+        Lower limit for colorscale.
     errorbars:
         Show errorbars if ``True`` (1d figure).
     figsize:
@@ -111,18 +156,18 @@ def inspector(
         ``(x, y)`` coordinates of the legend's anchor point in axes coordinates
         (1d figure).
     logc:
-        If ``True``, use logarithmic scale for colorscale (2d figure).
-    logy:
-        If ``True``, use logarithmic scale for y-axis (1d figure).
+        If ``True``, use logarithmic scale for colorscale.
     mask_cmap:
-        Colormap to use for masks in 2d figure.
+        Colormap to use for masks.
     mask_color:
         Color of masks (overrides ``mask_cmap``).
+    mode:
+        Select ``'point'`` for point inspection or ``'polygon'`` for polygon selection
+        with total intensity inside the polygon plotted as a function of ``dim``.
     nan_color:
-        Color to use for NaN values in 2d figure.
+        Color to use for NaN values.
     norm:
-        Set to ``'log'`` for a logarithmic y-axis (1d figure) or logarithmic colorscale
-        (2d figure). Legacy, prefer ``logy`` and ``logc`` instead.
+        Set to ``'log'`` for a logarithmic colorscale. Legacy, prefer ``logc`` instead.
     operation:
         The operation to apply along the third (undisplayed) dimension specified by
         ``dim``.
@@ -132,15 +177,19 @@ def inspector(
     title:
         The figure title.
     vmax:
-        Upper limit for data to be displayed (y-axis for 1d figure, colorscale for
-        2d figure). Legacy, prefer ``ymax`` and ``cmax`` instead.
+        Upper limit for data colorscale to be displayed.
+        Legacy, prefer ``cmax`` instead.
     vmin:
-        Lower limit for data to be displayed (y-axis for 1d figure, colorscale for
-        2d figure). Legacy, prefer ``ymin`` and ``cmin`` instead.
+        Lower limit for data colorscale to be displayed.
+        Legacy, prefer ``cmin`` instead.
     xlabel:
-        Label for x-axis (2d figure).
+        Label for x-axis.
+    xmax:
+        Upper limit for x-axis (1d figure)
+    xmin:
+        Lower limit for x-axis (1d figure)
     ylabel:
-        Label for y-axis (2d figure).
+        Label for y-axis.
     ymax:
         Upper limit for y-axis (1d figure).
     ymin:
@@ -159,11 +208,9 @@ def inspector(
         errorbars=errorbars,
         grid=grid,
         legend=legend,
-        logy=logy,
         mask_color=mask_color,
-        norm=norm,
-        vmax=vmax,
-        vmin=vmin,
+        xmax=xmax,
+        xmin=xmin,
         ymax=ymax,
         ymin=ymin,
     )
@@ -190,6 +237,7 @@ def inspector(
         figsize=figsize,
         grid=grid,
         logc=logc,
+        mask_cmap=mask_cmap,
         mask_color=mask_color,
         nan_color=nan_color,
         norm=norm,
@@ -198,21 +246,30 @@ def inspector(
         vmin=vmin,
         xlabel=xlabel,
         ylabel=ylabel,
-        ymax=ymax,
-        ymin=ymin,
         **kwargs,
     )
+    from ..widgets import Box, PointsTool, PolygonTool
 
-    from ..widgets import Box, PointsTool
+    if mode == 'point':
+        tool = PointsTool(
+            figure=f2d,
+            input_node=bin_edges_node,
+            func=_slice_xy,
+            destination=f1d,
+            tooltip="Activate inspector tool",
+        )
+    elif mode == 'polygon':
+        tool = PolygonTool(
+            figure=f2d,
+            input_node=bin_edges_node,
+            func=_mask_outside_polygon,
+            destination=f1d,
+            tooltip="Activate polygon inspector tool",
+        )
+    else:
+        raise ValueError(f'Mode "{mode}" is unknown.')
 
-    pts = PointsTool(
-        figure=f2d,
-        input_node=bin_edges_node,
-        func=_slice_xy,
-        destination=f1d,
-        tooltip="Activate inspector tool",
-    )
-    f2d.toolbar['inspect'] = pts
+    f2d.toolbar['inspect'] = tool
     out = [f2d, f1d]
     if orientation == 'horizontal':
         out = [out]

plopp/plotting/mesh3d.py

@@ -53,7 +53,7 @@ def mesh3d(
     figsize: tuple[int, int] = (600, 400),
     logc: bool | None = None,
     nan_color: str | None = None,
-    norm: Literal['linear', 'log', None] = None,
+    norm: Literal['linear', 'log'] | None = None,
     title: str | None = None,
     vmax: sc.Variable | float = None,
     vmin: sc.Variable | float = None,

plopp/plotting/plot.py

@@ -19,7 +19,7 @@ from .common import (
 def plot(
     obj: PlottableMulti,
     *,
-    aspect: Literal['auto', 'equal', None] = None,
+    aspect: Literal['auto', 'equal'] | None = None,
     autoscale: bool = True,
     cbar: bool = True,
     clabel: str | None = None,
@@ -38,7 +38,7 @@ def plot(
     mask_cmap: str = 'gray',
     mask_color: str | None = None,
     nan_color: str | None = None,
-    norm: Literal['linear', 'log', None] = None,
+    norm: Literal['linear', 'log'] | None = None,
     scale: dict[str, str] | None = None,
     title: str | None = None,
     vmax: sc.Variable | float | None = None,

plopp/plotting/scatter.py

@@ -46,9 +46,9 @@ def scatter(
     x: str = 'x',
     y: str = 'y',
     pos: str | None = None,
-    aspect: Literal['auto', 'equal', None] = None,
+    aspect: Literal['auto', 'equal'] | None = None,
     autoscale: bool = True,
-    cbar: bool = True,
+    cbar: bool = False,
     clabel: str | None = None,
     cmap: str = 'viridis',
     cmax: sc.Variable | float | None = None,
@@ -62,7 +62,7 @@ def scatter(
     logy: bool | None = None,
     mask_color: str = 'black',
     nan_color: str | None = None,
-    norm: Literal['linear', 'log', None] = None,
+    norm: Literal['linear', 'log'] | None = None,
     scale: dict[str, str] | None = None,
     size: str | float | None = None,
     title: str | None = None,

plopp/plotting/scatter3d.py

@@ -53,7 +53,7 @@ def scatter3d(
     figsize: tuple[int, int] = (600, 400),
     logc: bool | None = None,
     nan_color: str | None = None,
-    norm: Literal['linear', 'log', None] = None,
+    norm: Literal['linear', 'log'] | None = None,
     title: str | None = None,
     vmax: sc.Variable | float = None,
     vmin: sc.Variable | float = None,
@@ -126,7 +126,7 @@ def scatter3d(
         A three-dimensional interactive scatter plot.
     """
     from ..graphics import scatter3dfigure
-    from ..widgets import ClippingPlanes, ToggleTool
+    from ..widgets import ClippingManager, ToggleTool
 
     if 'ax' in kwargs:
         raise ValueError(
@@ -160,11 +160,11 @@ def scatter3d(
         vmin=vmin,
         **kwargs,
     )
-    clip_planes = ClippingPlanes(fig)
+    clip_manager = ClippingManager(fig)
     fig.toolbar['cut3d'] = ToggleTool(
-        callback=clip_planes.toggle_visibility,
+        callback=clip_manager.toggle_visibility,
         icon='layer-group',
         tooltip='Hide/show spatial cutting tool',
     )
-    fig.bottom_bar.add(clip_planes)
+    fig.bottom_bar.add(clip_manager)
     return fig

plopp/plotting/slicer.py

@@ -127,7 +127,7 @@ def slicer(
     obj: PlottableMulti,
     keep: list[str] | None = None,
     *,
-    aspect: Literal['auto', 'equal', None] = None,
+    aspect: Literal['auto', 'equal'] | None = None,
     autoscale: bool = True,
     cbar: bool = True,
     clabel: str | None = None,
@@ -146,7 +146,7 @@ def slicer(
     mask_cmap: str = 'gray',
     mask_color: str | None = None,
     nan_color: str | None = None,
-    norm: Literal['linear', 'log', None] = None,
+    norm: Literal['linear', 'log'] | None = None,
     scale: dict[str, str] | None = None,
     title: str | None = None,
     vmax: sc.Variable | float | None = None,

plopp/plotting/superplot.py

@@ -13,7 +13,7 @@ def superplot(
     obj: Plottable,
     keep: str | None = None,
     *,
-    aspect: Literal['auto', 'equal', None] = None,
+    aspect: Literal['auto', 'equal'] | None = None,
     autoscale: bool = True,
     coords: list[str] | None = None,
     enable_player: bool = False,
@@ -24,7 +24,7 @@ def superplot(
     logx: bool | None = None,
     logy: bool | None = None,
     mask_color: str = 'black',
-    norm: Literal['linear', 'log', None] = None,
+    norm: Literal['linear', 'log'] | None = None,
     scale: dict[str, str] | None = None,
     title: str | None = None,
     vmax: sc.Variable | float | None = None,

plopp/plotting/xyplot.py

@@ -40,7 +40,7 @@ def _make_data_array(x: sc.Variable, y: sc.Variable) -> sc.DataArray:
 def xyplot(
     x: sc.Variable | ndarray | list | Node,
     y: sc.Variable | ndarray | list | Node,
-    aspect: Literal['auto', 'equal', None] = None,
+    aspect: Literal['auto', 'equal'] | None = None,
     autoscale: bool = True,
     errorbars: bool = True,
     figsize: tuple[float, float] | None = None,
@@ -48,7 +48,7 @@ def xyplot(
     legend: bool | tuple[float, float] = True,
     logx: bool | None = None,
     logy: bool | None = None,
-    norm: Literal['linear', 'log', None] = None,
+    norm: Literal['linear', 'log'] | None = None,
     scale: dict[str, str] | None = None,
     title: str | None = None,
     vmax: sc.Variable | float | None = None,

plopp/widgets/__init__.pyi

@@ -3,8 +3,8 @@
 
 from .box import Box, HBar, VBar
 from .checkboxes import Checkboxes
-from .clip3d import Clip3dTool, ClippingPlanes
-from .drawing import DrawingTool, PointsTool
+from .clip3d import Clip3dTool, ClippingManager
+from .drawing import DrawingTool, PointsTool, PolygonTool
 from .linesave import LineSaveTool
 from .slice import RangeSliceWidget, SliceWidget, slice_dims
 from .toolbar import Toolbar, make_toolbar_canvas2d, make_toolbar_canvas3d
@@ -15,12 +15,13 @@ __all__ = [
     "ButtonTool",
     "Checkboxes",
     "Clip3dTool",
-    "ClippingPlanes",
+    "ClippingManager",
     "ColorTool",
     "DrawingTool",
     "HBar",
     "LineSaveTool",
     "PointsTool",
+    "PolygonTool",
     "RangeSliceWidget",
     "SliceWidget",
     "ToggleTool",

plopp/widgets/clip3d.py

@@ -46,7 +46,7 @@ class Clip3dTool(ipw.HBox):
     ----------
     limits:
         The spatial extent of the points in the 3d figure in the XYZ directions.
-    direction:
+    kind:
         The direction normal to the slice.
     update:
         A function to update the scene.
@@ -59,23 +59,23 @@ class Clip3dTool(ipw.HBox):
     def __init__(
         self,
         limits: tuple[sc.Variable, sc.Variable, sc.Variable],
-        direction: Literal['x', 'y', 'z'],
+        kind: Literal['x', 'y', 'z'],
         update: Callable,
         color: str = 'red',
         linewidth: float = 1.5,
         border_visible: bool = True,
     ):
         self._limits = limits
-        self._direction = direction
-        axis = 'xyz'.index(self._direction)
+        self.kind = kind
+        axis = 'xyz'.index(self.kind)
         self.dim = self._limits[axis].dim
         self._unit = self._limits[axis].unit
         self.visible = True
         self._update = update
         self._border_visible = border_visible
 
-        w_axis = 2 if self._direction == 'x' else 0
-        h_axis = 2 if self._direction == 'y' else 1
+        w_axis = 2 if self.kind == 'x' else 0
+        h_axis = 2 if self.kind == 'y' else 1
         width = (self._limits[w_axis][1] - self._limits[w_axis][0]).value
         height = (self._limits[h_axis][1] - self._limits[h_axis][0]).value
 
@@ -95,10 +95,10 @@ class Clip3dTool(ipw.HBox):
                 material=p3.LineBasicMaterial(color=color, linewidth=linewidth),
             ),
         ]
-        if self._direction == 'x':
+        if self.kind == 'x':
             for outline in self.outlines:
                 outline.rotateY(0.5 * np.pi)
-        if self._direction == 'y':
+        if self.kind == 'y':
             for outline in self.outlines:
                 outline.rotateX(0.5 * np.pi)
 
@@ -112,15 +112,15 @@ class Clip3dTool(ipw.HBox):
             max=vmax,
             value=[center[axis] - delta, center[axis] + delta],
             step=dx * 0.01,
-            description=direction.upper(),
+            description=self.kind.upper(),
             style={'description_width': 'initial'},
-            layout={'width': '470px', 'padding': '0px'},
+            layout={'width': '35.6em', 'padding': '0px'},
         )
 
         self.cut_visible = ipw.Button(
             icon='eye-slash',
             tooltip='Hide cut',
-            layout={'width': '16px', 'padding': '0px'},
+            layout={'width': '1.23em', 'padding': '0px'},
         )
 
         for outline, val in zip(self.outlines, self.slider.value, strict=True):
@@ -158,20 +158,20 @@ class Clip3dTool(ipw.HBox):
         # the cut, the border visibility is in sync with the parent button.
         self._border_visible = value
 
-    def move(self, value: dict[str, Any]):
+    def move(self, change: dict[str, Any]):
         """
         Move the outline of the cut according to new position given by the slider.
         """
         # Early return if relative difference between new and old value is small.
         # This also prevents flickering of an existing cut when a new cut is added.
         if (
-            np.abs(np.array(value['new']) - np.array(value['old'])).max()
+            np.abs(np.array(change['new']) - np.array(change['old'])).max()
             < 0.01 * self.slider.step
         ):
             return
-        for outline, val in zip(self.outlines, value['new'], strict=True):
+        for outline, val in zip(self.outlines, change['new'], strict=True):
             pos = list(outline.position)
-            axis = 'xyz'.index(self._direction)
+            axis = 'xyz'.index(self.kind)
             pos[axis] = val
             outline.position = pos
         self._throttled_update()
@@ -182,15 +182,114 @@ class Clip3dTool(ipw.HBox):
             self.slider.value[1], unit=self._unit
         )
 
+    def make_selection(self, da: sc.DataArray) -> sc.Variable:
+        """
+        Make a selection variable based on the current slider range.
+        """
+        xmin, xmax = self.range
+        return (da.coords[self.dim] >= xmin) & (da.coords[self.dim] < xmax)
+
+    @debounce(0.3)
+    def _throttled_update(self):
+        self._update()
+
+
+class ClipValueTool(ipw.HBox):
+    """
+    A tool that provides a slider to extract a points in a three-dimensional
+    scatter plot based on a value selection criterion, and adds it to the scene as an
+    opaque cut. The slider controls the range of the selection.
+
+    .. versionadded:: 26.2.0
+
+    Parameters
+    ----------
+    limits:
+        The range of values in the original data.
+    update:
+        A function to update the scene.
+    """
+
+    def __init__(self, limits: sc.Variable, update: Callable):
+        self._limits = limits
+        self._unit = self._limits.unit
+        self.visible = True
+        self._update = update
+        self.kind = 'v'
+
+        center = self._limits.mean().value
+        vmin = self._limits[0].value
+        vmax = self._limits[1].value
+        dx = vmax - vmin
+        delta = 0.05 * dx
+        self.slider = ipw.FloatRangeSlider(
+            min=vmin,
+            max=vmax,
+            value=[center - delta, center + delta],
+            step=dx * 0.01,
+            description="Values",
+            style={'description_width': 'initial'},
+            layout={'width': '35.6em', 'padding': '0px'},
+        )
+
+        self.cut_visible = ipw.Button(
+            icon='eye-slash',
+            tooltip='Hide cut',
+            layout={'width': '1.23em', 'padding': '0px'},
+        )
+
+        self.unit_label = ipw.Label(f'[{self._unit}]')
+        self.cut_visible.on_click(self.toggle)
+        self.slider.observe(self.move, names='value')
+
+        super().__init__([self.slider, ipw.Label(f'[{self._unit}]'), self.cut_visible])
+
+    def toggle(self, owner: ipw.Button):
+        """
+        Toggle the visibility of the cut on and off.
+        """
+        self.visible = not self.visible
+        self.slider.disabled = not self.visible
+        owner.icon = 'eye-slash' if self.visible else 'eye'
+        owner.tooltip = 'Hide cut' if self.visible else 'Show cut'
+        self._update()
+
+    def toggle_border(self, _):
+        return
+
+    @property
+    def range(self):
+        return sc.scalar(self.slider.value[0], unit=self._unit), sc.scalar(
+            self.slider.value[1], unit=self._unit
+        )
+
+    def make_selection(self, da: sc.DataArray) -> sc.Variable:
+        """
+        Make a selection variable based on the current slider range.
+        """
+        xmin, xmax = self.range
+        return (da.data >= xmin) & (da.data < xmax)
+
+    def move(self, change: dict[str, Any]):
+        # Early return if relative difference between new and old value is small.
+        # This also prevents flickering of an existing cut when a new cut is added.
+        if (
+            np.abs(np.array(change['new']) - np.array(change['old'])).max()
+            < 0.01 * self.slider.step
+        ):
+            return
+        self._throttled_update()
+
     @debounce(0.3)
     def _throttled_update(self):
         self._update()
 
 
-class ClippingPlanes(ipw.HBox):
+class ClippingManager(ipw.HBox):
     """
     A widget to make clipping planes for spatial cutting (see :class:`Clip3dTool`) to
     make spatial cuts in the X, Y, and Z directions on a three-dimensional scatter plot.
+    The widget also allows to make value-based cuts using :class:`ClipValueTool`.
 
     .. versionadded:: 24.04.0
 
@@ -226,33 +325,47 @@ class ClippingPlanes(ipw.HBox):
         self.cuts = []
         self._operation = 'or'
 
-        self.tabs = ipw.Tab(layout={'width': '550px'})
+        self.tabs = ipw.Tab(layout={'width': '41.6em'})
         self._original_nodes = list(self._view.graph_nodes.values())
         self._nodes = {}
 
+        self._value_limits = sc.concat(
+            [
+                min(n().data.min() for n in self._original_nodes),
+                max(n().data.max() for n in self._original_nodes),
+            ],
+            dim="dummy",
+        )
+
         self.add_cut_label = ipw.Label('Add cut:')
-        layout = {'width': '45px', 'padding': '0px 0px 0px 0px'}
         self.add_x_cut = ipw.Button(
             description='X',
             icon='plus',
             tooltip='Add X cut',
-            layout=layout,
+            **BUTTON_LAYOUT,
         )
         self.add_y_cut = ipw.Button(
             description='Y',
             icon='plus',
             tooltip='Add Y cut',
-            layout=layout,
+            **BUTTON_LAYOUT,
         )
         self.add_z_cut = ipw.Button(
             description='Z',
             icon='plus',
             tooltip='Add Z cut',
-            layout=layout,
+            **BUTTON_LAYOUT,
+        )
+        self.add_v_cut = ipw.Button(
+            description='V',
+            icon='plus',
+            tooltip='Add Value cut',
+            **BUTTON_LAYOUT,
         )
         self.add_x_cut.on_click(lambda _: self._add_cut('x'))
         self.add_y_cut.on_click(lambda _: self._add_cut('y'))
         self.add_z_cut.on_click(lambda _: self._add_cut('z'))
+        self.add_v_cut.on_click(lambda _: self._add_cut('v'))
 
         self.opacity = ipw.BoundedFloatText(
             min=0,
@@ -263,7 +376,7 @@ class ClippingPlanes(ipw.HBox):
             description='Opacity:',
             tooltip='Set the opacity of the background',
             style={'description_width': 'initial'},
-            layout={'width': '142px', 'padding': '0px 0px 0px 0px'},
+            layout={'width': '12.1em', 'padding': '0px 0px 0px 0px'},
         )
         self.opacity.observe(self._set_opacity, names='value')
 
@@ -283,7 +396,7 @@ class ClippingPlanes(ipw.HBox):
             value='OR',
             disabled=True,
             tooltip='Operation to combine multiple cuts',
-            layout={'width': '60px', 'padding': '0px 0px 0px 0px'},
+            layout={'width': '5.9em', 'padding': '0px 0px 0px 0px'},
         )
         self.cut_operation.observe(self.change_operation, names='value')
 
@@ -300,7 +413,14 @@ class ClippingPlanes(ipw.HBox):
                 self.tabs,
                 ipw.VBox(
                     [
-                        ipw.HBox([self.add_x_cut, self.add_y_cut, self.add_z_cut]),
+                        ipw.HBox(
+                            [
+                                self.add_x_cut,
+                                self.add_y_cut,
+                                self.add_z_cut,
+                                self.add_v_cut,
+                            ]
+                        ),
                         self.opacity,
                         ipw.HBox(
                             [
@@ -316,17 +436,20 @@ class ClippingPlanes(ipw.HBox):
 
         self.layout.display = 'none'
 
-    def _add_cut(self, direction: Literal['x', 'y', 'z']):
+    def _add_cut(self, kind: Literal['x', 'y', 'z', 'v']):
         """
-        Add a cut in the specified direction.
+        Add a cut of the specified kind.
         """
-        cut = Clip3dTool(
-            direction=direction,
-            limits=self._limits,
-            update=self.update_state,
-            border_visible=self.cut_borders_visibility.value,
-        )
-        self._view.canvas.add(cut.outlines)
+        if kind == 'v':
+            cut = ClipValueTool(limits=self._value_limits, update=self.update_state)
+        else:
+            cut = Clip3dTool(
+                kind=kind,
+                limits=self._limits,
+                update=self.update_state,
+                border_visible=self.cut_borders_visibility.value,
+            )
+            self._view.canvas.add(cut.outlines)
         self.cuts.append(cut)
         self.tabs.children = [*self.tabs.children, cut]
         self.tabs.selected_index = len(self.cuts) - 1
@@ -335,7 +458,8 @@ class ClippingPlanes(ipw.HBox):
 
     def _remove_cut(self, _):
         cut = self.cuts.pop(self.tabs.selected_index)
-        self._view.canvas.remove(cut.outlines)
+        if cut.kind != 'v':
+            self._view.canvas.remove(cut.outlines)
         self.tabs.children = self.cuts
         self.update_state()
         self.update_controls()
@@ -350,7 +474,7 @@ class ClippingPlanes(ipw.HBox):
         self.delete_cut.disabled = not at_least_one_cut
         self.cut_borders_visibility.disabled = not at_least_one_cut
         self.cut_operation.disabled = not at_least_one_cut
-        self.tabs.titles = [cut._direction.upper() for cut in self.cuts]
+        self.tabs.titles = [cut.kind.upper() for cut in self.cuts]
         self.opacity.disabled = not at_least_one_cut
         opacity = self.opacity.value if at_least_one_cut else 1.0
         self._set_opacity({'new': opacity})
@@ -403,12 +527,7 @@ class ClippingPlanes(ipw.HBox):
 
         for n in self._original_nodes:
             da = n.request_data()
-            selections = []
-            for cut in visible_cuts:
-                xmin, xmax = cut.range
-                selections.append(
-                    (da.coords[cut.dim] >= xmin) & (da.coords[cut.dim] < xmax)
-                )
+            selections = [cut.make_selection(da) for cut in visible_cuts]
             selection = OPERATIONS[self._operation](selections)
             if selection.sum().value > 0:
                 if n.id not in self._nodes:

plopp/widgets/drawing.py

@@ -76,6 +76,7 @@ class DrawingTool(ToggleTool):
         self._destination = destination
         self._destination_is_fig = is_figure(self._destination)
         self._get_artist_info = get_artist_info
+        self._get_artist_info_is_callable = None
         self._tool.on_create(self.make_node)
         self._tool.on_remove(self.remove_node)
         if continuous_update:
@@ -85,7 +86,10 @@ class DrawingTool(ToggleTool):
             self._tool.on_drag_release(self.update_node)
 
     def make_node(self, artist):
-        draw_node = Node(self._get_artist_info(artist=artist, figure=self._figure))
+        info = self._get_artist_info(artist=artist, figure=self._figure)
+        if self._get_artist_info_is_callable is None:
+            self._get_artist_info_is_callable = callable(info)
+        draw_node = Node(info)
         draw_node.pretty_name = f'Draw node {len(self._draw_nodes)}'
         nodeid = draw_node.id
         self._draw_nodes[nodeid] = draw_node
@@ -105,7 +109,10 @@ class DrawingTool(ToggleTool):
 
     def update_node(self, artist):
         n = self._draw_nodes[artist.nodeid]
-        n.func = self._get_artist_info(artist=artist, figure=self._figure)
+        if self._get_artist_info_is_callable:
+            n.func = self._get_artist_info(artist=artist, figure=self._figure)
+        else:
+            n.func = partial(self._get_artist_info, artist=artist, figure=self._figure)
         n.notify_children(artist)
 
     def remove_node(self, artist):
@@ -134,7 +141,7 @@ def _get_points_info(artist, figure):
     Convert the raw (x, y) position of a point to a dict containing the dimensions of
     each axis, and scalar values with units.
     """
-    return lambda: {
+    return {
         'x': {
             'dim': figure.canvas.dims['x'],
             'value': sc.scalar(artist.x, unit=figure.canvas.units['x']),
@@ -182,3 +189,73 @@ value:
 **kwargs:
     Additional arguments are forwarded to the ``ToggleTool`` constructor.
 """
+
+
+def _get_polygon_info(artist, figure):
+    """
+    Convert the raw polygon vertices to a dict containing the dimensions of
+    each axis, and arrays with units.
+    """
+    xs, ys = artist.x, artist.y
+    return {
+        'x': {
+            'dim': figure.canvas.dims['x'],
+            'value': sc.array(
+                dims=['vertex'],
+                values=xs,
+                unit=figure.canvas.units['x'],
+            ),
+        },
+        'y': {
+            'dim': figure.canvas.dims['y'],
+            'value': sc.array(
+                dims=['vertex'],
+                values=ys,
+                unit=figure.canvas.units['y'],
+            ),
+        },
+    }
+
+
+def _make_polygons(**kwargs):
+    """
+    Intermediate function needed for giving to `partial` to avoid making mpltoolbox a
+    hard dependency.
+    """
+    from mpltoolbox import Polygons
+
+    return Polygons(**kwargs)
+
+
+PolygonTool = partial(
+    DrawingTool,
+    tool=partial(_make_polygons, mec='w'),
+    get_artist_info=_get_polygon_info,
+    icon='draw-polygon',
+)
+"""
+Tool to draw polygon selections on a figure.
+
+Controls:
+  - Left-click to make new polygons
+  - Left-click and hold on polygon vertex to move vertex
+  - Right-click and hold to drag/move the entire polygon
+  - Middle-click to delete polygon
+
+Parameters
+----------
+figure:
+    The figure where the tool will draw the polygon.
+input_node:
+    The node that provides the raw data which is shown in ``figure``.
+func:
+    The function to be used to make a node whose parents will be the ``input_node``
+    and a node yielding the current state of the tool (current position, size).
+destination:
+    Where the output from the ``func`` node will be then sent on. This can either
+    be a figure, or another graph node.
+value:
+    Activate the tool upon creation if ``True``.
+**kwargs:
+    Additional arguments are forwarded to the ``ToggleTool`` constructor.
+"""

plopp/widgets/linesave.py

@@ -35,7 +35,7 @@ class LineSaveTool(VBar):
         self.button = ipw.Button(description='Save line')
         self.button.on_click(self.save_line)
         self.container = VBar()
-        super().__init__([self.button, self.container], layout={'width': '350px'})
+        super().__init__([self.button, self.container], layout={'width': '26.5em'})
 
     def _update_container(self):
         self.container.children = [line['tool'] for line in self._lines.values()]

plopp/widgets/slice.py

@@ -32,7 +32,7 @@ class DimSlicer(ipw.VBox):
             'value': (size - 1) // 2 if slider_constr is ipw.IntSlider else None,
             'continuous_update': True,
             'readout': False,
-            'layout': {"width": "200px", "margin": "0px 0px 0px 10px"},
+            'layout': {"width": "15.2em", "margin": "0px 0px 0px 10px"},
         }
         self.dim_label = ipw.Label(value=dim)
         self.slider = slider_constr(**widget_args)
@@ -40,7 +40,7 @@ class DimSlicer(ipw.VBox):
             value=True,
             tooltip="Continuous update",
             indent=False,
-            layout={"width": "20px"},
+            layout={"width": "1.52em"},
         )
         self.label = ipw.Label(
             value=coord_element_to_string(coord[dim, self.slider.value])

plopp/widgets/style.py

@@ -1,4 +1,4 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright (c) 2023 Scipp contributors (https://github.com/scipp)
 
-BUTTON_LAYOUT = {"layout": {"width": "37px", "padding": "0px 0px 0px 0px"}}
+BUTTON_LAYOUT = {"layout": {"width": "2.8em", "padding": "0px 0px 0px 0px"}}

plopp/widgets/tools.py

@@ -54,7 +54,7 @@ class ToggleTool(ipw.ToggleButton):
 
 class PlusMinusTool(ipw.HBox):
     def __init__(self, plus, minus):
-        layout = {'width': '16px', 'padding': '0px'}
+        layout = {'width': '1.23em', 'padding': '0px'}
         self.callback = {'plus': plus.pop('callback'), 'minus': minus.pop('callback')}
         self._plus = ipw.Button(icon='plus', **{**{'layout': layout}, **plus})
         self._minus = ipw.Button(icon='minus', **{**{'layout': layout}, **minus})
@@ -230,10 +230,10 @@ class ColorTool(ipw.HBox):
     """
 
     def __init__(self, text: str, color: str):
-        layout = ipw.Layout(display="flex", justify_content="flex-end", width='150px')
+        layout = ipw.Layout(display="flex", justify_content="flex-end", width='11.4em')
         self.text = ipw.Label(value=text, layout=layout)
         self.color = ipw.ColorPicker(
-            concise=True, value=color, description='', layout={'width': "30px"}
+            concise=True, value=color, description='', layout={'width': "2.3em"}
         )
         self.button = ipw.Button(icon='times', **BUTTON_LAYOUT)
         super().__init__([self.text, self.color, self.button])

{plopp-25.10.0.dist-info → plopp-26.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plopp
-Version: 25.10.0
+Version: 26.2.0
 Summary: Visualization library for Scipp
 Author: Scipp contributors
 License-Expression: BSD-3-Clause
@@ -36,12 +36,13 @@ Requires-Dist: graphviz>=0.20.3; extra == "test"
 Requires-Dist: h5py>=3.12; extra == "test"
 Requires-Dist: ipympl>=0.8.4; extra == "test"
 Requires-Dist: ipywidgets>=8.1.0; extra == "test"
+Requires-Dist: ipykernel<7,>=6.26; extra == "test"
 Requires-Dist: mpltoolbox>=24.6.0; extra == "test"
 Requires-Dist: pandas>=2.2.2; extra == "test"
 Requires-Dist: plotly>=5.15.0; extra == "test"
 Requires-Dist: pooch>=1.5; extra == "test"
 Requires-Dist: pyarrow>=13.0.0; extra == "test"
-Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest>=8.0; extra == "test"
 Requires-Dist: pythreejs>=2.4.1; extra == "test"
 Requires-Dist: scipp>=25.5.0; extra == "test"
 Requires-Dist: scipy>=1.10.0; extra == "test"

{plopp-25.10.0.dist-info → plopp-26.2.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-plopp/__init__.py,sha256=gyb7FdEP0biNaLQEBZFJKTQSf2pAghTK051eN-yJLxM,1084
+plopp/__init__.py,sha256=sDy1Bzh9cCQvH-JQ1m3e1V0aK-ZrDGycaE791H-nryA,1092
 plopp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 plopp/backends/__init__.py,sha256=hMvOWD3ua_34nUgcb_jITMnRvjRUUqHSUYuXxkxSIMM,1491
 plopp/backends/common.py,sha256=xz4iMmgE4UtRzQJQlX4Sc9sbTCmjPrd7b4dnpCbWuQs,3422
 plopp/backends/matplotlib/__init__.py,sha256=QNPZgWV3wO8psaMkSB-GtTOP-OIe9jSfwDdEt2xgbZg,107
-plopp/backends/matplotlib/canvas.py,sha256=xWwe6RY8qVRSNqpO_4rRCwy_zvlUafD0sOFuadU_9jE,17213
+plopp/backends/matplotlib/canvas.py,sha256=0fRyNkreWEBxdjTr8LJ-OlYs9Z1IHGCiqMS76H07DTs,17216
 plopp/backends/matplotlib/fast_image.py,sha256=1tF4G8kTmgmiybdD-KPIatU2dWwv0dgv4r8IMDQTTGE,6532
 plopp/backends/matplotlib/figure.py,sha256=Emj8KCIFvesEfAoKIWn4M4TcgZhq6zFTfRTFnLZHGxE,5515
 plopp/backends/matplotlib/image.py,sha256=YnczwdxsGmh0Nvrk1A8xL93ap2rzKI-0G428OCQmSCc,974
@@ -13,7 +13,7 @@ plopp/backends/matplotlib/scatter.py,sha256=DH-uvlGCWXrCd9qtBqUmg_qwgACnPTEjaUhT
 plopp/backends/matplotlib/tiled.py,sha256=dy5bKixJP7MYoFJ-bAU4vc6baZaw6aKenD-WoahF_ZM,6238
 plopp/backends/matplotlib/utils.py,sha256=24gmT2sBHS_wUitUThSLavwSK95uqbLAhadNdxC19I0,3479
 plopp/backends/plotly/__init__.py,sha256=QNPZgWV3wO8psaMkSB-GtTOP-OIe9jSfwDdEt2xgbZg,107
-plopp/backends/plotly/canvas.py,sha256=637AZaHvST95WZUO14GkpE_-hoQuWAItex2IK1otHbM,11023
+plopp/backends/plotly/canvas.py,sha256=Zcopn9avEjGBFUnBxgKFy7uIi_8GiDeyPCIAAF6L6CI,11025
 plopp/backends/plotly/figure.py,sha256=60QsXUFjr3CqXjxVpAbvd1c-wtq7T5fptotwybgUEcI,1356
 plopp/backends/plotly/line.py,sha256=yVpJW-xWa0Wy_oMdmvDn2ESIJymT9Fg6wN7RhIRK6Dw,9533
 plopp/backends/pythreejs/__init__.py,sha256=XvSD58Tj5WBrrOjkePcCrRW6RbbyrvhhWI_S8-AR92U,107
@@ -40,39 +40,39 @@ plopp/graphics/__init__.pyi,sha256=yZQkWxUfP9eKHSP47WjrBiu59Z-uhP5gE2eUrPDa6jU,6
 plopp/graphics/basefig.py,sha256=N5gBQE8w2968biRV7a3wkxxq-BM14ncfX52y5HziWiQ,824
 plopp/graphics/bbox.py,sha256=3WeMgu5LgWIXLJTYVT7_USwaAcS7cQPNCk6B0gvuNGo,3596
 plopp/graphics/camera.py,sha256=fXc1YH7Tp-rwKkcYeE-mHrxMz3SKauj5xJCRuKv-QPs,5323
-plopp/graphics/colormapper.py,sha256=dP3sC5IALguLK5UXI6ky1-K0ikX0OYgQurL7H5S6ONo,14384
+plopp/graphics/colormapper.py,sha256=Owe3l5cKNExJfh8_RPWGqhymhWrbmny7aDX9sx3yZP4,14962
 plopp/graphics/figures.py,sha256=PLWQLnQNWz8epubYlK7HLSkvPGJmTAmHjJM2DqpvLe8,2735
-plopp/graphics/graphicalview.py,sha256=BcCM1KuqyfWoJNVtpB8G-K2aywx9dXmZqtLuho_tuLI,11622
+plopp/graphics/graphicalview.py,sha256=LpfQIYN-OQeg_manrMskfpjH6XYsOCIQuZnMNEb0BKw,11660
 plopp/graphics/tiled.py,sha256=gXYZVAs6wRFKezzN3VlEvm7_z2zx3IDYfGZQZqrpL80,1386
 plopp/plotting/__init__.py,sha256=s25RIbKplHSRn0jjtLADPQl72JLf_KLRMRCfeMDI_UA,205
 plopp/plotting/__init__.pyi,sha256=95wYGfM5PT0Y0Ov_ue7rBrHvHxrtex-2WEYtfFzBvE0,475
-plopp/plotting/common.py,sha256=LxBrLdUrHqjgKde7KHnf4y09JEzfO4fbphXm5pjPoAs,13132
-plopp/plotting/inspector.py,sha256=hz15i9kp9s_Txfi-6wYPCS8CLIQbyDoEcVOTs3dAW4A,6803
-plopp/plotting/mesh3d.py,sha256=SaJCaKPIvhMXflOyGWxRlSj1o93bocrQ7OTYY5dNnHY,4186
-plopp/plotting/plot.py,sha256=oSM1rQr3nbO0yhIxsMexD5GCuee0lj3lc4rpE6LgpDQ,5655
-plopp/plotting/scatter.py,sha256=kjYmYcam651ELuN7AsED3NlSjU-9g6hOgpN399SghDM,6018
-plopp/plotting/scatter3d.py,sha256=GlEisMiCeR1ejS4qWIsiYW1iUWH8XDkipeZ1fwDDwP0,5305
-plopp/plotting/slicer.py,sha256=VX5kFaBGCF6qJZdew0pbVTVdeJW6rRejChyuyngd3Zs,9069
-plopp/plotting/superplot.py,sha256=XaRbNWMv9-nVQwVwglyndNZPdbfrQ736-Nzkm7I7eak,4484
-plopp/plotting/xyplot.py,sha256=o-0Yrysda0TAxImw0rNn7TKDJ6x21zuaz8iFYoS52mA,4260
+plopp/plotting/common.py,sha256=f9YxSNGYqisOTLit6ls-iQjx2bgs9xIaf3WEMlorNCE,13139
+plopp/plotting/inspector.py,sha256=5XKvz1RfSTpTzRbTSUJ_9oa8SpPtaAht4eixisb0hDQ,8739
+plopp/plotting/mesh3d.py,sha256=4QQPHuYVyur8nKkbTg7zQMQgFU3MjlsyAPFfpQSJMrU,4187
+plopp/plotting/plot.py,sha256=kAjKSH0QZGgWJVpyfk3GCenrLOUx26D5jbvnZscAueU,5657
+plopp/plotting/scatter.py,sha256=soKks05Fe5FafVrnJxhIj6OfFPhkG9zYrq2tADopi_I,6021
+plopp/plotting/scatter3d.py,sha256=7_mgE5apgkVvseLLMUJSfUQWIwW5P50w589AgrCNUvo,5311
+plopp/plotting/slicer.py,sha256=wdRdrvl0_f32U4yhe_7mbHT9ijjPPj9mW1KzAd_xupc,9071
+plopp/plotting/superplot.py,sha256=htLBssBpuoMKlhP7gsNHbjsyLJWLF27DO3HXpmnpauw,4486
+plopp/plotting/xyplot.py,sha256=3XyhLjWaIqpXOjBQONnD7VehO2cLoWkUiJFk471I_Mw,4262
 plopp/utils/__init__.py,sha256=s25RIbKplHSRn0jjtLADPQl72JLf_KLRMRCfeMDI_UA,205
 plopp/utils/__init__.pyi,sha256=n6xB4g9xWLz1tPI2gbX1N_hLKJhL0pbHOqarM4HNUdQ,246
 plopp/utils/arg_parse.py,sha256=ucBYyOoJfFNEyc2XdnmHLLIbhV-eyOW-UY4JSnMKE-4,783
 plopp/utils/deprecation.py,sha256=TW02FJht8_f3pHHRZYr2VurMrKniFQrmNpj4-z5ahKs,673
 plopp/widgets/__init__.py,sha256=s25RIbKplHSRn0jjtLADPQl72JLf_KLRMRCfeMDI_UA,205
-plopp/widgets/__init__.pyi,sha256=4hVX7I3VEjE3oy2AGVvguYsIgg7cVrhKGpX7xVgGe9Y,844
+plopp/widgets/__init__.pyi,sha256=0mbhLTfA-sULqa9kzmhV9WN6OJr9n-9W5Qb-aKQjIW4,878
 plopp/widgets/box.py,sha256=v5Gd3sY0WXcc3UfkcXxZboPG02sfOMXIo50tmpxPwVs,1806
 plopp/widgets/checkboxes.py,sha256=52yJryEu1upYafFxqoTOdAZmHeKzCI_CJiCWSezCtRA,2430
-plopp/widgets/clip3d.py,sha256=L90HUd3bjEU3BaPdK8DnUbeeFNqfFyBWDEwaG9nP-M8,14602
+plopp/widgets/clip3d.py,sha256=NFJGCPsaGcTnlsP5ruW_jfFo4Ywx3zafuPiewpBSbYI,18409
 plopp/widgets/debounce.py,sha256=V5aIcnb465oqXZX-UG_DR7GjvoG6D_C2jjEUBmguGDA,1292
-plopp/widgets/drawing.py,sha256=Pcozffq7I5H9x57GNBJVvkCjVR6eaPBuxyHlFkEEjzQ,6252
-plopp/widgets/linesave.py,sha256=s5QcY-31x7Hvf9iLHmzfFIzodXTD9BX0Av3NlG8GS88,2458
-plopp/widgets/slice.py,sha256=rWBxvNru7m9PDWSjUUb-WGPCTDfOcNDQBjP88HFEqbc,5474
-plopp/widgets/style.py,sha256=Fw4S8te0xDyT8-kWu4Ut35aLgyr98qMlWZRbXbd1-dk,184
+plopp/widgets/drawing.py,sha256=z8gzzD4pN52V0BxHc8lw-CArGQGk0POS-ZGAPQqCAEw,8483
+plopp/widgets/linesave.py,sha256=gnxTT31xsSEroYMRriQNaxokM8cQPjhLPKwujoQTGVE,2459
+plopp/widgets/slice.py,sha256=rL_BiryBB_pITin1N3o7wRTGQaQksI3EEaJTG_040Jw,5477
+plopp/widgets/style.py,sha256=3qEdXNsat4bqk5BDqZie0Sqg2wvHn2zMrWvfFMq9W9M,185
 plopp/widgets/toolbar.py,sha256=GH4KKsPGBnNl-bllGD8gF__PgmKpr_QS7zL81GYXUWE,4697
-plopp/widgets/tools.py,sha256=9l7LmB8qG0OTt5ZJihJzqRna1ouxJthO_Ahnq7WKTtY,7172
-plopp-25.10.0.dist-info/licenses/LICENSE,sha256=fCqnkzCwkGneGtgOidkO2b3ed6SGZT0yhuworuJG0K0,1553
-plopp-25.10.0.dist-info/METADATA,sha256=FS_IwuAl8hOO2FAvEIMXpFhKYls7PgRX98XA8cnjT30,2850
-plopp-25.10.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-plopp-25.10.0.dist-info/top_level.txt,sha256=Lk_GLFh37eX-3PO3c6bPkDpir7GjJmbQHYza3IpIphc,6
-plopp-25.10.0.dist-info/RECORD,,
+plopp/widgets/tools.py,sha256=01JW4RSR72L2fs-2FkuSMVgBc1Eyq-NSNFIuPx7OWao,7176
+plopp-26.2.0.dist-info/licenses/LICENSE,sha256=fCqnkzCwkGneGtgOidkO2b3ed6SGZT0yhuworuJG0K0,1553
+plopp-26.2.0.dist-info/METADATA,sha256=JoXJTsXScaR-7BiSPMPBQvRIwslxSQ1gFJRO6LyNR-A,2900
+plopp-26.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+plopp-26.2.0.dist-info/top_level.txt,sha256=Lk_GLFh37eX-3PO3c6bPkDpir7GjJmbQHYza3IpIphc,6
+plopp-26.2.0.dist-info/RECORD,,

{plopp-25.10.0.dist-info → plopp-26.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any