GraphicsView performance problems

[Gopala Krishna]

Probably I am asking too much from trolls or it is heights of optimization!!
How about rubberbanding support while moving items in future version of qt ? This will surely reduce number of repaints. Anyway I am planning to do this to my app after the port reach some descent stage.

I say this because, the app I am porting(obviously from qt3.3 - 4.2) - qucs uses this technique in qt3 version and the performance is very good. And actually it uses lots of repaints() (instead of update()) and also the code doesn't optimize update by using rect version of update - I mean QWidget::update(QRect r). And best of all, it doesn't use QCanvas. Yet it works fine even on low end pc's.
That is the reason, I am asking question about performance so that the ported version does better than previous one.

[wysota]

What exactly do you mean by rubberbanding support?

[Gopala Krishna]

What exactly do you mean by rubberbanding support?

What I mean is, the elements which are moving can be drawn with something like QPainter::rasterOP() set to NotROP of qt3 and QPen being DotLine. While updating position of item, first the item can be drawn with above flags again at previous position and then in new position.

BTW, did I use a wrong word for this ? (I mean rubberbanding)

[wysota]

What I mean is, the elements which are moving can be drawn with something like QPainter::rasterOP() set to NotROP of qt3 and QPen being DotLine. While updating position of item, first the item can be drawn with above flags again at previous position and then in new position.

I think the problem is not in painting but in reconstructing the index, so it wouldn't help much. The raster operation (XOR here) does make sense only if objects don't overlap. When they do, you'll get trash when moving them away. It's better to redraw the region.

BTW, did I use a wrong word for this ? (I mean rubberbanding)

Yes, sort of Rubber band is used when talking about selecting items (because of a shape that expands if you drag it allowing to select an area - see QRubberBand).

[Gopala Krishna]

I think the problem is not in painting but in reconstructing the index, so it wouldn't help much. The raster operation (XOR here) does make sense only if objects don't overlap. When they do, you'll get trash when moving them away. It's better to redraw the region.

Oh ok. Thanks. I didn't think about this.

[camel]

Just want to share a little thing I just read about on qt4-preview-feedback, for all those who like to play around with snapshots. (And to get it into the archive here too, if anyone looks this thread up later ;-)

In this message Andreas mentions a nice flag you can set on the GraphicsView QGraphicsView::SmartViewportUpdate

Andreas explains the behaviour (a small addition of mine is in cursive)

at a certain threshold (of number of dirty rects)(currently set to 50 rects), the bounding rect is used instead.

You can use it like this to try it out:

#if QT_VERSION >= 0x040300
   view->setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
#endif

#if QT_VERSION >= 0x040300
   view->setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
#endif

To copy to clipboard, switch view to plain text mode 

Another thing you might want to try, is the QGraphicsView::OptimizationFlags. (especially if you do all your clipping yourself, and set the painter state each time anyway, such as I did in my version of the example)
But remember: setting these flags allow you to shoot your own leg off much easier, if you are not carefull...

#if QT_VERSION >= 0x040300
   view->setOptimizationFlags(QGraphicsView::DontClipPainter | QGraphicsView::DontSavePainterState);
#endif

#if QT_VERSION >= 0x040300
   view->setOptimizationFlags(QGraphicsView::DontClipPainter | QGraphicsView::DontSavePainterState);
#endif

To copy to clipboard, switch view to plain text mode 

From my non-scientific try-outs, both make it feel faster to me, individually as well as combined.

[camel]

I thought about starting a page in the wiki about how to get the most from your use of QGraphicsView (so that all the little nice tidbits can be collected somewhere)...

What would be the best name for it?
"Optimizing QGraphicsView", is kind of wrong

"Optimizing your use of QGraphicsView" is correct, but kind-of long...
"Good coding practices for QGraphicsView"...ditto...


Probably the best thing would be to also have a
"Optimizing your use of QPainter" section to be able to refer to it...

[Gopala Krishna]

How about "Optimizing techniques with GraphicsView"

[Gopala Krishna]

Just want to share a little thing I just read about on qt4-preview-feedback, for all those who like to play around with snapshots. (And to get it into the archive here too, if anyone looks this thread up later ;-)

In this message Andreas mentions a nice flag you can set on the GraphicsView QGraphicsView::SmartViewportUpdate

Hey thanks for the nice link. One of the thing qt is good at is to make us eagerly wait for the next version !!!!!
And hence it pulls you towards using the snapshots !
I am surely gonna try this weekend !

[Gopala Krishna]

Today I found some time to play again with all codes in this thread. Just then I thought of one more technique to draw the grid which I think should increase the performance. But I couldn't see major difference while trying it out.
The main idea is to create big pixmap and draw the grid to it in the constructor. In drawBackground() we can just draw relevant part of pixmap. I feel this way, even if the grid size is reduced, the performance remains same. Only thing is I compensate ram for speed which is ok for me. To combat this, probably we can reduce pixmap size to medium one and take necessary actions when the backgroundRect to be drawn is larger.
Anyway the code is here.

Note: This is modified version of camel's code

#include <QtGui>
#include <cmath>
 
namespace {
   static inline int gridFloor(const qreal& value)
   {
      if (value < 0) {
         return -1 * static_cast<int>(std::ceil(qAbs(value)));
      } else {
         return static_cast<int>(std::floor(value));
      }
   }
 
   static inline int gridCeil(const qreal &value)
   {
      if (value < 0) {
         return -1 * static_cast<int>(std::floor(qAbs(value)));
      } else {
         return static_cast<int>(std::ceil(value));
      }
   }
}
 
class GridScene : public QGraphicsScene
{
   public:
      GridScene(qreal x, qreal y, qreal w, qreal h)
         : QGraphicsScene(x, y, w, h)
      {
         setItemIndexMethod(QGraphicsScene::NoIndex);
         setupCache();
      }
 
   protected:
      void setupCache()
      {
         const int gridSize = 25;
         backgroundCache = QPixmap(1024,768);
         backgroundCache.fill(Qt::white);
 
         QPainter painter(&backgroundCache);
         painter.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
         painter.setPen(QPen(Qt::darkGreen,0));
         painter.setBrush(Qt::NoBrush);
 
         for (int x = 0; x < 1024; x += gridSize)
            painter.drawLine(x,0,x,768);
         for (int y = 0; y < 768; y += gridSize)
            painter.drawLine(0,y,1024,y);
 
      }
      void drawBackground(QPainter *painter, const QRectF &rect)
      {
         const int realLeft = gridFloor(rect.left());
         const int realRight = gridCeil(rect.right());
         const int realTop = gridFloor(rect.top());
         const int realBottom = gridCeil(rect.bottom());
         QRect realRect(realLeft,realTop,realRight-realLeft,realBottom-realTop);
         painter->drawPixmap(realRect,backgroundCache,realRect);
      }
 
   private:
      QPixmap backgroundCache;
};
 
namespace {
   static inline QPainterPath constructNodeShape(const QRectF& elipseRect)
   {
      QPainterPath path;
      path.addEllipse(elipseRect);
      return path;
   }
}
 
class Node : public QGraphicsItem
{
   public:
      Node(QGraphicsItem *par = 0, QGraphicsScene *sc = 0)
         : QGraphicsItem(par,sc),
           elipseRect(-4.0, -4.0, 8.0, 8.0),
           elipsePath(constructNodeShape(QRectF(-3.0, -3.0, 2.0*3.0, 2.0*3.0))),
           elipseShape(constructNodeShape(elipseRect)),
           nodePen(Qt::darkRed),
           nodeBrush(Qt::NoBrush)
      {
         setFlags(0);
         setAcceptedMouseButtons(0);
      }
 
      void paint(QPainter* p,const QStyleOptionGraphicsItem *o, QWidget *)
      {
         p->setPen(nodePen);
         p->setBrush(nodeBrush);
         p->setOpacity(1.0);
 
         p->setClipRect(o->exposedRect);
         p->drawPath(elipsePath);
      }
 
      QPainterPath shape() const
      {
         return elipseShape;
      }
 
      QRectF boundingRect() const
      {
         return elipseRect;
      }
 
   protected:
      const QRectF elipseRect;
      const QPainterPath elipsePath;
      const QPainterPath elipseShape;
      const QPen nodePen;
      const QBrush nodeBrush;
};
 
 
namespace {
   static inline QPainterPath constructResistorPath()
   {
      QPainterPath resistorPath;
      resistorPath.addRect(QRectF(-18.0, -9.0, 36.0, 18.0));
      resistorPath.moveTo(-27, 0);
      resistorPath.lineTo(-18, 0);
      resistorPath.moveTo(18, 0);
      resistorPath.lineTo(27, 0);
      return resistorPath;
   }
}
 
class Resistor : public QGraphicsItem
{
   public:
      Resistor(QGraphicsItem *par = 0, QGraphicsScene *scene = 0)
         : QGraphicsItem(par,scene),
           resistorPath(constructResistorPath()),
           boundingBox(resistorPath.boundingRect().adjusted(-1, -1, 1, 1)),
           resistorSelectedPen(Qt::darkBlue),
           resistorOpenPen(Qt::darkGray,1),
           resistorBrush(Qt::NoBrush)
      {
         setFlags(ItemIsMovable | ItemIsSelectable | ItemIsFocusable);
         // comment the following  4 lines to see the performance difference
         QGraphicsTextItem *t = new QGraphicsTextItem("R1 = 100k",this,scene);
         t->setPos(0,-35);
         Node * node = new Node(this,scene);
         node->setPos(QPointF(-30,0));
         node = new Node(this,scene);
         node->setPos(QPointF(30,0));
      }
 
      void paint(QPainter *p, const QStyleOptionGraphicsItem *o, QWidget *)
      {
         if(!(o->state & QStyle::State_Open))
            p->setPen(resistorOpenPen);
         if(o->state & QStyle::State_Selected)
            p->setPen(resistorSelectedPen);
 
         p->setClipRect( o->exposedRect );
         p->setBrush(resistorBrush);
         p->drawPath(resistorPath);
      }
 
      QRectF boundingRect() const
      {
         return boundingBox;
      }
 
   private:
      const QPainterPath resistorPath;
      const QRectF boundingBox;
      const QPen resistorSelectedPen;
      const QPen resistorOpenPen;
      const QBrush resistorBrush;
};
 
int main(int argc,char *argv[])
{
   QApplication app(argc,argv);
   GridScene scene(0,0,1024,768);
   for(int j = 2; j < 4; ++j)
      for(int i = 1; i <11; ++i)
      {
         Resistor *r = new Resistor(0,&scene);
         r->setPos(j*100, i * 50);
      }
   QGraphicsView *view = new QGraphicsView(&scene);
   view->setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
   view->setDragMode(QGraphicsView::RubberBandDrag);
   view->show();
   return app.exec();
}

#include <QtGui>
#include <cmath>
       
namespace {
   static inline int gridFloor(const qreal& value)
   {
      if (value < 0) {
         return -1 * static_cast<int>(std::ceil(qAbs(value)));
      } else {
         return static_cast<int>(std::floor(value));
      }
   }
       
   static inline int gridCeil(const qreal &value)
   {
      if (value < 0) {
         return -1 * static_cast<int>(std::floor(qAbs(value)));
      } else {
         return static_cast<int>(std::ceil(value));
      }
   }
}
       
class GridScene : public QGraphicsScene
{
   public:
      GridScene(qreal x, qreal y, qreal w, qreal h)
         : QGraphicsScene(x, y, w, h)
      {
         setItemIndexMethod(QGraphicsScene::NoIndex);
         setupCache();
      }
       
   protected:
      void setupCache()
      {
         const int gridSize = 25;
         backgroundCache = QPixmap(1024,768);
         backgroundCache.fill(Qt::white);
         
         QPainter painter(&backgroundCache);
         painter.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
         painter.setPen(QPen(Qt::darkGreen,0));
         painter.setBrush(Qt::NoBrush);

         for (int x = 0; x < 1024; x += gridSize)
            painter.drawLine(x,0,x,768);
         for (int y = 0; y < 768; y += gridSize)
            painter.drawLine(0,y,1024,y);
                
      }
      void drawBackground(QPainter *painter, const QRectF &rect)
      {
         const int realLeft = gridFloor(rect.left());
         const int realRight = gridCeil(rect.right());
         const int realTop = gridFloor(rect.top());
         const int realBottom = gridCeil(rect.bottom());
         QRect realRect(realLeft,realTop,realRight-realLeft,realBottom-realTop);
         painter->drawPixmap(realRect,backgroundCache,realRect);
      }
       
   private:
      QPixmap backgroundCache;
};
       
namespace {
   static inline QPainterPath constructNodeShape(const QRectF& elipseRect)
   {
      QPainterPath path;
      path.addEllipse(elipseRect);
      return path;
   }
}
       
class Node : public QGraphicsItem
{
   public:
      Node(QGraphicsItem *par = 0, QGraphicsScene *sc = 0)
         : QGraphicsItem(par,sc),
           elipseRect(-4.0, -4.0, 8.0, 8.0),
           elipsePath(constructNodeShape(QRectF(-3.0, -3.0, 2.0*3.0, 2.0*3.0))),
           elipseShape(constructNodeShape(elipseRect)),
           nodePen(Qt::darkRed),
           nodeBrush(Qt::NoBrush)
      {
         setFlags(0);
         setAcceptedMouseButtons(0);
      }
       
      void paint(QPainter* p,const QStyleOptionGraphicsItem *o, QWidget *)
      {
         p->setPen(nodePen);
         p->setBrush(nodeBrush);
         p->setOpacity(1.0);
       
         p->setClipRect(o->exposedRect);
         p->drawPath(elipsePath);
      }
       
      QPainterPath shape() const
      {
         return elipseShape;
      }
       
      QRectF boundingRect() const
      {
         return elipseRect;
      }
       
   protected:
      const QRectF elipseRect;
      const QPainterPath elipsePath;
      const QPainterPath elipseShape;
      const QPen nodePen;
      const QBrush nodeBrush;
};
       
       
namespace {
   static inline QPainterPath constructResistorPath()
   {
      QPainterPath resistorPath;
      resistorPath.addRect(QRectF(-18.0, -9.0, 36.0, 18.0));
      resistorPath.moveTo(-27, 0);
      resistorPath.lineTo(-18, 0);
      resistorPath.moveTo(18, 0);
      resistorPath.lineTo(27, 0);
      return resistorPath;
   }
}
       
class Resistor : public QGraphicsItem
{
   public:
      Resistor(QGraphicsItem *par = 0, QGraphicsScene *scene = 0)
         : QGraphicsItem(par,scene),
           resistorPath(constructResistorPath()),
           boundingBox(resistorPath.boundingRect().adjusted(-1, -1, 1, 1)),
           resistorSelectedPen(Qt::darkBlue),
           resistorOpenPen(Qt::darkGray,1),
           resistorBrush(Qt::NoBrush)
      {
         setFlags(ItemIsMovable | ItemIsSelectable | ItemIsFocusable);
         // comment the following  4 lines to see the performance difference
         QGraphicsTextItem *t = new QGraphicsTextItem("R1 = 100k",this,scene);
         t->setPos(0,-35);
         Node * node = new Node(this,scene);
         node->setPos(QPointF(-30,0));
         node = new Node(this,scene);
         node->setPos(QPointF(30,0));
      }
       
      void paint(QPainter *p, const QStyleOptionGraphicsItem *o, QWidget *)
      {
         if(!(o->state & QStyle::State_Open))
            p->setPen(resistorOpenPen);
         if(o->state & QStyle::State_Selected)
            p->setPen(resistorSelectedPen);
       
         p->setClipRect( o->exposedRect );
         p->setBrush(resistorBrush);
         p->drawPath(resistorPath);
      }
       
      QRectF boundingRect() const
      {
         return boundingBox;
      }
       
   private:
      const QPainterPath resistorPath;
      const QRectF boundingBox;
      const QPen resistorSelectedPen;
      const QPen resistorOpenPen;
      const QBrush resistorBrush;
};
       
int main(int argc,char *argv[])
{
   QApplication app(argc,argv);
   GridScene scene(0,0,1024,768);
   for(int j = 2; j < 4; ++j)
      for(int i = 1; i <11; ++i)
      {
         Resistor *r = new Resistor(0,&scene);
         r->setPos(j*100, i * 50);
      }
   QGraphicsView *view = new QGraphicsView(&scene);
   view->setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
   view->setDragMode(QGraphicsView::RubberBandDrag);
   view->show();
   return app.exec();
}

To copy to clipboard, switch view to plain text mode 

[camel]

What happens if you make the window larger than the pixmap? :-)

Thing is, I would imagine that most draws are actually rather small pieces. (Fixing for moving items), so I do not know if it is faster to always work with the one big pixmap.

Probably best would be something like 3 or 4 gridsizes as a cache...but I have not tested it out...

[Gopala Krishna]

While experimenting further I noticed one of the major neglected thing.
Just add this

view->scale(4.0,4.0);

view->scale(4.0,4.0);

To copy to clipboard, switch view to plain text mode 

And now it is very very slow!!! Why ? Can someone explain this ?
Also the the gridlines are quite thicker which I don't want .
Please some one help me

EDIT: This happens only in pixmap version of grids.

[wysota]

Just add this

view->scale(4.0,4.0);

view->scale(4.0,4.0);

To copy to clipboard, switch view to plain text mode 

And now it is very very slow!!! Why ? Can someone explain this ?

Sure, you introduced matrix transformations which makes everything more computation intensive (the pixmap is scaled).

Also the the gridlines are quite thicker which I don't want .
Please some one help me

There is nothing you can do when using a pixmap to change it. The pixmap just gets scaled and all pixels get four times bigger in each direction.