setRotation method for QGraphicsSimpleTextItem() slow zommig and pannig interaction - pyqt5

Question

I have a GUI that show line and text aligned to each line, I use QGraphicsSimpleTextItem() for text.
Issue:
If there is no Rotation method used on QGraphicsSimpleTextItem() zoom and pan (subclass QGraphcisView) interaction runs rapidly, but if a Rotation is assigned to those items text zoom and pan interaction becomes very slow.
Question:
I have Line Profiler to find the line that consumes more time in the class, but nothing really stands out, as shown below. Is there any reason this would happen? How can I improve this?
Setting text rotation (ang)
Commenting out text rotation line (ang)
Per Hit time does not show a great increase or decrease but the user experience regarding zoom and pan interaction when commenting line # dict_Text[str(i)].setRotation(ang[i]) is very different.
Reproduce Problem:
Below is a code that reproduces the trouble I am experiencing, first run the code as is an you will have a very slow zoom and pan interaction, then comment out the line dict_Text[str(i)].setRotation(ang[i]) and zoom and pan interaction will be very fast.
Code:
from PyQt5 import QtWidgets, QtCore, QtGui
import numpy as np
import sys
print(QtCore.PYQT_VERSION_STR)
class GraphicsView(QtWidgets.QGraphicsView):
#profile
def __init__(self, scene, parent):
super(GraphicsView, self).__init__(scene, parent)
#Mouse Tracking
self.setMouseTracking(True)
#Zoom Anchor
self.setTransformationAnchor(QtWidgets.QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QtWidgets.QGraphicsView.AnchorUnderMouse)
#Antialiasing and indexing
self.setRenderHints(QtGui.QPainter.Antialiasing | QtGui.QPainter.HighQualityAntialiasing | QtGui.QPainter.TextAntialiasing)
self.setCacheMode(QtWidgets.QGraphicsView.CacheBackground)
self.resetCachedContent()
scene.setItemIndexMethod(QtWidgets.QGraphicsScene.NoIndex)
#Pan variable
self.pos_init_class = None
#profile
def mousePressEvent(self, event):
pos = self.mapToScene(event.pos())
#Mouse Pan
if event.button() == QtCore.Qt.MiddleButton:
self.pos_init_class = pos
super(GraphicsView, self).mousePressEvent(event)
#profile
def mouseReleaseEvent(self, event):
if self.pos_init_class and event.button() == QtCore.Qt.MiddleButton:
#Mouse Pan
self.pos_init_class = None
super(GraphicsView, self).mouseReleaseEvent(event)
#profile
def mouseMoveEvent(self, event):
if self.pos_init_class:
#Mouse Pan
delta = self.pos_init_class - self.mapToScene(event.pos())
r = self.mapToScene(self.viewport().rect()).boundingRect()
self.setSceneRect(r.translated(delta))
super(GraphicsView, self).mouseMoveEvent(event)
#profile
def wheelEvent(self, event):
#Mouse Zoom
if event.angleDelta().y() > 0:
self.scale(1.5, 1.5)
else:
self.scale(1 / 1.5, 1 / 1.5)
class Ui_MainWindow(object):
def __init__(self):
super(Ui_MainWindow, self).__init__()
def plt_plot(self):
#Create data set
size = 200
x = np.random.randint(0, high=1000, size=size, dtype=int)
y = np.random.randint(0, high=1000, size=size, dtype=int)
ang = np.random.randint(1, high=360, size=size, dtype=int)
#Store Text in Dict
dict_Text = {}
for i in range(len(x)):
#Create Text Item
dict_Text[str(i)] = QtWidgets.QGraphicsSimpleTextItem()
#Set text
dict_Text[str(i)].setText('nn-mm \nL: 50.6 m \nD: 1500 mm')
#Set Pos
dict_Text[str(i)].setPos(x[i], y[i])
#Set rotation angle
dict_Text[str(i)].setRotation(ang[i])
#Add to Scene
self.graphicsView.scene().addItem(dict_Text[str(i)])
def setupUi(self, MainWindow):
#Central Widget
self.centralwidget = QtWidgets.QWidget(MainWindow)
MainWindow.setCentralWidget(self.centralwidget)
main_width, main_heigth = 1200, 800
MainWindow.resize(main_width, main_heigth)
#Create GraphicsView and Scene
self.scene = QtWidgets.QGraphicsScene()
self.graphicsView = GraphicsView(scene=self.scene, parent=self.centralwidget)
#Set Geometry
self.graphicsView.setGeometry(QtCore.QRect(0, 0, main_width, main_heigth))
#plot dummy data set
self.plt_plot()
if __name__ == "__main__":
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())

Answer 1

While the QGraphicsView framework documentations states that it's pretty fast, that doesn't mean that it's always fast.
The rendering speed depends on many factors, and individual item transformation can drastically decrease the overall performance.
Consider that the drawing of all items is done as individual raster painting (the backend is almost all Qt's own rendering: its optimization, while normally good, is not perfect).
For each item that has an individual transformation, the painter will need to do the painting based on that transformation.
If you have 200 items, each one with its own transformation, that means a lot of computing.
Note: a transformation is a matrix that can transform the painting (meaning that everything will need special and additional computation).
Qt transformations pretty standard:
translation
scale
shear
[projection]
rotation (which is done by combining shearing and scaling, hence the complexity)
perspective (which is done by combining projection and scaling)
Then you have to add the fact that you're not drawing simple items, but text based items. Text painting requires a lot of computation, despite all the optimization that Qt and the underlying system provide.
I wouldn't go into deep on how text painting is done, but you have to consider a moltitude of aspects; let's just consider a very few of them:
each letter is composed of many complex polygons (many of them using bezier curves)
each letter has different sizes and spacings, including per-letter (and per letter-pair) spacing, also known as kerning
some fonts have even more advanced features, like ligature
even simple alignment has to be taken into account, possibly according to the system, widget or even text option layout direction
lots of other things...
Consider this (it doesn't work exactly like this, but that's just for the sake of the example): in your text you have about 20 drawable characters.
Imagine every character as an individual newly created instance of QPainterPath, containing lots of lines and bezier curves (as almost any characters does). That's about 4000 individual paths with their own curves, each one created every time they are drawn.
Then you need to also apply a transformation matrix, due to the rotation (as explained before, both shear and translation).
I need to remark that the above is an over-simplification of how text drawing is done (as Qt also partially relies on the underlying system font rendering).
So, is there a solution?
Well, "not really" and "not always".
First of all, instead of using setSceneRect(), you could get some slight improvement by scrolling the contents of the scene. This is done by setting a (very much) bigger sceneRect and hiding the scrollbars using set<Orientation>ScrollBarPolicy to ScrollBarAlwaysOff, then moving the visible area by setting the delta position on the scroll bar values. Moving the scroll bars will just cause the repainting of the viewport, while setSceneRect() also requires (recursive) computation of the visible area based on the transformation and the scroll bar sizes.
Then, there is the OpenGL alternative, which might improve performance:
In order to accurately and quickly apply transformations and effects to items, Graphics View is built with the assumption that the user's hardware is able to provide reasonable performance for floating point instructions.
[...]
As a result, certain kinds of effects may be slower than expected on certain devices. It may be possible to compensate for this performance hit by making optimizations in other areas; for example, by using OpenGL to render a scene.
See OpenGL Rendering about that, but consider that it does not always guarantee better performances.
Finally, if you need to show that many individual text items, each one with its own rotation, you must expect that performance will drastically decrease. The only possible alternative is to try to render those text items as (bigger) images, and then use QGraphicsPixmapItem, but in order to get reliable results (as bitmap based objects are prone to aliasing when transformed) you'd need to use bigger sizes for each item.