QPainting QPixmap using clipping to gain performance

Question

I'm trying to create a simple Image Viewer in Qt with zooming supported.

To display an image file I load it into a QImage and create a QPixmap.

class NN: public QWidget{
    Q_OBJECT
    Q_DISABLE_COPY(NN)
public:
    NN(QWidget* parent = nullptr) : QWidget(parent){
    }
    const QPixmap& pixmap() const 
    {
        return m_pixmap;
    }
    void setPixmap(const QPixmap& px) 
    {
        m_pixmap = px;
        update();
    }
protected:
    void paintEvent(QPaintEvent*)
    {
        QPainter painter(this);
        painter.setRenderHint(QPainter::Antialiasing, false);
        style()->drawItemPixmap(&painter, rect(), Qt::AlignCenter, m_pixmap.scaled(rect().size()));
    }
private:
    QPixmap m_pixmap;
};

(This Widget is part of a ScrollArea)

This works fine, but when I try to load large images and zoom in, the performance starts to decrease (lag).

I thought of applying a clip to the drawItemPixmap() method, but I am not quite sure how and whether it would help increasing the performance.

My question is whether the clipping idea would work, and if so how. If not, maybe there is another way to gain performance?

Jeremy Friesner · Accepted Answer

When m_pixmap and/or rect() are very large, the bulk of your slowdown is likely coming from here:

m_pixmap.scaled(rect().size())

Here you are you are asking Qt to create a new QPixmap object the same size as rect(), which is a potentially very expensive operation; and passing that QPixmap object into the call to drawItemPixmap() which will draw just a small portion of the pixmap, after which the QPixmap object will get discarded, and the whole procedure will have to be done again the next time you want to redraw your object.

Needless to say, that can be very inefficient.

A more efficient approach would be to call QPainter::drawPixmap(const QRect & target, const Pixmap & pixmap, const QRect & source), like this:

painter.drawPixmap(rect(), m_pixmap, srcRect);

... and drawPixmap() will draw a scaled pixmap of size rect() (i.e. just the size of your widget) by rescaling the content of m_pixmap that is inside srcRect; much more efficient than rescaling the entire m_pixmap image.

You'll need to calculate the correct left/top/width/height values for srcRect, of course, but that should be straightforward with a little bit of algebra. (Basically just figure out what portion of the pixmap should currently be visible based on your widget's current zoom/pan state)

QPainting QPixmap using clipping to gain performance

Answers (2)

Related Questions