PyQtGraph 0.1.14 takes approximately twice as long to plot colored points in a ScatterPlotItem that 0.1.13 about pyqtgraph HOT 7 CLOSED

I would guess that #2863 is the one affecting you.

1. Are you able to bisect the code to confirm that #2863 is the relevant PR affecting you?
2. Are you using a hi-dpi display? If yes, in the following lines, if you change self._dpr to your screen device pixel ratio, does it make a difference?

   pyqtgraph/pyqtgraph/graphicsItems/ScatterPlotItem.py

   Lines 151 to 153 in a4bf606

   	def __init__(self):
   	self._dpr = 1.0
   	self.clear()

ScatterPlotItem starts off assuming DPR=1.0, and if that turns out to be incorrect, it has to rebuild the symbol cache. Effectively, this means that the time to first render should be slower for users with a hi-dpi display.
Now, pyqtgraph library could perhaps try to probe for the primary screen's DPR and use that. That, however, is not entirely foolproof, as the user may have multiple screens with different DPRs.

Indeed, ScatterPlotItem does not know the screen on which it will display until just before painting occurs. And furthermore, even after being displayed, the user could drag the window to the other screen.

from pyqtgraph.

Thanks for the quick reply!

I am indeed on a hi-dpi display and that may explain the slow down on my machine. In general, I am supporting users on Windows, Linux and macOS with any number of screens, so I would indeed need to check for the DPI before I plot.

I will check that the pull request you mention is indeed the one that affects the rendering performance on my machine and come back to you asap.

from pyqtgraph.

The following script takes < 2.5 secs to run on a particular system with hidpi.

import time

import numpy as np
import pyqtgraph as pg

npoints = 200_000
nbrushes = 600

rng = np.random.default_rng(0)
xy = rng.standard_normal(size=(2, npoints))
unique_colors = rng.integers(256, size=(nbrushes, 3))
unique_brushes = [pg.mkBrush(*rgb) for rgb in unique_colors]
random_choice = rng.integers(nbrushes, size=npoints)
random_brushes = [unique_brushes[x] for x in random_choice]

pg.mkQApp()

scatter = pg.ScatterPlotItem(
    size=5,
    pen=pg.mkPen(None),
    brush=pg.mkBrush(255, 255, 255, 128),  # To be overridden in the next call depending on a setting
    hoverable=True,
    hoverSymbol="s",
    hoverSize=5,
    hoverPen=pg.mkPen("w", width=2),
    hoverBrush=None,
)

t0 = time.perf_counter()
# scatter.addPoints(x=xy[0], y=xy[1], brush=random_choice)  # SLOW
scatter.addPoints(x=xy[0], y=xy[1], brush=random_brushes)   # FAST
t1 = time.perf_counter()
print(f'{t1 - t0:.3f}')

pg.mkQApp()
win = pg.PlotWidget()
win.show()
win.addItem(scatter)
pg.exec()

The following should explain why:

from pyqtgraph.

set PYQTGRAPHPROFILE="ScatterPlotItem.paint"

SLOW version (with dpi mismatch)

9.933
> Entering ScatterPlotItem.paint
  prep: 11133.5924 ms
  draw: 164.4934 ms
< Exiting ScatterPlotItem.paint, total time: 11298.1008 ms

FAST version (with dpi mismatch)

0.710
> Entering ScatterPlotItem.paint
  prep: 369.4633 ms
  draw: 47.4142 ms
< Exiting ScatterPlotItem.paint, total time: 416.8903 ms

FAST version (with dpi matched)

0.709
> Entering ScatterPlotItem.paint
  prep: 31.1583 ms
  draw: 48.1068 ms
< Exiting ScatterPlotItem.paint, total time: 79.2849 ms

In the FAST version, a matched dpi would have saved only ~340ms.
Is that worth optimizing for?

The optimization would be adding one line after the instantiation of SymbolAtlas.

self.fragmentAtlas = SymbolAtlas()
self.fragmentAtlas.setDevicePixelRatio(QtGui.QGuiApplication.primaryScreen().devicePixelRatio())

from pyqtgraph.

Thanks a lot! I will try it out first thing on Monday.

from pyqtgraph.

Hi,

when using the suggested fast method (#2960 (comment)) to create just one QBrush per unique identifier and have all other points with the same id reference it, I get the following results:

pyQtGraph 0.13.3: 748 +/- 5ms
pyQtGraph 0.13.4: 748 +/- 6ms

down from ca. 19.6 seconds.

Additionally, If I change the device pixel ratio of SymbolAtlas via self.fragmentAtlas.setDevicePixelRatio(QtGui.QGuiApplication.primaryScreen().devicePixelRatio()) (which on my machine maps to 1.5), I get the following results:

pyQtGraph 0.13.4: 757 +/- 4ms

Apparently, changing the device pixel ratio even (very minimally) slows down the rendering.

All in all, reducing the number of QBrush object instantiations more than solves my performance issue with colouring points in the ScatterPlotItem (from 19 down to a quarter of a second), and any additional optimization seem to bring only negligible improvements (or even regressions).

from pyqtgraph.

I had a typo in my instructions (edited):

set PYQTGRAPHPROFILE="ScatterPlotItem.paint"

from pyqtgraph.