8000 Move pixel ratio handling into FigureCanvasBase. · matplotlib/matplotlib@e5a840b · GitHub
[go: up one dir, main page]
Skip to content

Commit e5a840b

Browse files
QuLogicQuLogic
committed
Move pixel ratio handling into FigureCanvasBase.
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.
1 parent 3798e5f commit e5a840b

File tree

7 files changed

+89
-73
lines changed

7 files changed

+89
-73
lines changed

‎lib/matplotlib/backend_bases.py

Lines changed: 49 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1723,6 +1723,10 @@ def __init__(self, figure):
17231723
self.toolbar = None # NavigationToolbar2 will set me
17241724
self._is_idle_drawing = False
17251725

1726+
# We don't want to scale up the figure DPI more than once.
1727+
figure._original_dpi = figure.dpi
1728+
self._device_pixel_ratio = 1
1729+
17261730
@property
17271731
def callbacks(self):
17281732
return self.figure._canvas_callbacks
@@ -2040,12 +2044,54 @@ def draw_idle(self, *args, **kwargs):
20402044
with self._idle_draw_cntx():
20412045
self.draw(*args, **kwargs)
20422046

2047+
@property
2048+
def device_pixel_ratio(self):
2049+
"""
2050+
The ratio of logical to physical pixels used for the canvas on screen.
2051+
2052+
By default, this is 1, meaning physical and logical pixels are the same
2053+
size. Subclasses that support High DPI screens may set this property to
2054+
indicate that said ratio is different. All Matplotlib interaction,
2055+
unless working directly with the canvas, remains in logical pixels.
2056+
2057+
"""
2058+
return self._device_pixel_ratio
2059+
2060+
def _set_device_pixel_ratio(self, ratio):
2061+
"""
2062+
Set the ratio of logical to physical pixels used for the canvas.
2063+
2064+
Subclasses that support High DPI screens can set this property to
2065+
indicate that said ratio is different. The canvas itself will be
2066+
created at the physical size, while the client side will use the
2067+
logical size. Implementations that support High DPI screens should use
2068+
physical pixels for events so that transforms back to Axes space are
2069+
correct.
2070+
2071+
By default, this is 1, meaning physical and logical pixels are the same
2072+
size.
2073+
"""
2074+
# In cases with mixed resolution displays, we need to be careful if the
2075+
# device pixel ratio changes - in this case we need to resize the
2076+
# canvas accordingly. Some backends provide events that indicate a
2077+
# change in DPI, but those that don't will update this before drawing.
2078+
if self._device_pixel_ratio != ratio:
2079+
dpi = ratio * self.figure._original_dpi
2080+
self.figure._set_dpi(dpi, forward=False)
2081+
self._device_pixel_ratio = ratio
2082+
20432083
def get_width_height(self):
20442084
"""
2045-
Return the figure width and height in points or pixels
2046-
(depending on the backend), truncated to integers.
2085+
Return the figure width and height in integral points or pixels.
2086+
2087+
Returns
2088+
-------
2089+
width, height : int
2090+
The size of the figure, in points or pixels, depending on the
2091+
backend.
20472092
"""
2048-
return int(self.figure.bbox.width), int(self.figure.bbox.height)
2093+
return tuple(int(size / self.device_pixel_ratio)
2094+
for size in self.figure.bbox.max)
20492095

20502096
@classmethod
20512097
def get_supported_filetypes(cls):

‎lib/matplotlib/backends/backend_qt5.py

Lines changed: 11 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -221,15 +221,6 @@ def __init__(self, figure):
221221
_create_qApp()
222222
super().__init__(figure=figure)
223223

224-
# We don't want to scale up the figure DPI more than once.
225-
# Note, we don't handle a signal for changing DPI yet.
226-
figure._original_dpi = figure.dpi
227-
self._update_figure_dpi()
228-
# In cases with mixed resolution displays, we need to be careful if the
229-
# dpi_ratio changes - in this case we need to resize the canvas
230-
# accordingly.
231-
self._dpi_ratio_prev = self._dpi_ratio
232-
233224
self._draw_pending = False
234225
self._is_drawing = False
235226
self._draw_rect_callback = lambda painter: None
@@ -241,28 +232,17 @@ def __init__(self, figure):
241232
palette = QtGui.QPalette(QtCore.Qt.white)
242233
self.setPalette(palette)
243234

244-
def _update_figure_dpi(self):
245-
dpi = self._dpi_ratio * self.figure._original_dpi
246-
self.figure._set_dpi(dpi, forward=False)
247-
248-
@property
249-
def _dpi_ratio(self):
250-
return _devicePixelRatioF(self)
251-
252235
def _update_pixel_ratio(self):
253236
# We need to be careful in cases with mixed resolution displays if
254-
# dpi_ratio changes.
255-
if self._dpi_ratio != self._dpi_ratio_prev:
256-
# We need to update the figure DPI.
257-
self._update_figure_dpi()
258-
self._dpi_ratio_prev = self._dpi_ratio
237+
# device_pixel_ratio changes.
238+
current_pixel_ratio = _devicePixelRatioF(self)
239+
if self.device_pixel_ratio != current_pixel_ratio:
240+
self._set_device_pixel_ratio(current_pixel_ratio)
259241
# The easiest way to resize the canvas is to emit a resizeEvent
< 10000 code>260242
# since we implement all the logic for resizing the canvas for
261243
# that event.
262244
event = QtGui.QResizeEvent(self.size(), self.size())
263245
self.resizeEvent(event)
264-
# resizeEvent triggers a paintEvent itself, so we exit this one
265-
# (after making sure that the event is immediately handled).
266246

267247
def _update_screen(self, screen):
268248
# Handler for changes to a window's attached screen.
@@ -278,10 +258,6 @@ def showEvent(self, event):
278258
window.screenChanged.connect(self._update_screen)
279259
self._update_screen(window.screen())
280260

281-
def get_width_height(self):
282-
w, h = FigureCanvasBase.get_width_height(self)
283-
return int(w / self._dpi_ratio), int(h / self._dpi_ratio)
284-
285261
def enterEvent(self, event):
286262
try:
287263
x, y = self.mouseEventCoords(event.pos())
@@ -304,11 +280,10 @@ def mouseEventCoords(self, pos):
304280
305281
Also, the origin is different and needs to be corrected.
306282
"""
307-
dpi_ratio = self._dpi_ratio
308283
x = pos.x()
309284
# flip y so y=0 is bottom of canvas
310-
y = self.figure.bbox.height / dpi_ratio - pos.y()
311-
return x * dpi_ratio, y * dpi_ratio
285+
y = self.figure.bbox.height / self.device_pixel_ratio - pos.y()
286+
return x * self.device_pixel_ratio, y * self.device_pixel_ratio
312287

313288
def mousePressEvent(self, event):
314289
x, y = self.mouseEventCoords(event.pos())
@@ -369,8 +344,8 @@ def keyReleaseEvent(self, event):
369344
FigureCanvasBase.key_release_event(self, key, guiEvent=event)
370345

371346
def resizeEvent(self, event):
372-
w = event.size().width() * self._dpi_ratio
373-
h = event.size().height() * self._dpi_ratio
347+
w = event.size().width() * self.device_pixel_ratio
348+
h = event.size().height() * self.device_pixel_ratio
374349
dpival = self.figure.dpi
375350
winch = w / dpival
376351
hinch = h / dpival
@@ -468,7 +443,7 @@ def blit(self, bbox=None):
468443
if bbox is None and self.figure:
469444
bbox = self.figure.bbox # Blit the entire canvas if bbox is None.
470445
# repaint uses logical pixels, not physical pixels like the renderer.
471-
l, b, w, h = [int(pt / self._dpi_ratio) for pt in bbox.bounds]
446+
l, b, w, h = [int(pt / self.device_pixel_ratio) for pt in bbox.bounds]
472447
t = b + h
473448
self.repaint(l, self.rect().height() - t, w, h)
474449

@@ -489,11 +464,11 @@ def drawRectangle(self, rect):
489464
# Draw the zoom rectangle to the QPainter. _draw_rect_callback needs
490465
# to be called at the end of paintEvent.
491466
if rect is not None:
492-
x0, y0, w, h = [int(pt / self._dpi_ratio) for pt in rect]
467+
x0, y0, w, h = [int(pt / self.device_pixel_ratio) for pt in rect]
493468
x1 = x0 + w
494469
y1 = y0 + h
495470
def _draw_rect_callback(painter):
496-
pen = QtGui.QPen(QtCore.Qt.black, 1 / self._dpi_ratio)
471+
pen = QtGui.QPen(QtCore.Qt.black, 1 / self.device_pixel_ratio)
497472
pen.setDashPattern([3, 3])
498473
for color, offset in [
499474
(QtCore.Qt.black, 0), (QtCore.Qt.white, 3)]:

‎lib/matplotlib/backends/backend_qt5agg.py

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -42,8 +42,8 @@ def paintEvent(self, event):
4242
# scale rect dimensions using the screen dpi ratio to get
4343
# correct values for the Figure coordinates (rather than
4444
# QT5's coords)
45-
width = rect.width() * self._dpi_ratio
46-
height = rect.height() * self._dpi_ratio
45+
width = rect.width() * self.device_pixel_ratio
46+
height = rect.height() * self.device_pixel_ratio
4747
left, top = self.mouseEventCoords(rect.topLeft())
4848
# shift the "top" by the height of the image to get the
4949
# correct corner for our coordinate system
@@ -61,7 +61,7 @@ def paintEvent(self, event):
6161

6262
qimage = QtGui.QImage(buf, buf.shape[1], buf.shape[0],
6363
QtGui.QImage.Format_ARGB32_Premultiplied)
64-
_setDevicePixelRatio(qimage, self._dpi_ratio)
64+
_setDevicePixelRatio(qimage, self.device_pixel_ratio)
6565
# set origin using original QT coordinates
6666
origin = QtCore.QPoint(rect.left(), rect.top())
6767
painter.drawImage(origin, qimage)

‎lib/matplotlib/backends/backend_qt5cairo.py

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -17,9 +17,8 @@ def draw(self):
1717
super().draw()
1818

1919
def paintEvent(self, event):
20-
dpi_ratio = self._dpi_ratio
21-
width = int(dpi_ratio * self.width())
22-
height = int(dpi_ratio * self.height())
20+
width = int(self.device_pixel_ratio * self.width())
21+
height = int(self.device_pixel_ratio * self.height())
2322
if (width, height) != self._renderer.get_canvas_width_height():
2423
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
2524
self._renderer.set_ctx_from_surface(surface)
@@ -32,7 +31,7 @@ def paintEvent(self, event):
3231
# QImage under PySide on Python 3.
3332
if QT_API == 'PySide':
3433
ctypes.c_long.from_address(id(buf)).value = 1
35-
_setDevicePixelRatio(qimage, dpi_ratio)
34+
_setDevicePixelRatio(qimage, self.device_pixel_ratio)
3635
painter = QtGui.QPainter(self)
3736
painter.eraseRect(event.rect())
3837
painter.drawImage(0, 0, qimage)

‎lib/matplotlib/backends/backend_webagg_core.py

Lines changed: 8 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -172,10 +172,6 @@ def __init__(self, *args, **kwargs):
172172
# to the connected clients.
173173
self._current_image_mode = 'full'
174174

175-
# Store the DPI ratio of the browser. This is the scaling that
176-
# occurs automatically for all images on a HiDPI display.
177-
self._dpi_ratio = 1
178-
179175
def show(self):
180176
# show the figure window
181177
from matplotlib.pyplot import show
@@ -345,8 +341,8 @@ def handle_refresh(self, event):
345341
self.draw_idle()
346342

347343
def handle_resize(self, event):
348-
x, y = event.get('width', 800), event.get('height', 800)
349-
x, y = int(x) * self._dpi_ratio, int(y) * self._dpi_ratio
344+
x = int(event.get('width', 800)) * self.device_pixel_ratio
345+
y = int(event.get('height', 800)) * self.device_pixel_ratio
350346
fig = self.figure
351347
# An attempt at approximating the figure size in pixels.
352348
fig.set_size_inches(x / fig.dpi, y / fig.dpi, forward=False)
@@ -361,14 +357,10 @@ def handle_send_image_mode(self, event):
361357
# The client requests notification of what the current image mode is.
362358
self.send_event('image_mode', mode=self._current_image_mode)
363359

364-
def handle_set_dpi_ratio(self, event):
365-
dpi_ratio = event.get('dpi_ratio', 1)
366-
if dpi_ratio != self._dpi_ratio:
367-
# We don't want to scale up the figure dpi more than once.
368-
if not hasattr(self.figure, '_original_dpi'):
369-
self.figure._original_dpi = self.figure.dpi
370-
self.figure.dpi = dpi_ratio * self.figure._original_dpi
371-
self._dpi_ratio = dpi_ratio
360+
def handle_set_device_pixel_ratio(self, event):
361+
device_pixel_ratio = event.get('device_pixel_ratio', 1)
362+
if device_pixel_ratio != self.device_pixel_ratio:
363+
self._set_device_pixel_ratio(device_pixel_ratio)
372364
self._force_full = True
373365
self.draw_idle()
374366

@@ -462,7 +454,8 @@ def _get_toolbar(self, canvas):
462454
def resize(self, w, h, forward=True):
463455
self._send_event(
464456
'resize',
465-
size=(w / self.canvas._dpi_ratio, h / self.canvas._dpi_ratio),
457+
size=(w / self.canvas.device_pixel_ratio,
458+
h / self.canvas.device_pixel_ratio),
466459
forward=forward)
467460

468461
def set_window_title(self, title):

‎lib/matplotlib/backends/web_backend/js/mpl.js

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -63,7 +63,9 @@ mpl.figure = function (figure_id, websocket, ondownload, parent_element) {
6363
fig.send_message('supports_binary', { value: fig.supports_binary });
6464
fig.send_message('send_image_mode', {});
6565
if (fig.ratio !== 1) {
66-
fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });
66+
fig.send_message('set_device_pixel_ratio', {
67+
device_pixel_ratio: fig.ratio,
68+
});
6769
}
6870
fig.send_message('refresh', {});
6971
};

‎lib/matplotlib/tests/test_backend_qt.py

Lines changed: 12 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -158,10 +158,10 @@ def on_key_press(event):
158158

159159

160160
@pytest.mark.backend('Qt5Agg')
161-
def test_pixel_ratio_change():
161+
def test_device_pixel_ratio_change():
162162
"""
163163
Make sure that if the pixel ratio changes, the figure dpi changes but the
164-
widget remains the same physical size.
164+
widget remains the same logical size.
165165
"""
166166

167167
prop = 'matplotlib.backends.backend_qt5.FigureCanvasQT.devicePixelRatioF'
@@ -172,10 +172,8 @@ def test_pixel_ratio_change():
172172
qt_canvas = fig.canvas
173173
qt_canvas.show()
174174

175-
def set_pixel_ratio(ratio):
175+
def set_device_pixel_ratio(ratio):
176176
p.return_value = ratio
177-
# Make sure the mocking worked
178-
assert qt_canvas._dpi_ratio == ratio
179177

180178
# The value here doesn't matter, as we can't mock the C++ QScreen
181179
# object, but can override the functional wrapper around it.
@@ -186,43 +184,46 @@ def set_pixel_ratio(ratio):
186184
qt_canvas.draw()
187185
qt_canvas.flush_events()
188186

187+
# Make sure the mocking worked
188+
assert qt_canvas.device_pixel_ratio == ratio
189+
189190
qt_canvas.manager.show()
190191
size = qt_canvas.size()
191192
screen = qt_canvas.window().windowHandle().screen()
192-
set_pixel_ratio(3)
193+
set_device_pixel_ratio(3)
193194

194195
# The DPI and the renderer width/height change
195196
assert fig.dpi == 360
196197
assert qt_canvas.renderer.width == 1800
197198
assert qt_canvas.renderer.height == 720
198199

199-
# The actual widget size and figure physical size don't change
200+
# The actual widget size and figure logical size don't change.
200201
assert size.width() == 600
201202
assert size.height() == 240
202203
assert qt_canvas.get_width_height() == (600, 240)
203204
assert (fig.get_size_inches() == (5, 2)).all()
204205

205-
set_pixel_ratio(2)
206+
set_device_pixel_ratio(2)
206207

207208
# The DPI and the renderer width/height change
208209
assert fig.dpi == 240
209210
assert qt_canvas.renderer.width == 1200
210211
assert qt_canvas.renderer.height == 480
211212

212-
# The actual widget size and figure physical size don't change
213+
# The actual widget size and figure logical size don't change.
213214
assert size.width() == 600
214215
assert size.height() == 240
215216
assert qt_canvas.get_width_height() == (600, 240)
216217
assert (fig.get_size_inches() == (5, 2)).all()
217218

218-
set_pixel_ratio(1.5)
219+
set_device_pixel_ratio(1.5)
219220

220221
# The DPI and the renderer width/height change
221222
assert fig.dpi == 180
222223
assert qt_canvas.renderer.width == 900
223224
assert qt_canvas.renderer.height == 360
224225

225-
# The actual widget size and figure physical size don't change
226+
# The actual widget size and figure logical size don't change.
226227
assert size.width() == 600
227228
assert size.height() == 240
228229
assert qt_canvas.get_width_height() == (600, 240)

0 commit comments

Comments
 (0)
0