plopp 25.3.0__py3-none-any.whl → 25.4.1__py3-none-any.whl

plopp/backends/common.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright (c) 2023 Scipp contributors (https://github.com/scipp)
 
+import uuid
 from typing import Literal
 
 import numpy as np
@@ -98,15 +99,16 @@ def make_line_bbox(
         The scale of the y-axis.
     """
     line_x = data.coords[dim]
-    sel = slice(None)
-    if data.masks:
-        sel = ~merge_masks(data.masks)
-        if set(sel.dims) != set(data.data.dims):
-            sel = sc.broadcast(sel, sizes=data.data.sizes).copy()
-    line_y = data.data[sel]
     if errorbars:
-        stddevs = sc.stddevs(data.data[sel])
-        line_y = sc.concat([line_y - stddevs, line_y + stddevs], dim)
+        stddevs = sc.stddevs(data.data)
+        line_y = sc.DataArray(
+            data=sc.concat(
+                [data.data - stddevs, data.data + stddevs], dim=uuid.uuid4().hex
+            ),
+            masks=data.masks,
+        )
+    else:
+        line_y = data
 
     return BoundingBox(
         **{**axis_bounds(('xmin', 'xmax'), line_x, xscale, pad=True)},

plopp/backends/matplotlib/fast_image.py

@@ -0,0 +1,203 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+
+import uuid
+import warnings
+from typing import Literal
+
+import numpy as np
+import scipp as sc
+
+from ...core.utils import coord_as_bin_edges, scalar_to_string
+from ...graphics.bbox import BoundingBox, axis_bounds
+from ...graphics.colormapper import ColorMapper
+from ..common import check_ndim
+from .canvas import Canvas
+
+
+class FastImage:
+    """
+    Artist to represent two-dimensional data.
+
+    Parameters
+    ----------
+    canvas:
+        The canvas that will display the image.
+    colormapper:
+        The colormapper to use for the image.
+    data:
+        The initial data to create the image from.
+    artist_number:
+        The canvas keeps track of how many images have been added to it. This is unused
+        by the FastImage artist.
+    uid:
+        The unique identifier of the artist. If None, a random UUID is generated.
+    **kwargs:
+        Additional arguments are forwarded to Matplotlib's ``imshow``.
+    """
+
+    def __init__(
+        self,
+        canvas: Canvas,
+        colormapper: ColorMapper,
+        data: sc.DataArray,
+        artist_number: int,
+        uid: str | None = None,
+        **kwargs,
+    ):
+        check_ndim(data, ndim=2, origin="FastImage")
+        self.uid = uid if uid is not None else uuid.uuid4().hex
+        self._canvas = canvas
+        self._colormapper = colormapper
+        self._ax = self._canvas.ax
+        self._data = data
+
+        string_labels = {}
+        self._bin_edge_coords = {}
+        for i, k in enumerate("yx"):
+            self._bin_edge_coords[k] = coord_as_bin_edges(
+                self._data, self._data.dims[i]
+            )
+            if self._data.coords[self._data.dims[i]].dtype == str:
+                string_labels[k] = self._data.coords[self._data.dims[i]]
+
+        self._xmin, self._xmax = self._bin_edge_coords["x"].values[[0, -1]]
+        self._ymin, self._ymax = self._bin_edge_coords["y"].values[[0, -1]]
+        self._dx = np.diff(self._bin_edge_coords["x"].values[:2])
+        self._dy = np.diff(self._bin_edge_coords["y"].values[:2])
+
+        # Calling imshow sets the aspect ratio to 'equal', which might not be what the
+        # user requested. We need to restore the original aspect ratio after making the
+        # image.
+        original_aspect = self._ax.get_aspect()
+
+        # Because imshow sets the aspect, it may generate warnings when the axes scales
+        # are log.
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                category=UserWarning,
+                message="Attempt to set non-positive .* on a log-scaled axis",
+            )
+            self._image = self._ax.imshow(
+                self._data.values,
+                origin="lower",
+                extent=(self._xmin, self._xmax, self._ymin, self._ymax),
+                **({"interpolation": "nearest"} | kwargs),
+            )
+
+        self._ax.set_aspect(original_aspect)
+        self._colormapper.add_artist(self.uid, self)
+        self._update_colors()
+
+        for xy, var in string_labels.items():
+            getattr(self._ax, f"set_{xy}ticks")(np.arange(float(var.shape[0])))
+            getattr(self._ax, f"set_{xy}ticklabels")(var.values)
+
+        self._canvas.register_format_coord(self.format_coord)
+        # We also hide the cursor hover values generated by the image, as values are
+        # included in our custom format_coord.
+        self._image.format_cursor_data = lambda _: ""
+
+    @property
+    def data(self):
+        """
+        Get the image's data in a form that may have been tweaked, compared to the
+        original data, in the case of a two-dimensional coordinate.
+        """
+        return self._data
+
+    def notify_artist(self, message: str) -> None:
+        """
+        Receive notification from the colormapper that its state has changed.
+        We thus need to update the colors of the image.
+
+        Parameters
+        ----------
+        message:
+            The message from the colormapper.
+        """
+        self._update_colors()
+
+    def _update_colors(self):
+        """
+        Update the image colors.
+        """
+        rgba = self._colormapper.rgba(self.data)
+        self._image.set_data(rgba)
+
+    def update(self, new_values: sc.DataArray):
+        """
+        Update image array with new values.
+
+        Parameters
+        ----------
+        new_values:
+            New data to update the image values from.
+        """
+        check_ndim(new_values, ndim=2, origin="FastImage")
+        self._data = new_values
+        self._update_colors()
+
+    def format_coord(
+        self, xslice: tuple[str, sc.Variable], yslice: tuple[str, sc.Variable]
+    ) -> str:
+        """
+        Format the coordinates of the mouse pointer to show the value of the
+        data at that point.
+
+        Parameters
+        ----------
+        xslice:
+            Dimension and x coordinate of the mouse pointer, as slice parameters.
+        yslice:
+            Dimension and y coordinate of the mouse pointer, as slice parameters.
+        """
+        ind_x = int((xslice[1].value - self._xmin) / self._dx)
+        ind_y = int((yslice[1].value - self._ymin) / self._dy)
+        try:
+            val = self._data[yslice[0], ind_y][xslice[0], ind_x]
+            prefix = self._data.name
+            if prefix:
+                prefix += ": "
+            return prefix + scalar_to_string(val)
+        except IndexError:
+            return None
+
+    @property
+    def visible(self) -> bool:
+        """
+        The visibility of the image.
+        """
+        return self._image.get_visible()
+
+    @visible.setter
+    def visible(self, val: bool):
+        self._image.set_visible(val)
+
+    @property
+    def opacity(self) -> float:
+        """
+        The opacity of the image.
+        """
+        return self._image.get_alpha()
+
+    @opacity.setter
+    def opacity(self, val: float):
+        self._image.set_alpha(val)
+
+    def bbox(self, xscale: Literal["linear", "log"], yscale: Literal["linear", "log"]):
+        """
+        The bounding box of the image.
+        """
+        return BoundingBox(
+            **{**axis_bounds(("xmin", "xmax"), self._bin_edge_coords["x"], xscale)},
+            **{**axis_bounds(("ymin", "ymax"), self._bin_edge_coords["y"], yscale)},
+        )
+
+    def remove(self):
+        """
+        Remove the image artist from the canvas.
+        """
+        self._image.remove()
+        self._colormapper.remove_artist(self.uid)

plopp/backends/matplotlib/image.py

@@ -1,251 +1,36 @@
 # SPDX-License-Identifier: BSD-3-Clause
-# Copyright (c) 2023 Scipp contributors (https://github.com/scipp)
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
 
-import uuid
-from typing import Literal
-
-import numpy as np
 import scipp as sc
 
-from ...core.utils import coord_as_bin_edges, merge_masks, repeat, scalar_to_string
-from ...graphics.bbox import BoundingBox, axis_bounds
-from ...graphics.colormapper import ColorMapper
-from ..common import check_ndim
 from .canvas import Canvas
+from .fast_image import FastImage
+from .mesh_image import MeshImage
 
 
-def _find_dim_of_2d_coord(coords):
-    for xy, coord in coords.items():
-        if coord['var'].ndim == 2:
-            return (xy, coord['dim'])
-
-
-def _get_dims_of_1d_and_2d_coords(coords):
-    dim_2d = _find_dim_of_2d_coord(coords)
-    if dim_2d is None:
-        return None, None
-    axis_1d = 'xy'.replace(dim_2d[0], '')
-    dim_1d = (axis_1d, coords[axis_1d]['dim'])
-    return dim_1d, dim_2d
-
-
-def _maybe_repeat_values(data, dim_1d, dim_2d):
-    if dim_2d is None:
-        return data
-    return repeat(data, dim=dim_1d[1], n=2)[dim_1d[1], :-1]
-
-
-def _from_data_array_to_pcolormesh(data, coords, dim_1d, dim_2d):
-    z = _maybe_repeat_values(data=data, dim_1d=dim_1d, dim_2d=dim_2d)
-    if dim_2d is None:
-        return coords['x'], coords['y'], z
-
-    # Broadcast 1d coord to 2d and repeat along 1d dim
-    # TODO: It may be more efficient here to first repeat and then broadcast, but
-    # the current order is simpler in implementation.
-    broadcasted_coord = repeat(
-        sc.broadcast(
-            coords[dim_1d[0]],
-            sizes={**coords[dim_2d[0]].sizes, **coords[dim_1d[0]].sizes},
-        ).transpose(data.dims),
-        dim=dim_1d[1],
-        n=2,
-    )
-    # Repeat 2d coord along 1d dim
-    repeated_coord = repeat(coords[dim_2d[0]].transpose(data.dims), dim=dim_1d[1], n=2)
-    out = {dim_1d[0]: broadcasted_coord[dim_1d[1], 1:-1], dim_2d[0]: repeated_coord}
-    return out['x'], out['y'], z
-
-
-class Image:
+def Image(
+    canvas: Canvas,
+    data: sc.DataArray,
+    **kwargs,
+):
     """
-    Artist to represent two-dimensional data.
+    Factory function to create an image artist.
+    If all the coordinates of the data are 1D and linearly spaced,
+    a `FastImage` is created.
+    Otherwise, a `MeshImage` is created.
 
     Parameters
     ----------
     canvas:
         The canvas that will display the image.
-    colormapper:
-        The colormapper to use for the image.
     data:
-        The initial data to create the image from.
-    uid:
-        The unique identifier of the artist. If None, a random UUID is generated.
-    shading:
-        The shading to use for the ``pcolormesh``.
-    rasterized:
-        Rasterize the mesh/image if ``True``.
-    **kwargs:
-        Additional arguments are forwarded to Matplotlib's ``pcolormesh``.
+        The data to create the image from.
     """
-
-    def __init__(
-        self,
-        canvas: Canvas,
-        colormapper: ColorMapper,
-        data: sc.DataArray,
-        uid: str | None = None,
-        shading: str = 'auto',
-        rasterized: bool = True,
-        **kwargs,
+    if (canvas.ax.name != 'polar') and all(
+        (data.coords[dim].ndim < 2)
+        and ((data.coords[dim].dtype == str) or (sc.islinspace(data.coords[dim])))
+        for dim in data.dims
     ):
-        check_ndim(data, ndim=2, origin='Image')
-        self.uid = uid if uid is not None else uuid.uuid4().hex
-        self._canvas = canvas
-        self._colormapper = colormapper
-        self._ax = self._canvas.ax
-        self._data = data
-        # Because all keyword arguments from the figure are forwarded to both the canvas
-        # and the line, we need to remove the arguments that belong to the canvas.
-        kwargs.pop('ax', None)
-        kwargs.pop('cax', None)
-        # An artist number is passed to the artist, but is unused for the image.
-        kwargs.pop('artist_number', None)
-        # If the grid is visible on the axes, we need to set that on again after we
-        # call pcolormesh, because that turns the grid off automatically.
-        # See https://github.com/matplotlib/matplotlib/issues/15600.
-        need_grid = self._ax.xaxis.get_gridlines()[0].get_visible()
-
-        to_dim_search = {}
-        string_labels = {}
-        bin_edge_coords = {}
-        self._data_with_bin_edges = sc.DataArray(data=self._data.data)
-        for i, k in enumerate('yx'):
-            to_dim_search[k] = {
-                'dim': self._data.dims[i],
-                'var': self._data.coords[self._data.dims[i]],
-            }
-            bin_edge_coords[k] = coord_as_bin_edges(self._data, self._data.dims[i])
-            self._data_with_bin_edges.coords[self._data.dims[i]] = bin_edge_coords[k]
-            if self._data.coords[self._data.dims[i]].dtype == str:
-                string_labels[k] = self._data.coords[self._data.dims[i]]
-
-        self._dim_1d, self._dim_2d = _get_dims_of_1d_and_2d_coords(to_dim_search)
-        self._mesh = None
-
-        x, y, z = _from_data_array_to_pcolormesh(
-            data=self._data.data,
-            coords=bin_edge_coords,
-            dim_1d=self._dim_1d,
-            dim_2d=self._dim_2d,
-        )
-        self._mesh = self._ax.pcolormesh(
-            x.values,
-            y.values,
-            z.values,
-            shading=shading,
-            rasterized=rasterized,
-            **kwargs,
-        )
-
-        self._colormapper.add_artist(self.uid, self)
-        self._mesh.set_array(None)
-        self._update_colors()
-
-        for xy, var in string_labels.items():
-            getattr(self._ax, f'set_{xy}ticks')(np.arange(float(var.shape[0])))
-            getattr(self._ax, f'set_{xy}ticklabels')(var.values)
-
-        if need_grid:
-            self._ax.grid(True)
-
-        self._canvas.register_format_coord(self.format_coord)
-
-    @property
-    def data(self):
-        """
-        Get the Mesh's data in a form that may have been tweaked, compared to the
-        original data, in the case of a two-dimensional coordinate.
-        """
-        out = sc.DataArray(
-            data=_maybe_repeat_values(
-                data=self._data.data, dim_1d=self._dim_1d, dim_2d=self._dim_2d
-            )
-        )
-        if self._data.masks:
-            out.masks['one_mask'] = _maybe_repeat_values(
-                data=sc.broadcast(
-                    merge_masks(self._data.masks),
-                    dims=self._data.dims,
-                    shape=self._data.shape,
-                ),
-                dim_1d=self._dim_1d,
-                dim_2d=self._dim_2d,
-            )
-        return out
-
-    def notify_artist(self, message: str) -> None:
-        """
-        Receive notification from the colormapper that its state has changed.
-        We thus need to update the colors of the mesh.
-
-        Parameters
-        ----------
-        message:
-            The message from the colormapper.
-        """
-        self._update_colors()
-
-    def _update_colors(self):
-        """
-        Update the mesh colors.
-        """
-        rgba = self._colormapper.rgba(self.data)
-        self._mesh.set_facecolors(rgba.reshape(np.prod(rgba.shape[:-1]), 4))
-
-    def update(self, new_values: sc.DataArray):
-        """
-        Update image array with new values.
-
-        Parameters
-        ----------
-        new_values:
-            New data to update the mesh values from.
-        """
-        check_ndim(new_values, ndim=2, origin='Image')
-        self._data = new_values
-        self._data_with_bin_edges.data = new_values.data
-        self._update_colors()
-
-    def format_coord(
-        self, xslice: tuple[str, sc.Variable], yslice: tuple[str, sc.Variable]
-    ) -> str:
-        """
-        Format the coordinates of the mouse pointer to show the value of the
-        data at that point.
-
-        Parameters
-        ----------
-        xslice:
-            Dimension and x coordinate of the mouse pointer, as slice parameters.
-        yslice:
-            Dimension and y coordinate of the mouse pointer, as slice parameters.
-        """
-        try:
-            val = self._data_with_bin_edges[yslice][xslice]
-            prefix = self._data.name
-            if prefix:
-                prefix += ': '
-            return prefix + scalar_to_string(val)
-        except (IndexError, RuntimeError):
-            return None
-
-    def bbox(self, xscale: Literal['linear', 'log'], yscale: Literal['linear', 'log']):
-        """
-        The bounding box of the image.
-        """
-        ydim, xdim = self._data.dims
-        image_x = self._data_with_bin_edges.coords[xdim]
-        image_y = self._data_with_bin_edges.coords[ydim]
-
-        return BoundingBox(
-            **{**axis_bounds(('xmin', 'xmax'), image_x, xscale)},
-            **{**axis_bounds(('ymin', 'ymax'), image_y, yscale)},
-        )
-
-    def remove(self):
-        """
-        Remove the image artist from the canvas.
-        """
-        self._mesh.remove()
-        self._colormapper.remove_artist(self.uid)
+        return FastImage(canvas=canvas, data=data, **kwargs)
+    else:
+        return MeshImage(canvas=canvas, data=data, **kwargs)

plopp/backends/matplotlib/line.py

@@ -58,9 +58,6 @@ class Line:
         self._canvas = canvas
         self._ax = self._canvas.ax
         self._data = data
-        # Because all keyword arguments from the figure are forwarded to both the canvas
-        # and the line, we need to remove the arguments that belong to the canvas.
-        kwargs.pop('ax', None)
 
         line_args = parse_dicts_in_kwargs(kwargs, name=data.name)
 
@@ -84,6 +81,7 @@ class Line:
             'linestyle': 'solid',
             'linewidth': 1.5,
             'color': f'C{artist_number}',
+            'zorder': 2,
         }
         markers = list(Line2D.markers.keys())
         default_plot_style = {
@@ -91,6 +89,7 @@ class Line:
             'linewidth': 1.5,
             'marker': markers[(artist_number + 2) % len(markers)],
             'color': f'C{artist_number}',
+            'zorder': 2,
         }
 
         if line_data["hist"]:
@@ -98,40 +97,35 @@ class Line:
                 line_data['values']['x'],
                 line_data['values']['y'],
                 label=self.label,
-                zorder=10,
                 **{**default_step_style, **line_args},
             )[0]
 
             self._mask = self._ax.step(line_data['mask']['x'], line_data['mask']['y'])[
                 0
             ]
-            self._mask.update_from(self._line)
-            self._mask.set_color(mask_color)
-            self._mask.set_label(None)
-            self._mask.set_linewidth(self._mask.get_linewidth() * 3)
-            self._mask.set_zorder(self._mask.get_zorder() - 1)
-            self._mask.set_visible(line_data['mask']['visible'])
         else:
             self._line = self._ax.plot(
                 line_data['values']['x'],
                 line_data['values']['y'],
                 label=self.label,
-                zorder=10,
                 **{**default_plot_style, **line_args},
             )[0]
-            self._mask = self._ax.plot(
-                line_data['mask']['x'],
-                line_data['mask']['y'],
-                zorder=11,
-                mec=mask_color,
-                mfc="None",
-                mew=3.0,
-                linestyle="none",
-                marker=self._line.get_marker(),
-                visible=line_data['mask']['visible'],
-            )[0]
+            self._mask = self._ax.plot(line_data['mask']['x'], line_data['mask']['y'])[
+                0
+            ]
 
-        self.line_mask = sc.array(dims=['x'], values=~np.isnan(line_data['mask']['y']))
+        self._mask.update_from(self._line)
+        self._mask.set_color(mask_color)
+        self._mask.set_label(None)
+        self._mask.set_visible(line_data['mask']['visible'])
+        if self._line.get_marker().lower() != 'none':
+            self._mask.set(
+                mec=mask_color, mfc='None', mew=3.0, zorder=self._line.get_zorder() + 1
+            )
+        if self._line.get_linestyle().lower() != 'none':
+            self._mask.set(
+                lw=self._line.get_linewidth() * 3, zorder=self._line.get_zorder() - 1
+            )
 
         # Add error bars
         if errorbars and (line_data['stddevs'] is not None):
@@ -140,7 +134,7 @@ class Line:
                 line_data['stddevs']['y'],
                 yerr=line_data['stddevs']['e'],
                 color=self._line.get_color(),
-                zorder=10,
+                zorder=self._line.get_zorder(),
                 fmt="none",
             )
 
@@ -156,7 +150,6 @@ class Line:
         check_ndim(new_values, ndim=1, origin='Line')
         self._data = new_values
         line_data = make_line_data(data=self._data, dim=self._dim)
-        self.line_mask = sc.array(dims=['x'], values=~np.isnan(line_data['mask']['y']))
 
         self._line.set_data(line_data['values']['x'], line_data['values']['y'])
         self._mask.set_data(line_data['mask']['x'], line_data['mask']['y'])
@@ -191,20 +184,89 @@ class Line:
         self._canvas.draw()
 
     @property
-    def color(self):
+    def color(self) -> str:
         """
         The line color.
         """
         return self._line.get_color()
 
     @color.setter
-    def color(self, val):
+    def color(self, val: str):
         self._line.set_color(val)
         if self._error is not None:
             for artist in self._error.get_children():
                 artist.set_color(val)
         self._canvas.draw()
 
+    @property
+    def style(self) -> str:
+        """
+        The line style.
+        """
+        return self._line.get_linestyle()
+
+    @style.setter
+    def style(self, val: str):
+        self._line.set_linestyle(val)
+        self._canvas.draw()
+
+    @property
+    def width(self) -> float:
+        """
+        The line width.
+        """
+        return self._line.get_linewidth()
+
+    @width.setter
+    def width(self, val: float):
+        self._line.set_linewidth(val)
+        self._canvas.draw()
+
+    @property
+    def marker(self) -> str:
+        """
+        The line marker.
+        """
+        return self._line.get_marker()
+
+    @marker.setter
+    def marker(self, val: str):
+        self._line.set_marker(val)
+        self._mask.set_marker(val)
+        self._canvas.draw()
+
+    @property
+    def visible(self) -> bool:
+        """
+        Whether the line is visible.
+        """
+        return self._line.get_visible()
+
+    @visible.setter
+    def visible(self, val: bool):
+        self._line.set_visible(val)
+        self._mask.set_visible(val)
+        if self._error is not None:
+            for artist in self._error.get_children():
+                artist.set_visible(val)
+        self._canvas.draw()
+
+    @property
+    def opacity(self) -> float:
+        """
+        The line opacity.
+        """
+        return self._line.get_alpha()
+
+    @opacity.setter
+    def opacity(self, val: float):
+        self._line.set_alpha(val)
+        self._mask.set_alpha(val)
+        if self._error is not None:
+            for artist in self._error.get_children():
+                artist.set_alpha(val)
+        self._canvas.draw()
+
     def bbox(
         self, xscale: Literal['linear', 'log'], yscale: Literal['linear', 'log']
     ) -> BoundingBox: