fix(image): match the anti-aliasing kernel to the scaled data type

The scaling functions require the anti-aliasing kernel to have the data
type of the data they scale, which was not the case:

- when exporting an image area without the LUT but with the
  interpolation while the Z-axis log scale was enabled: the raw data was
  exported with the float64 kernel of its logarithm;
- after set_data with data of another type: the kernel kept the former
  type, so that drawing the image failed (aborting the application with
  PyQt5), as well as exporting it.

Add BaseImageItem._get_interpolation_for, which gives the kernel the data
type of the data to be scaled, used by all export_roi implementations,
and _sync_interpolation_dtype, which keeps the kernel in the data type of
the data drawn, now also called by set_data.

Refs #89

Assisted-by: Claude Opus 5.5

Author: PierreRaybaut

plotpy/items/image/base.py

@@ -516,6 +516,8 @@ def set_data(
         # display would keep using the previous (now stale) log data.
         if self._is_zaxis_log:
             self._recompute_log_data()
+        # The new data may have another data type than the previous one
+        self._sync_interpolation_dtype()
         if not self.param.keep_lut_range:
             if self._is_zaxis_log:
                 # The linear LUT range, restored when the log scale is disabled,
@@ -653,6 +655,33 @@ def get_interpolation(self) -> tuple[int] | tuple[int, np.ndarray]:
         """Get interpolation mode"""
         return self.interpolate
 
+    def _get_interpolation_for(
+        self, data: np.ndarray
+    ) -> tuple[int] | tuple[int, np.ndarray]:
+        """Return the interpolation mode to be used to scale the given data
+
+        The scaling functions require the anti-aliasing kernel to have the data
+        type of the data they scale, which is not always the data drawn (e.g. the
+        raw data, exported without the LUT, instead of its logarithm drawn with
+        the Z-axis logarithmic scale).
+
+        Args:
+            data: Data to be scaled
+
+        Returns:
+            Interpolation mode, with an anti-aliasing kernel of the data type of
+            the given data
+        """
+        interp = self.interpolate
+        if interp[0] == INTERP_AA and interp[1].dtype != data.dtype:
+            interp = (INTERP_AA, interp[1].astype(data.dtype))
+        return interp
+
+    def _sync_interpolation_dtype(self) -> None:
+        """Give the anti-aliasing kernel the data type of the data drawn"""
+        if self.data is not None:
+            self.interpolate = self._get_interpolation_for(self._get_display_data())
+
     def set_lut_range(self, lut_range: tuple[float, float]) -> None:
         """
         Set the current active lut range
@@ -759,9 +788,7 @@ def set_zaxis_log_state(self, state: bool) -> None:
             self._is_zaxis_log = False
             self._log_data = None
             self.set_lut_range(self._lin_lut_range)
-        if self.data is not None and self.interpolate[0] == INTERP_AA:
-            dtype = self._get_display_data().dtype
-            self.interpolate = (INTERP_AA, self.interpolate[1].astype(dtype))
+        self._sync_interpolation_dtype()
         plot = self.plot()
         if plot is not None:
             plot.update_colormap_axis(self)
@@ -892,7 +919,10 @@ def export_roi(
         else:
             a, b = 1.0, 0.0
             data = self.data
-        interp = self.interpolate if apply_interpolation else (INTERP_NEAREST,)
+        if apply_interpolation:
+            interp = self._get_interpolation_for(data)
+        else:
+            interp = (INTERP_NEAREST,)
         _scale_rect(data, src_rect, dst_image, dst_rect, (a, b, None), interp)
 
     # ---- QwtPlotItem API -----------------------------------------------------

plotpy/items/image/standard.py

@@ -404,7 +404,10 @@ def export_roi(
         else:
             a, b = 1.0, 0.0
             data = self.data
-        interp = self.interpolate if apply_interpolation else (INTERP_NEAREST,)
+        if apply_interpolation:
+            interp = self._get_interpolation_for(data)
+        else:
+            interp = (INTERP_NEAREST,)
         rescaled_src = self._rescale_src_rect(src_rect)
         _scale_rect(
             data,
@@ -697,7 +700,10 @@ def export_roi(
             a, b = 1.0, 0.0
             lut = (a, b, None, np.zeros((1,), np.uint32))
             data = self.data
-        interp = self.interpolate if apply_interpolation else (INTERP_NEAREST,)
+        if apply_interpolation:
+            interp = self._get_interpolation_for(data)
+        else:
+            interp = (INTERP_NEAREST,)
         xytr = self.x, self.y, src_rect
         _scale_xy(data, xytr, dst_image, dst_rect, lut, interp)
 

plotpy/items/image/transform.py

@@ -360,7 +360,7 @@ def export_roi(
                     aa = np.ones((force_interp_size, force_interp_size), data.dtype)
                     interp = (force_interp_mode, aa)
             else:  # don't force interpolation, keep current image interpolation
-                interp = self.interpolate
+                interp = self._get_interpolation_for(data)
         else:  # don't apply interpolation --> INTERP_NEAREST
             interp = (INTERP_NEAREST,)
         _scale_tr(data, mat, dst_image, dst_rect, (a, b, None), interp)

plotpy/tests/unit/test_image_aa_kernel.py

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+#
+# Licensed under the terms of the BSD 3-Clause
+# (see plotpy/LICENSE for details)
+
+"""Anti-aliasing interpolation kernel of image items (Issue #89).
+
+The scaling functions require the anti-aliasing kernel to have the data type of
+the data they scale: exporting and drawing an image must work whatever the Z-axis
+scale and the data type of the image data.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+from guidata.qthelpers import qt_app_context
+from qtpy import QtCore as QC
+from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
+from qwt import QwtScaleMap
+
+from plotpy.builder import make
+from plotpy.items import assemble_imageitems
+
+KINDS = ("image", "xyimage", "trimage", "maskedimage", "maskedxyimage")
+DTYPES = (np.uint8, np.uint16, np.int32, np.float32)
+NY, NX = 6, 8
+
+
+def _data(dtype: type) -> np.ndarray:
+    """Return image data of the given data type"""
+    return np.arange(1, NY * NX + 1).reshape(NY, NX).astype(dtype)
+
+
+def _make_item(kind: str, data: np.ndarray):
+    """Return an image item of the given kind, with the anti-aliasing
+    interpolation"""
+    x, y = np.arange(NX, dtype=float), np.arange(NY, dtype=float)
+    mask = np.zeros(data.shape, dtype=bool)
+    interpolation = "antialiasing"
+    builders = {
+        "image": lambda: make.image(data, interpolation=interpolation),
+        "xyimage": lambda: make.xyimage(x, y, data, interpolation=interpolation),
+        "trimage": lambda: make.trimage(data, interpolation=interpolation),
+        "maskedimage": lambda: make.maskedimage(
+            data, mask, interpolation=interpolation
+        ),
+        "maskedxyimage": lambda: make.maskedxyimage(
+            x, y, data, mask, interpolation=interpolation
+        ),
+    }
+    return builders[kind]()
+
+
+def _export(item, apply_lut: bool) -> np.ndarray:
+    """Export the image with its interpolation"""
+    rect = QC.QRectF(0, 0, NX, NY)
+    return assemble_imageitems(
+        [item], rect, NX, NY, apply_lut=apply_lut, apply_interpolation=True
+    )
+
+
+def _draw(item) -> None:
+    """Draw the image item on an image, raising the exceptions which would be
+    raised in the plot's paint event"""
+    width, height = 4 * NX, 4 * NY
+    xmap, ymap = QwtScaleMap(), QwtScaleMap()
+    xmap.setPaintInterval(0, width)
+    xmap.setScaleInterval(0, NX)
+    ymap.setPaintInterval(0, height)
+    ymap.setScaleInterval(0, NY)
+    image = QG.QImage(width, height, QG.QImage.Format_ARGB32)
+    painter = QG.QPainter(image)
+    try:
+        item.draw(painter, xmap, ymap, QC.QRectF(0, 0, width, height))
+    finally:
+        painter.end()
+
+
+def _plot_with_item(item):
+    """Return a plot window showing the image item"""
+    # In unattended mode, leaving a `qt_app_context` schedules the closing of all
+    # top-level widgets: process it now, so that it does not close this window
+    QW.QApplication.processEvents()
+    win = make.dialog(type="image")
+    win.manager.get_plot().add_item(item)
+    return win
+
+
+@pytest.mark.parametrize("dtype", DTYPES)
+@pytest.mark.parametrize("kind", KINDS)
+def test_export_with_anti_aliasing(kind: str, dtype: type) -> None:
+    """Exporting an image area with the anti-aliasing interpolation works with or
+    without the LUT, with or without the Z-axis log scale"""
+    with qt_app_context(exec_loop=False):
+        item = _make_item(kind, _data(dtype))
+        for log_state in (False, True):
+            item.set_zaxis_log_state(log_state)
+            for apply_lut in (False, True):
+                assert _export(item, apply_lut).shape == (NY, NX)
+
+
+@pytest.mark.parametrize("kind", KINDS)
+def test_set_data_of_another_data_type(kind: str) -> None:
+    """After replacing the data by data of another type, the kernel has the data
+    type of the data drawn, and the image can be drawn and exported"""
+    with qt_app_context(exec_loop=False):
+        item = _make_item(kind, _data(np.uint16))
+        win = _plot_with_item(item)
+        for log_state in (False, True):
+            item.set_zaxis_log_state(log_state)
+            for dtype in (np.float32, np.uint8):
+                item.set_data(_data(dtype))
+                # With the log scale, the data drawn is the float64 logarithm
+                expected_dtype = np.float64 if log_state else dtype
+                assert item.interpolate[1].dtype == expected_dtype
+                _draw(item)
+                for apply_lut in (False, True):
+                    assert _export(item, apply_lut).shape == (NY, NX)
+        win.close()
+
+
+if __name__ == "__main__":
+    for _kind in KINDS:
+        for _dtype in DTYPES:
+            test_export_with_anti_aliasing(_kind, _dtype)
+        test_set_data_of_another_data_type(_kind)