Optimizing Qt 4 Graphics View

During the summer I worked a lot with one of the latest addition to the Qt framework
,
the graphics view. The graphics view is basically a canvas to draw
2D-graphics, and replaced the QCanvas class from Qt 3.x. It was added
to Qt in version 4.2.

The application I worked on is used for displaying a sea map along
with various other maritime related information (and a lot of other
stuff that’s not really relevant). While the application functioned the
way it was, we wanted to replace our old (somewhat hackish) way of
representing the parts of the program as CSS-themed top-level widgets
and using a embedded graphics view to represent the entire UI of the
application. This approach would give us a better ability to integrate
the various parts of the application, as well as support transitions
between various view states of the program (and other nifty graphics
effects). With the recent addition of QGraphicsProxyWidget in Qt 4.4
this was finally an option, so we decided to give it a shot.

During the initial porting of the application, we did not notice
much in the way of performance loss, but as soon as we added more (and
larger) dynamical elements to the GUI, it started slowing down. This
led me to investigate why the application was slowing down, and how to
remedy the situation. The reason why is pretty simple: in order for Qt
to draw widgets inside the graphics view, it apparently has to render
them twice. Qt will first render the widget to an off-screen buffer,
and then render the content of the off-screen buffer to the graphics
scene as a texture. As soon as we knew why, we started looking at how
to optimize it.

Accelerating the Scene:

Qt allows you to use OpenGL to accelerate the scene. This can
greatly increase the performance, assuming the graphics card in your
computer has decent support for hardware accelerating 2D operations
(this is not the case for nVidia today). To enable OpenGL acceleration,
you will have to create a QGLWidget and tell the graphics scene to use
it as a viewport.  Here’s an example:

QGLWidget* viewport = new QGLWidget(QGLFormat(QGL::DoubleBuffer | QGL::Rgba |
QGL::AlphaChannel | QGL::DirectRendering | QGL::SampleBuffers));
myGraphicsScene->setViewport(viewport);

Item Cache:

The graphics view allows you to independently set the cache mode for each item in the scene.  Setting the cache mode to QGraphicsItem::DeviceCoordinateCache
will make Qt use the cached version of a item instead of redrawing the
item (twice) every time the scene is updated. This sort of cache will
not work if you need to transform (rotate, scale, shear, etc.) the
item. If you need transformation you should have a look at the QGraphicsItem::ItemCoordinateCache
cache mode.

Increasing the Pixmap Cache Size:

While caching the items works good when you’ve got a small amount of
small objects, I soon figured out that when adding larger items, or
just a lot of small ones, the drawing becomes slow again. It took me
some time, but I finally figured out why. When you tell Qt to use cache
for graphics items, it uses its internal QPixmapCache as a buffer for
the items. This is not explicitly mentioned in the documentation, only
a hint is given in the “See also”-section of the documentation. The
default size for this cache is 1024kb
, which explains
why it gets slower the more items you add. Increasing the cache size is
imperative if your application will use a lot of objects and you want
cache. You can achieve this by calling the static function QPixmapCache::setCacheLimit(int)
, just keep in mind it takes kilobytes as the argument.

Other tricks:

While these tricks are the ones that gave the greatest increase in
performance (a dogmatic conclusion, no real benchmarks where made) in
our application, there are several other functions you might want
to  look at:

QGraphicsView::setOptimizationFlag
QGraphicsView::setViewportUpdateMode
QGraphicsScene::setItemIndexMethod

These functions may give an increase in performance, depending on the nature of the application.