fix(image): render images at the screen resolution

With a display scaling such as 125%, 150% or 200%, image items were rendered
in an offscreen image of the canvas size (logical pixels), which was then
upscaled to the screen: images were shown with half the screen resolution
with a 200% scaling, and with one screen pixel row and column out of five
duplicated with a 125% scaling.

The offscreen image is now rendered at the resolution of the paint device,
given by the painter device transform (`get_offscreen_ratio`). Destination
rectangles are converted to offscreen image pixels (`_offscreen_rect`) and
the offscreen image is drawn back in canvas coordinates (`_draw_offscreen`),
so that the `draw_image` API is unchanged. Printing and exporting with a
scaling painter transform keep the canvas resolution, as does the new
`image/device_resolution` option of the `plot` configuration section when
disabled. The rendering is unchanged with a 100% scaling.

Converting destination rectangles to integers also fixes `RawImageItem`,
whose drawing failed with "Invalid destination rectangle" errors.

Assisted-by: Claude Opus 5.5

Author: PierreRaybaut

plotpy/config.py

@@ -52,6 +52,8 @@ def get_plotpy_defaults() -> dict[str, int | float | str | bool]:
             "curve/cosmetic_hairline": True,
             # Draw thick curves as several one-pixel strokes on screen
             "curve/fast_thick_lines": True,
+            # Render images at the resolution of the screen (e.g. 125%, 200%)
+            "image/device_resolution": True,
             "title/font/size": 12,
             "title/font/bold": False,
             "selected_curve_symbol/marker": "Rect",

plotpy/items/image/base.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import math
 import os
 import os.path as osp
 from collections import OrderedDict
@@ -25,7 +26,7 @@
     _histogram,
     _scale_rect,
 )
-from plotpy.config import _
+from plotpy.config import CONF, _
 from plotpy.constants import LUT_MAX, LUT_SIZE, LUTAlpha
 from plotpy.coords import pixelround
 from plotpy.interfaces import (
@@ -165,6 +166,35 @@ def _get_colormap_lut(
     return colors, lut
 
 
+def get_offscreen_ratio(painter: QPainter) -> float:
+    """Return the resolution at which image items are rendered before being
+    drawn with the given painter, in pixels per canvas pixel.
+
+    Images are rendered at the resolution of the paint device, e.g. 1.25 or 2
+    pixels per canvas pixel with a 125% or 200% screen scaling, instead of being
+    upscaled from the canvas resolution, which takes more time (up to about 4
+    times with a 200% screen scaling). Images are rendered at the canvas
+    resolution when printing or exporting with a scaling (or rotating) painter
+    transform, or when the ``image/device_resolution`` option of the ``plot``
+    configuration section is disabled.
+
+    Args:
+        painter: Painter
+
+    Returns:
+        Resolution, in pixels per canvas pixel
+    """
+    world = painter.worldTransform()
+    if (
+        world.isScaling()
+        or world.isRotating()
+        or not CONF.get("plot", "image/device_resolution", True)
+    ):
+        return 1.0
+    ratio = abs(painter.deviceTransform().m11())
+    return ratio if ratio > 0.0 else 1.0
+
+
 class BaseImageItem(QwtPlotItem):
     """Base class for image items
 
@@ -229,6 +259,8 @@ def __init__(
         self._image: QG.QImage | None = None
 
         self._offscreen = np.array((1, 1), np.uint32)
+        #: Resolution of the offscreen image, in pixels per canvas pixel
+        self._offscreen_ratio = 1.0
 
         # Linear interpolation is the default interpolation algorithm:
         # it's almost as fast as 'nearest pixel' method but far smoother
@@ -882,12 +914,39 @@ def draw_image(
             self._get_display_data(),
             src_rect,
             self._offscreen,
-            dst_rect,
+            self._offscreen_rect(dst_rect),
             self.lut,
             self.interpolate,
         )
-        qrect = QC.QRectF(QC.QPointF(dest[0], dest[1]), QC.QPointF(dest[2], dest[3]))
-        painter.drawImage(qrect, self._image, qrect)
+        self._draw_offscreen(painter, dest)
+
+    def _offscreen_rect(
+        self, rect: tuple[float, float, float, float]
+    ) -> tuple[int, int, int, int]:
+        """Convert a rectangle from canvas coordinates to offscreen image pixels
+
+        Args:
+            rect: Rectangle (x1, y1, x2, y2), in canvas coordinates
+
+        Returns:
+            Rectangle (x1, y1, x2, y2), in offscreen image pixels
+        """
+        ratio = self._offscreen_ratio
+        return tuple(int(value * ratio) for value in rect)
+
+    def _draw_offscreen(
+        self, painter: QPainter, rect: tuple[int, int, int, int]
+    ) -> None:
+        """Draw a part of the offscreen image on the canvas
+
+        Args:
+            painter: Painter
+            rect: Rectangle (x1, y1, x2, y2) to be drawn, in offscreen image pixels
+        """
+        source = QC.QRectF(QC.QPointF(rect[0], rect[1]), QC.QPointF(rect[2], rect[3]))
+        ratio = self._offscreen_ratio
+        target = QC.QRectF(source.topLeft() / ratio, source.bottomRight() / ratio)
+        painter.drawImage(target, self._image, source)
 
     def export_roi(
         self,
@@ -941,20 +1000,26 @@ def draw(
             yMap: Y axis scale map
             canvasRect: Canvas rectangle
         """
-        x1, y1, x2, y2 = canvasRect.getCoords()
+        # The offscreen image covers the canvas at the resolution of the paint
+        # device (see `get_offscreen_ratio`), rounded up to whole pixels
+        ratio = self._offscreen_ratio = get_offscreen_ratio(painter)
+        W = math.ceil(canvasRect.right() * ratio)
+        H = math.ceil(canvasRect.bottom() * ratio)
+        x1, y1 = canvasRect.left(), canvasRect.top()
+        x2, y2 = W / ratio, H / ratio
         i1, i2 = xMap.invTransform(x1), xMap.invTransform(x2)
         j1, j2 = yMap.invTransform(y1), yMap.invTransform(y2)
 
+        # Destination rectangle, extended by one offscreen image pixel to the right
+        # and to the bottom (offscreen image pixels being truncated)
         xl, yt, xr, yb = self.boundingRect().getCoords()
         dest = (
             xMap.transform(xl),
             yMap.transform(yt),
-            xMap.transform(xr) + 1,
-            yMap.transform(yb) + 1,
+            xMap.transform(xr) + 1 / ratio,
+            yMap.transform(yb) + 1 / ratio,
         )
 
-        W = int(canvasRect.right())
-        H = int(canvasRect.bottom())
         if self._offscreen.shape != (H, W):
             self._offscreen = np.empty((H, W), np.uint32)
             self._image = QG.QImage(self._offscreen, W, H, QG.QImage.Format_ARGB32)

plotpy/items/image/filter.py

@@ -349,12 +349,11 @@ def draw_image(
             new_data,
             (x, y, src_rect),
             self._offscreen,
-            dstRect.getCoords(),
+            self._offscreen_rect(dstRect.getCoords()),
             lut,
             self.interpolate,
         )
-        qrect = QC.QRectF(QC.QPointF(dest[0], dest[1]), QC.QPointF(dest[2], dest[3]))
-        painter.drawImage(qrect, self._image, qrect)
+        self._draw_offscreen(painter, dest)
 
 
 assert_interfaces_valid(ImageFilterItem)

plotpy/items/image/masked.py

@@ -7,7 +7,6 @@
 import guidata.io
 import numpy as np
 import numpy.ma as ma
-from qtpy import QtCore as QC
 
 from plotpy import io
 from plotpy._scaler import INTERP_NEAREST, _scale_rect, _scale_xy
@@ -556,14 +555,11 @@ def draw_image(
             lut = (1, 0, bg, cmap)
             shown_data = np.ma.getmaskarray(self.data)
             src2 = self._rescale_src_rect(src_rect)
-            dst_rect = tuple([int(i) for i in dst_rect])
+            dst_rect = self._offscreen_rect(dst_rect)
             dest = _scale_rect(
                 shown_data, src2, self._offscreen, dst_rect, lut, (INTERP_NEAREST,)
             )
-            qrect = QC.QRectF(
-                QC.QPointF(dest[0], dest[1]), QC.QPointF(dest[2], dest[3])
-            )
-            painter.drawImage(qrect, self._image, qrect)
+            self._draw_offscreen(painter, dest)
 
     # ---- RawImageItem API -----------------------------------------------------
     def set_data(
@@ -734,14 +730,11 @@ def draw_image(
             shown_data = np.ma.getmaskarray(self.data)
 
             xytr = self.x, self.y, src_rect
-            dst_rect = tuple([int(i) for i in dst_rect])
+            dst_rect = self._offscreen_rect(dst_rect)
             dest = _scale_xy(
                 shown_data, xytr, self._offscreen, dst_rect, lut, (INTERP_NEAREST,)
             )
-            qrect = QC.QRectF(
-                QC.QPointF(dest[0], dest[1]), QC.QPointF(dest[2], dest[3])
-            )
-            painter.drawImage(qrect, self._image, qrect)
+            self._draw_offscreen(painter, dest)
 
     def set_data(
         self, data: np.ndarray, lut_range: list[float, float] | None = None

plotpy/items/image/misc.py

@@ -180,13 +180,12 @@ def draw_image(
             self.data,
             src_rect,
             self._offscreen,
-            dst_rect,
+            self._offscreen_rect(dst_rect),
             self.lut,
             self.interpolate,
             self.grid,
         )
-        qrect = QC.QRectF(QC.QPointF(dest[0], dest[1]), QC.QPointF(dest[2], dest[3]))
-        painter.drawImage(qrect, self._image, qrect)
+        self._draw_offscreen(painter, dest)
         xl, yt, xr, yb = dest
         self._offscreen[yt:yb, xl:xr] = 0
 

plotpy/items/image/standard.py

@@ -357,7 +357,7 @@ def draw_image(
             return
 
         src2 = self._rescale_src_rect(src_rect)
-        dst_rect = tuple([int(i) for i in dst_rect])
+        dst_rect = self._offscreen_rect(dst_rect)
 
         try:
             dest = _scale_rect(
@@ -371,8 +371,7 @@ def draw_image(
         except ValueError:
             # This exception is raised when zooming unreasonably inside a pixel
             return
-        qrect = QC.QRectF(QC.QPointF(dest[0], dest[1]), QC.QPointF(dest[2], dest[3]))
-        painter.drawImage(qrect, self._image, qrect)
+        self._draw_offscreen(painter, dest)
 
     def export_roi(
         self,
@@ -658,7 +657,7 @@ def draw_image(
         if self.warn_if_non_linear_scale(painter, canvasRect):
             return
         xytr = self.x, self.y, src_rect
-        dst_rect = tuple([int(i) for i in dst_rect])
+        dst_rect = self._offscreen_rect(dst_rect)
         dest = _scale_xy(
             self._get_display_data(),
             xytr,
@@ -667,8 +666,7 @@ def draw_image(
             self.lut,
             self.interpolate,
         )
-        qrect = QC.QRectF(QC.QPointF(dest[0], dest[1]), QC.QPointF(dest[2], dest[3]))
-        painter.drawImage(qrect, self._image, qrect)
+        self._draw_offscreen(painter, dest)
 
     def export_roi(
         self,

plotpy/items/image/transform.py

@@ -271,9 +271,13 @@ def draw_image(
         sy = (y1 - y0) / (H - 1)
         # tr1 = tr(x0,y0)@scale(sx,sy)@tr(-cx,-cy)
         tr = np.array([[sx, 0, x0 - cx * sx], [0, sy, y0 - cy * sy], [0, 0, 1]], float)
+        ratio = self._offscreen_ratio
+        if ratio != 1.0:
+            # From offscreen image pixels to canvas coordinates
+            tr = tr @ np.diag([1.0 / ratio, 1.0 / ratio, 1.0])
         mat = self.tr @ tr
 
-        dst_rect = tuple([int(i) for i in dst_rect])
+        dst_rect = self._offscreen_rect(dst_rect)
         dest = _scale_tr(
             self._get_display_data(),
             mat,
@@ -282,8 +286,7 @@ def draw_image(
             self.lut,
             self.interpolate,
         )
-        qrect = QC.QRectF(QC.QPointF(dest[0], dest[1]), QC.QPointF(dest[2], dest[3]))
-        painter.drawImage(qrect, self._image, qrect)
+        self._draw_offscreen(painter, dest)
         # -- rotation circle
         if self.can_rotate():
             if self.rotation_point is None: