Move pixel ratio handling into FigureCanvasBase.

QuLogic · QuLogic · commit afd6e052a771 · 2020-12-16T04:28:42.000-05:00
This is already implemented in two backends (Qt5 and nbAgg), and I plan
to implement it in TkAgg, so it's better to remove the repetition.
diff --git a/lib/matplotlib/backend_bases.py b/lib/matplotlib/backend_bases.py
@@ -1723,6 +1723,10 @@ def __init__(self, figure):
         self.toolbar = None  # NavigationToolbar2 will set me
         self._is_idle_drawing = False
 
+        # We don't want to scale up the figure DPI more than once.
+        figure._original_dpi = figure.dpi
+        self._pixel_ratio = 1
+
     @property
     def callbacks(self):
         return self.figure._canvas_callbacks
@@ -2040,12 +2044,45 @@ def draw_idle(self, *args, **kwargs):
             with self._idle_draw_cntx():
                 self.draw(*args, **kwargs)
 
+    @property
+    def pixel_ratio(self):
+        """
+        The ratio of logical to physical pixels used for the canvas.
+
+        Subclasses that support High DPI screens can set this property to
+        indicate that said ratio is different. The canvas itself will be
+        created at the physical size, while the display and any events will use
+        the logical size (and such implementations should ensure that events do
+        so.)
+
+        By default, this is 1, meaning physical and logical pixels are the same
+        size.
+        """
+        return self._pixel_ratio
+
+    @pixel_ratio.setter
+    def pixel_ratio(self, ratio):
+        # In cases with mixed resolution displays, we need to be careful if the
+        # pixel_ratio changes - in this case we need to resize the canvas
+        # accordingly. Some backends provide events that indicate a change in
+        # DPI, but those that don't will update this before drawing.
+        if self._pixel_ratio != ratio:
+            dpi = ratio * self.figure._original_dpi
+            self.figure._set_dpi(dpi, forward=False)
+        self._pixel_ratio = ratio
+
     def get_width_height(self):
         """
-        Return the figure width and height in points or pixels
-        (depending on the backend), truncated to integers.
+        Return the figure width and height in integral points or pixels.
+
+        Returns
+        -------
+        width, height : int
+            The size of the figure, in points or pixels, depending on the
+            backend.
         """
-        return int(self.figure.bbox.width), int(self.figure.bbox.height)
+        return tuple(int(size / self.pixel_ratio)
+                     for size in self.figure.bbox.max)
 
     @classmethod
     def get_supported_filetypes(cls):
diff --git a/lib/matplotlib/backends/backend_qt5.py b/lib/matplotlib/backends/backend_qt5.py
@@ -221,15 +221,6 @@ def __init__(self, figure):
         _create_qApp()
         super().__init__(figure=figure)
 
-        # We don't want to scale up the figure DPI more than once.
-        # Note, we don't handle a signal for changing DPI yet.
-        figure._original_dpi = figure.dpi
-        self._update_figure_dpi()
-        # In cases with mixed resolution displays, we need to be careful if the
-        # dpi_ratio changes - in this case we need to resize the canvas
-        # accordingly.
-        self._dpi_ratio_prev = self._dpi_ratio
-
         self._draw_pending = False
         self._is_drawing = False
         self._draw_rect_callback = lambda painter: None
@@ -241,22 +232,13 @@ def __init__(self, figure):
         palette = QtGui.QPalette(QtCore.Qt.white)
         self.setPalette(palette)
 
-    def _update_figure_dpi(self):
-        dpi = self._dpi_ratio * self.figure._original_dpi
-        self.figure._set_dpi(dpi, forward=False)
-
-    @property
-    def _dpi_ratio(self):
-        return _devicePixelRatioF(self)
-
     def _update_pixel_ratio(self):
-        # As described in __init__ above, we need to be careful in cases with
-        # mixed resolution displays if dpi_ratio is changing between painting
-        # events.
-        if self._dpi_ratio != self._dpi_ratio_prev:
+        # We need to be careful in cases with mixed resolution displays if
+        # pixel_ratio changes.
+        current_pixel_ratio = _devicePixelRatioF(self)
+        if self.pixel_ratio != current_pixel_ratio:
             # We need to update the figure DPI.
-            self._update_figure_dpi()
-            self._dpi_ratio_prev = self._dpi_ratio
+            self.pixel_ratio = current_pixel_ratio
             # The easiest way to resize the canvas is to emit a resizeEvent
             # since we implement all the logic for resizing the canvas for
             # that event.
@@ -283,10 +265,6 @@ def showEvent(self, event):
         window.screenChanged.connect(self._update_screen)
         self._update_screen(window.screen())
 
-    def get_width_height(self):
-        w, h = FigureCanvasBase.get_width_height(self)
-        return int(w / self._dpi_ratio), int(h / self._dpi_ratio)
-
     def enterEvent(self, event):
         try:
             x, y = self.mouseEventCoords(event.pos())
@@ -309,11 +287,11 @@ def mouseEventCoords(self, pos):
 
         Also, the origin is different and needs to be corrected.
         """
-        dpi_ratio = self._dpi_ratio
+        pixel_ratio = self.pixel_ratio
         x = pos.x()
         # flip y so y=0 is bottom of canvas
-        y = self.figure.bbox.height / dpi_ratio - pos.y()
-        return x * dpi_ratio, y * dpi_ratio
+        y = self.figure.bbox.height / pixel_ratio - pos.y()
+        return x * pixel_ratio, y * pixel_ratio
 
     def mousePressEvent(self, event):
         x, y = self.mouseEventCoords(event.pos())
@@ -374,8 +352,8 @@ def keyReleaseEvent(self, event):
             FigureCanvasBase.key_release_event(self, key, guiEvent=event)
 
     def resizeEvent(self, event):
-        w = event.size().width() * self._dpi_ratio
-        h = event.size().height() * self._dpi_ratio
+        w = event.size().width() * self.pixel_ratio
+        h = event.size().height() * self.pixel_ratio
         dpival = self.figure.dpi
         winch = w / dpival
         hinch = h / dpival
@@ -473,7 +451,7 @@ def blit(self, bbox=None):
         if bbox is None and self.figure:
             bbox = self.figure.bbox  # Blit the entire canvas if bbox is None.
         # repaint uses logical pixels, not physical pixels like the renderer.
-        l, b, w, h = [int(pt / self._dpi_ratio) for pt in bbox.bounds]
+        l, b, w, h = [int(pt / self.pixel_ratio) for pt in bbox.bounds]
         t = b + h
         self.repaint(l, self.rect().height() - t, w, h)
 
@@ -494,11 +472,11 @@ def drawRectangle(self, rect):
         # Draw the zoom rectangle to the QPainter.  _draw_rect_callback needs
         # to be called at the end of paintEvent.
         if rect is not None:
-            x0, y0, w, h = [int(pt / self._dpi_ratio) for pt in rect]
+            x0, y0, w, h = [int(pt / self.pixel_ratio) for pt in rect]
             x1 = x0 + w
             y1 = y0 + h
             def _draw_rect_callback(painter):
-                pen = QtGui.QPen(QtCore.Qt.black, 1 / self._dpi_ratio)
+                pen = QtGui.QPen(QtCore.Qt.black, 1 / self.pixel_ratio)
                 pen.setDashPattern([3, 3])
                 for color, offset in [
                         (QtCore.Qt.black, 0), (QtCore.Qt.white, 3)]:
diff --git a/lib/matplotlib/backends/backend_qt5agg.py b/lib/matplotlib/backends/backend_qt5agg.py
@@ -42,8 +42,8 @@ def paintEvent(self, event):
             # scale rect dimensions using the screen dpi ratio to get
             # correct values for the Figure coordinates (rather than
             # QT5's coords)
-            width = rect.width() * self._dpi_ratio
-            height = rect.height() * self._dpi_ratio
+            width = rect.width() * self.pixel_ratio
+            height = rect.height() * self.pixel_ratio
             left, top = self.mouseEventCoords(rect.topLeft())
             # shift the "top" by the height of the image to get the
             # correct corner for our coordinate system
@@ -61,7 +61,7 @@ def paintEvent(self, event):
 
             qimage = QtGui.QImage(buf, buf.shape[1], buf.shape[0],
                                   QtGui.QImage.Format_ARGB32_Premultiplied)
-            _setDevicePixelRatio(qimage, self._dpi_ratio)
+            _setDevicePixelRatio(qimage, self.pixel_ratio)
             # set origin using original QT coordinates
             origin = QtCore.QPoint(rect.left(), rect.top())
             painter.drawImage(origin, qimage)
diff --git a/lib/matplotlib/backends/backend_qt5cairo.py b/lib/matplotlib/backends/backend_qt5cairo.py
@@ -17,9 +17,8 @@ def draw(self):
         super().draw()
 
     def paintEvent(self, event):
-        dpi_ratio = self._dpi_ratio
-        width = int(dpi_ratio * self.width())
-        height = int(dpi_ratio * self.height())
+        width = int(self.pixel_ratio * self.width())
+        height = int(self.pixel_ratio * self.height())
         if (width, height) != self._renderer.get_canvas_width_height():
             surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
             self._renderer.set_ctx_from_surface(surface)
@@ -32,7 +31,7 @@ def paintEvent(self, event):
         # QImage under PySide on Python 3.
         if QT_API == 'PySide':
             ctypes.c_long.from_address(id(buf)).value = 1
-        _setDevicePixelRatio(qimage, dpi_ratio)
+        _setDevicePixelRatio(qimage, self.pixel_ratio)
         painter = QtGui.QPainter(self)
         painter.eraseRect(event.rect())
         painter.drawImage(0, 0, qimage)
diff --git a/lib/matplotlib/backends/backend_webagg_core.py b/lib/matplotlib/backends/backend_webagg_core.py
@@ -137,10 +137,6 @@ def __init__(self, *args, **kwargs):
         # to the connected clients.
         self._current_image_mode = 'full'
 
-        # Store the DPI ratio of the browser.  This is the scaling that
-        # occurs automatically for all images on a HiDPI display.
-        self._dpi_ratio = 1
-
     def show(self):
         # show the figure window
         from matplotlib.pyplot import show
@@ -311,7 +307,7 @@ def handle_refresh(self, event):
 
     def handle_resize(self, event):
         x, y = event.get('width', 800), event.get('height', 800)
-        x, y = int(x) * self._dpi_ratio, int(y) * self._dpi_ratio
+        x, y = int(x) * self.pixel_ratio, int(y) * self.pixel_ratio
         fig = self.figure
         # An attempt at approximating the figure size in pixels.
         fig.set_size_inches(x / fig.dpi, y / fig.dpi, forward=False)
@@ -326,14 +322,10 @@ def handle_send_image_mode(self, event):
         # The client requests notification of what the current image mode is.
         self.send_event('image_mode', mode=self._current_image_mode)
 
-    def handle_set_dpi_ratio(self, event):
-        dpi_ratio = event.get('dpi_ratio', 1)
-        if dpi_ratio != self._dpi_ratio:
-            # We don't want to scale up the figure dpi more than once.
-            if not hasattr(self.figure, '_original_dpi'):
-                self.figure._original_dpi = self.figure.dpi
-            self.figure.dpi = dpi_ratio * self.figure._original_dpi
-            self._dpi_ratio = dpi_ratio
+    def handle_set_pixel_ratio(self, event):
+        pixel_ratio = event.get('pixel_ratio', 1)
+        if pixel_ratio != self.pixel_ratio:
+            self.pixel_ratio = pixel_ratio
             self._force_full = True
             self.draw_idle()
 
@@ -427,7 +419,7 @@ def _get_toolbar(self, canvas):
     def resize(self, w, h, forward=True):
         self._send_event(
             'resize',
-            size=(w / self.canvas._dpi_ratio, h / self.canvas._dpi_ratio),
+            size=(w / self.canvas.pixel_ratio, h / self.canvas.pixel_ratio),
             forward=forward)
 
     def set_window_title(self, title):
diff --git a/lib/matplotlib/backends/web_backend/js/mpl.js b/lib/matplotlib/backends/web_backend/js/mpl.js
@@ -63,7 +63,7 @@ mpl.figure = function (figure_id, websocket, ondownload, parent_element) {
         fig.send_message('supports_binary', { value: fig.supports_binary });
         fig.send_message('send_image_mode', {});
         if (fig.ratio !== 1) {
-            fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });
+            fig.send_message('set_pixel_ratio', { pixel_ratio: fig.ratio });
         }
         fig.send_message('refresh', {});
     };
@@ -158,7 +158,7 @@ mpl.figure.prototype._init_canvas = function () {
 
     this.ratio = (window.devicePixelRatio || 1) / backingStore;
     if (this.ratio !== 1) {
-        fig.send_message('set_dpi_ratio', { dpi_ratio: this.ratio });
+        fig.send_message('set_pixel_ratio', { pixel_ratio: this.ratio });
     }
 
     var rubberband_canvas = (this.rubberband_canvas = document.createElement(
diff --git a/lib/matplotlib/tests/test_backend_qt.py b/lib/matplotlib/tests/test_backend_qt.py
@@ -161,7 +161,7 @@ def on_key_press(event):
 def test_pixel_ratio_change():
     """
     Make sure that if the pixel ratio changes, the figure dpi changes but the
-    widget remains the same physical size.
+    widget remains the same logical size.
     """
 
     prop = 'matplotlib.backends.backend_qt5.FigureCanvasQT.devicePixelRatioF'
@@ -174,8 +174,6 @@ def test_pixel_ratio_change():
 
         def set_pixel_ratio(ratio):
             p.return_value = ratio
-            # Make sure the mocking worked
-            assert qt_canvas._dpi_ratio == ratio
 
             # The value here doesn't matter, as we can't mock the C++ QScreen
             # object, but can override the functional wrapper around it.
@@ -186,6 +184,9 @@ def set_pixel_ratio(ratio):
             qt_canvas.draw()
             qt_canvas.flush_events()
 
+            # Make sure the mocking worked
+            assert qt_canvas.pixel_ratio == ratio
+
         qt_canvas.manager.show()
         size = qt_canvas.size()
         screen = qt_canvas.window().windowHandle().screen()
@@ -196,7 +197,7 @@ def set_pixel_ratio(ratio):
         assert qt_canvas.renderer.width == 1800
         assert qt_canvas.renderer.height == 720
 
-        # The actual widget size and figure physical size don't change
+        # The actual widget size and figure logical size don't change.
         assert size.width() == 600
         assert size.height() == 240
         assert qt_canvas.get_width_height() == (600, 240)
@@ -209,7 +210,7 @@ def set_pixel_ratio(ratio):
         assert qt_canvas.renderer.width == 1200
         assert qt_canvas.renderer.height == 480
 
-        # The actual widget size and figure physical size don't change
+        # The actual widget size and figure logical size don't change.
         assert size.width() == 600
         assert size.height() == 240
         assert qt_canvas.get_width_height() == (600, 240)
@@ -222,7 +223,7 @@ def set_pixel_ratio(ratio):
         assert qt_canvas.renderer.width == 900
         assert qt_canvas.renderer.height == 360
 
-        # The actual widget size and figure physical size don't change
+        # The actual widget size and figure logical size don't change.
         assert size.width() == 600
         assert size.height() == 240
         assert qt_canvas.get_width_height() == (600, 240)
