GraphicsView performance problems

[wysota]

That looks really weird.
The reason probably once again that the time is spent inside of Qt-Code and not yours, so sadly that does not help.

These figures are wrong. All functions from inside Qt should be counted on behalf of the functions calling them and here all functions have nothing but zeros. The application needs to run longer.

Or it could have been inlined, again not really helpfull :-/

Yes, that's possible, especially if they were implemented inside the class header and optimisations were enabled.

You must be sure to disable inlining optimisations. You can use -fno-inline to disable inlining.

[Gopala Krishna]

Yup! you both are right. Anyway I am recompiling Qt tomorrow. I'll surely post after I do that. In the meanwhile I'd like to inform you people that I have never used cachegrind. Is that better than gprof ? If yes how should I use that ?

[camel]

Did you try my last modification? Did it change anything for you?

Yup! you both are right. Anyway I am recompiling Qt tomorrow. I'll surely post after I do that. In the meanwhile I'd like to inform you people that I have never used cachegrind. Is that better than gprof ? If yes how should I use that ?

You do not need to compile anything special (besides DEBUG of course ;-)

Then call

$valgrind --tool=callgrind ./YOUR_APP

this will produce a file called callgrind.out.PID_OF_PROCESS

then you can call

$kcachegrind callgrind.out.PID_OF_PROCESS

http://kcachegrind.sourceforge.net/cgi-bin/show.cgi

[Gopala Krishna]

Did you try my last modification? Did it change anything for you?



You do not need to compile anything special (besides DEBUG of course ;-)

Then call


this will produce a file called callgrind.out.PID_OF_PROCESS

then you can call


http://kcachegrind.sourceforge.net/cgi-bin/show.cgi

Thanks ! Here is the output as attachment
EDIT: My quota of attachment is almost over. I'll update a bit later.

[wysota]

I have modified my application which uses QGraphicsView framework to draw a grid simmilar to yours and I implemented it in a worst possible way:

void drawBackground ( QPainter * painter, const QRectF & rect ){
  static QPen p(QColor(150,150,150));
  painter->setPen(p);
  for(int row=10+((int)(rect.top())/10)*10; row<rect.bottom(); row+=10){
    for(int col = 10+((int)(rect.left())/10)*10; col<rect.right(); col+=10)
       painter->drawPoint(col, row);
  }
}

void drawBackground ( QPainter * painter, const QRectF & rect ){
  static QPen p(QColor(150,150,150));
  painter->setPen(p);
  for(int row=10+((int)(rect.top())/10)*10; row<rect.bottom(); row+=10){
    for(int col = 10+((int)(rect.left())/10)*10; col<rect.right(); col+=10)
       painter->drawPoint(col, row);
  }
}

To copy to clipboard, switch view to plain text mode 

Profiling info (compiled with -fno-inline -ggdb -pg) looks like this:

%   cumulative   self              self     total
 time   seconds   seconds    calls  us/call  us/call  name
 33.33      0.02     0.02  1547664     0.01     0.01  QRectF::right() const
 33.33      0.04     0.02                             SpecScene::drawBackground(QPainter*, QRectF const&)
 16.67      0.05     0.01  1527572     0.01     0.01  QPainter::drawPoint(int, int)

%   cumulative   self              self     total
 time   seconds   seconds    calls  us/call  us/call  name
 33.33      0.02     0.02  1547664     0.01     0.01  QRectF::right() const
 33.33      0.04     0.02                             SpecScene::drawBackground(QPainter*, QRectF const&)
 16.67      0.05     0.01  1527572     0.01     0.01  QPainter::drawPoint(int, int)

To copy to clipboard, switch view to plain text mode 

As you see 33% of the application time is spent in drawBackground and half of it is used to calculate QRectF::right() (which makes sense as it gets calculated in each iteration of the loop) and pretty much is used to actually draw the points.

index % time    self  children    called     name
                                                 <spontaneous>
[1]     83.3    0.02    0.03                 SpecScene::drawBackground(QPainter*, QRectF const&) [1]
                0.02    0.00 1547627/1547664     QRectF::right() const [2]
                0.01    0.00 1527572/1527572     QPainter::drawPoint(int, int) [3]
                0.00    0.00   20635/20651       QRectF::bottom() const [35]
                0.00    0.00   20055/20055       QRectF::left() const [36]
                0.00    0.00     580/580         QRectF::top() const [93]
                0.00    0.00       1/702         QColor::QColor(int, int, int, int) [92]

index % time    self  children    called     name
                                                 <spontaneous>
[1]     83.3    0.02    0.03                 SpecScene::drawBackground(QPainter*, QRectF const&) [1]
                0.02    0.00 1547627/1547664     QRectF::right() const [2]
                0.01    0.00 1527572/1527572     QPainter::drawPoint(int, int) [3]
                0.00    0.00   20635/20651       QRectF::bottom() const [35]
                0.00    0.00   20055/20055       QRectF::left() const [36]
                0.00    0.00     580/580         QRectF::top() const [93]
                0.00    0.00       1/702         QColor::QColor(int, int, int, int) [92]

To copy to clipboard, switch view to plain text mode 

As you see it is actually more time consuming to calculate the rectangle coords than to draw points!

Some facts:
- I use Qt4.2.2 on i686 Linux,
- I didn't use antialiasing,
- I didn't use scaling (so I have an identity matrix when it comes to viewport-window transformations),
- scene size was about 1200x1000,
- I didn't compile Qt with profiling information (so I guess it's not required after all),
- I got detailed info about both mine and Qt methods,
- the result is pretty fast.

I got a pretty good result, but I didn't suffer from viewport-window transformations which might be your case if you scale the view. I didn't use antialiasing for my view, as points are points - they don't suffer from the aliasing effect. I could easily improve the implementation by calculating rectangle coordinates once per drawBackground() which should reduce the execution effort by half.

It is up to you to do the interpretation of the results. My impression is that it is not really drawBackground() which causes the slowdown - maybe it is just called too often by other parts of the system? Maybe you abuse update()?

[camel]

I have modified my application which uses QGraphicsView framework to draw a grid simmilar to yours and I implemented it in a worst possible way:

Profiling info (compiled with -fno-inline -ggdb -pg) looks like this:

%   cumulative   self              self     total
 time   seconds   seconds    calls  us/call  us/call  name
 33.33      0.02     0.02  1547664     0.01     0.01  QRectF::right() const
 33.33      0.04     0.02                             SpecScene::drawBackground(QPainter*, QRectF const&)
 16.67      0.05     0.01  1527572     0.01     0.01  QPainter::drawPoint(int, int)

%   cumulative   self              self     total
 time   seconds   seconds    calls  us/call  us/call  name
 33.33      0.02     0.02  1547664     0.01     0.01  QRectF::right() const
 33.33      0.04     0.02                             SpecScene::drawBackground(QPainter*, QRectF const&)
 16.67      0.05     0.01  1527572     0.01     0.01  QPainter::drawPoint(int, int)

To copy to clipboard, switch view to plain text mode 

Well, if you disable inlining, no wonder right() is expensive. calling a function 1.5 Million times just takes its time...inlining is there for a reason ;-)

So I would not call this run very exemplary... :-)

[camel]

just a note:
If you like to profile further into the drawing part,
you need to call:

valgrind --tool=callgrind --seperate-callers=5 --seperate-recs=10 ./YOUR_APP

Otherwise you will get "cycles", which is not very helpfull in this task..

BUT: this takes up much more memory to analyze later...

[camel]

Hi,

well I just love to play with this... ;-)


Here is another (and much faster) way to write the drawBackground function...with the added niceness that it helps avoiding the color errors ;-)

You might want to check if this survives zooming etc.

void drawBackground(QPainter *painter, const QRectF &rect)
      {
         const int gridSize = 25;
 
        if (backgroundCache.isNull()) {
            backgroundCache = QPixmap(gridSize, gridSize);
            const int middle = gridSize / 2;
            QPainter backgroundPainter(&backgroundCache);
            backgroundPainter.setRenderHints(painter->renderHints());
            backgroundPainter.fillRect(QRect(0, 0, gridSize, gridSize), QBrush(Qt::white));
            backgroundPainter.setPen(backgroundPen);
            backgroundPainter.setBrush(backgroundBrush);
            backgroundPainter.drawLine(0, middle, gridSize, middle);
            backgroundPainter.drawLine(middle, 0, middle, gridSize);
        }
 
         const int realLeft = static_cast<int>(std::floor(rect.left()));
         const int realRight = static_cast<int>(std::ceil(rect.right()));
         const int realTop = static_cast<int>(std::floor(rect.top()));
         const int realBottom = static_cast<int>(std::ceil(rect.bottom()));
 
 
         const int firstLeftGridLine = realLeft - (realLeft % gridSize);
         const int firstTopGridLine = realTop - (realTop % gridSize);
 
 
         QPainterPath background;
         for (int x = firstLeftGridLine; x < realRight; x += gridSize) {
            for (int y = firstTopGridLine; y < realBottom; y += gridSize) {
                painter->drawPixmap(x, y, backgroundCache);
            }
        }
      }

void drawBackground(QPainter *painter, const QRectF &rect)
      {
         const int gridSize = 25;

        if (backgroundCache.isNull()) {
            backgroundCache = QPixmap(gridSize, gridSize);
            const int middle = gridSize / 2;
            QPainter backgroundPainter(&backgroundCache);
            backgroundPainter.setRenderHints(painter->renderHints());
            backgroundPainter.fillRect(QRect(0, 0, gridSize, gridSize), QBrush(Qt::white));
            backgroundPainter.setPen(backgroundPen);
            backgroundPainter.setBrush(backgroundBrush);
            backgroundPainter.drawLine(0, middle, gridSize, middle);
            backgroundPainter.drawLine(middle, 0, middle, gridSize);
        }

         const int realLeft = static_cast<int>(std::floor(rect.left()));
         const int realRight = static_cast<int>(std::ceil(rect.right()));
         const int realTop = static_cast<int>(std::floor(rect.top()));
         const int realBottom = static_cast<int>(std::ceil(rect.bottom()));


         const int firstLeftGridLine = realLeft - (realLeft % gridSize);
         const int firstTopGridLine = realTop - (realTop % gridSize);


         QPainterPath background;
         for (int x = firstLeftGridLine; x < realRight; x += gridSize) {
            for (int y = firstTopGridLine; y < realBottom; y += gridSize) {
                painter->drawPixmap(x, y, backgroundCache);
            }
        }
      }

To copy to clipboard, switch view to plain text mode 

Have a nice day :-)

[Gopala Krishna]

Hi,

well I just love to play with this... ;-)


Here is another way to write the drawBackground function...with the added niceness that it helps avoiding the color errors ;-)

You might want to check if this survives zooming etc.

void drawBackground(QPainter *painter, const QRectF &rect)
      ...

void drawBackground(QPainter *painter, const QRectF &rect)
      ...

To copy to clipboard, switch view to plain text mode 

Have a nice day :-)

Not bad idea! That problem solved !!! Thanks a lot.
Now the next problem is performance !
A good day to you too

[Gopala Krishna]

just a note:
If you like to profile further into the drawing part,
you need to call:


Otherwise you will get "cycles", which is not very helpfull in this task..

BUT: this takes up much more memory to analyze later...

I get the following error

valgrind: Bad option '--seperate-callers=5'; aborting.

I am trying to analyse the code as it is now. I am getting lost here and there but kcachegrind is a cool tool. Needs some time to get used to it. Thanks for helping me till now. I'll continue with this tomorrow.

[camel]

I get the following error
valgrind: Bad option '--seperate-callers=5'; aborting.

I think they changed the option names during 3.1 and 3.2 (which I use)

try:
valgrind --tool=callgrind --fn-caller=5 --fn-recursion=10 ./YOUR_APP

[wysota]

Well, if you disable inlining, no wonder right() is expensive. calling a function 1.5 Million times just takes its time...inlining is there for a reason ;-)

So I would not call this run very exemplary... :-)

It means that QRectF::right() takes longer than QPainter::drawPoint() and right() is not a very complex method

After getting rid of the right() and bottom() calls inside the loop the result of profiling is as follows:

50.00      0.06     0.06                             SpecScene::drawBackground(QPainter*, QRectF const&)
 25.00      0.09     0.03  1460235     0.02     0.02  QPoint::QPoint(int, int)
 16.67      0.11     0.02  1454915     0.01     0.03  QPainter::drawPoint(int, int)

50.00      0.06     0.06                             SpecScene::drawBackground(QPainter*, QRectF const&)
 25.00      0.09     0.03  1460235     0.02     0.02  QPoint::QPoint(int, int)
 16.67      0.11     0.02  1454915     0.01     0.03  QPainter::drawPoint(int, int)

To copy to clipboard, switch view to plain text mode 

The QPoint constructor is called by QPainter::drawPoint, so we can forget about it. The whole method takes over 90% of the whole application time and gives a total of less than 0.1s. That's not much

It is important to see what the bottleneck is instead of shooting blind. No matter how much you optimise QPainter::drawLines() if it's not the bottleneck, you won't get a decent improvement.

In my opinion it would be much simpler and faster to simply apply a backgroundBrush with the grid to the scene and forget about points and lines. You wouldn't get any painter paths then, no floating point operations. The only thing that could slow down the process is the matrix transformation, so try to avoid it.

[camel]

It is important to see what the bottleneck is instead of shooting blind. No matter how much you optimise QPainter::drawLines() if it's not the bottleneck, you won't get a decent improvement.

That is why I look into my KCachgrind and follow the callgraph and sources ;-)

The problem is not drawPoints, as that does not do much.

The problem with drawLines and friends is that it often (with antialiasing) first creates a painterpath from those lines and then paints them. This takes time, not least because of memory allocation.

This is why I said use painterpaths directly.

Optimizing the returnvalue of boundingrect and shape is so easy (and makes the code much nicer in my opinion) so that I would not even consider it a optimization, its just nicer programming. (besides helping during run-time of course ;-)

In my opinion it would be much simpler and faster to simply apply a backgroundBrush with the grid to the scene and forget about points and lines. You wouldn't get any painter paths then, no floating point operations. The only thing that could slow down the process is the matrix transformation, so try to avoid it.

I cuncur there, see my last post about the drawbackground function.
To use a background brush would be the logical next step ;-)

[wysota]

The problem with drawLines and friends is that it often (with antialiasing) first creates a painterpath from those lines and then paints them. This takes time, not least because of memory allocation.

This is why I said use painterpaths directly.

If you disable antialiasing, there is a possibility that painter paths will not be used. And there is no point in having antialiasing enabled for drawing horizontal or vertical lines, as these don't suffer from the aliasing effect. You can safely temporarily disable antialiasing while painting those.

bool isAA = painter->renderHints() & QPainter::Antialiasing;
painter->setRenderHint(QPainter::Antialiasing, false);
painter->drawLines(...);
painter->setRenderHint(QPainter::Antialiasing, isAA);

bool isAA = painter->renderHints() & QPainter::Antialiasing;
painter->setRenderHint(QPainter::Antialiasing, false);
painter->drawLines(...);
painter->setRenderHint(QPainter::Antialiasing, isAA);

To copy to clipboard, switch view to plain text mode 

Another possibility of painter paths being active is that there is scaling involved. But while zooming in, the number of lines needed to draw should decrease. While zooming out on the other hand you can draw fewer lines as too many of them will clutter the scene anyway.

You can also store the path in a member variable and then only draw the path on the painter. But I think using a background brush will be much faster, especially with smooth scaling disabled.

[camel]

If you disable antialiasing, there is a possibility that painter paths will not be used. And there is no point in having antialiasing enabled for drawing horizontal or vertical lines, as these don't suffer from the aliasing effect. You can safely temporarily disable antialiasing while painting those.

The problem being of course that the lines look differenty ;-)
But some people might see that as an advantage in this case.

Another possibility of painter paths being active is that there is scaling involved. But while zooming in, the number of lines needed to draw should decrease. While zooming out on the other hand you can draw fewer lines as too many of them will clutter the scene anyway.

You can also store the path in a member variable and then only draw the path on the painter. But I think using a background brush will be much faster, especially with smooth scaling disabled.

In this case the brush is faster. Storing the path in a member variable is not possible in this case, as the lines to draw will change wildly during repaints, and I am not sure how efficient it would be to crop out the rest if you draw all possible lines.

For the other items, I did just that, storing the path. which works out quite well. I might be possible to also use pixmaps here, but that is probably rather a space/time tradeoff... :-)

[wysota]

The problem being of course that the lines look differenty ;-)

Could you explain what you mean by that? Antialiasing shouldn't have any positive effect on horizontal/vertical lines... You can reduce the contrast by using antialiasing on horizontal/vertical lines, but that doesn't improve the line. You can just change the colour you use for drawing and have the same optical effect...

By the way... by a "line" I understand a "thin line" not a "thick filled rectangle". Of course you can still have a simmilar effect to antialiasing by using a pen different than a brush...

[camel]

Could you explain what you mean by that? Antialiasing shouldn't have any positive effect on horizontal/vertical lines... You can reduce the contrast by using antialiasing on horizontal/vertical lines, but that doesn't improve the line. You can just change the colour you use for drawing and have the same optical effect...

By the way... by a "line" I understand a "thin line" not a "thick filled rectangle". Of course you can still have a simmilar effect to antialiasing by using a pen different than a brush...

I did not say "positive effect", I just said "effect"

Why the effect:
A one-pixel line not antialiased is exactly one pixel wide
A one-pixel line antialiased will have the centre of the line on the border between two pixels. (See here


If you do not use anti-aliasing for all horizontal and vertical lines (such as the resistors in this example) you will have two very different looking lines.

You might like the effect of having different lines or not, but they will look different :-)

[wysota]

The main problem is probably not "within" drawBackground but the method which calls it more often than necessary.

That's why I mentioned update(). Try reducing the number of items (for example by simplifying the resistor item to consist of only one item), it may improve performance.

I mean though we optimize drawBackground() , we need to find out why it is called many times than necessary.

Funny... I have just taken a look at the profiling info you provided and it seems that it's not mentioned how many time drawBackground() is called. But it might be because of an incorrect compilation of the application (that's why you don't get detailed profiling information for drawBackground()).

I feel this because of experimenting with larger boundingRect gave good performance - i.e lesser drawBackground calls.

Increasing boundingRect() causes less modifications of the BSP tree while moving items.

I tried by disabling indexing in mousePressEvent() when selectedItems().isEmpty() == false and enabling it again in release event. This didn't help much either

Try disabling it entirely.

I did not say "positive effect", I just said "effect"

OK

If you do not use anti-aliasing for all horizontal and vertical lines (such as the resistors in this example) you will have two very different looking lines.

I didn't say not to antialias the resistors but the grid. You won't notice any differences between lines then as all grid lines will be drawn in the same way and you can manipulate the contrast (as antialiasing blurs the edges of lines to reduce the contrast) by changing the colour of the pen.

[camel]

I just wanted to post my last version of the to-be-optimized app.

Little changes I made, were for example:
* making sure that it actually paints correctly (also when the view gets to big, and we start to receive negative coordinates ;-)
* setting QGraphicsScene::NoIndex, with no obvious negative effects
* noticing that it is actually faster (on X11) to draw the pixmap by hand a few times than to use a brush :-/
* setting clipping to the exposed rect while painting the nodes

The top timespenders in the app are basically all related to QRegion, i.e. collision detection and repainting. These can only be optimized...well indirectly...


Anyways, if anybody would like to try out that version, here it is

#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));
        }
    }
 
    static inline int nextSmallerGrid(const int &value, const int &gridSize)
    {
        if (value < 0) {
            const int absValue = qAbs(value);
            return -1 * (absValue + gridSize - (absValue % gridSize));
        } else {
            return value - (value % gridSize);
        }
    }
}
 
class GridScene : public QGraphicsScene
{
   public:
      GridScene(qreal x, qreal y, qreal w, qreal h)
         : QGraphicsScene(x, y, w, h)
    {
        setItemIndexMethod(QGraphicsScene::NoIndex);
    }
 
   protected:
      void drawBackground(QPainter *painter, const QRectF &rect)
      {
          const int gridSize = 25;
 
          if (backgroundCache.isNull()) {
              backgroundCache = QPixmap(gridSize, gridSize);
              const int middle = gridSize / 2;
              {
                  QPainter backgroundPainter(&backgroundCache);
                  backgroundPainter.setRenderHints(painter->renderHints());
                  backgroundPainter.fillRect(QRect(0, 0, gridSize, gridSize), QBrush(Qt::white));
                  backgroundPainter.setPen(QPen(Qt::darkGreen,0));
                  backgroundPainter.setBrush(Qt::NoBrush);
                  backgroundPainter.drawLine(0, middle, gridSize, middle);
                  backgroundPainter.drawLine(middle, 0, middle, gridSize);
              }
          }
 
          const int realLeft = gridFloor(rect.left());
          const int realRight = gridCeil(rect.right());
          const int realTop = gridFloor(rect.top());
          const int realBottom = gridCeil(rect.bottom());
 
 
          const int firstLeftGridLine = nextSmallerGrid(realLeft, gridSize);
          const int firstTopGridLine = nextSmallerGrid(realTop, gridSize);
 
          QRectF cacheRect(0, 0, gridSize, gridSize);
          for (int x = firstLeftGridLine; x < realRight; x += gridSize) {
              for (int y = firstTopGridLine; y < realBottom; y += gridSize) {
                  painter->drawPixmap(QRectF(x, y, gridSize, gridSize),
                                      backgroundCache,
                                      cacheRect);
              }
          }
      }
 
   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));
        }
    }

    static inline int nextSmallerGrid(const int &value, const int &gridSize)
    {
        if (value < 0) {
            const int absValue = qAbs(value);
            return -1 * (absValue + gridSize - (absValue % gridSize));
        } else {
            return value - (value % gridSize);
        }
    }
}

class GridScene : public QGraphicsScene
{
   public:
      GridScene(qreal x, qreal y, qreal w, qreal h)
         : QGraphicsScene(x, y, w, h)
    {
        setItemIndexMethod(QGraphicsScene::NoIndex);
    }

   protected:
      void drawBackground(QPainter *painter, const QRectF &rect)
      {
          const int gridSize = 25;

          if (backgroundCache.isNull()) {
              backgroundCache = QPixmap(gridSize, gridSize);
              const int middle = gridSize / 2;
              {
                  QPainter backgroundPainter(&backgroundCache);
                  backgroundPainter.setRenderHints(painter->renderHints());
                  backgroundPainter.fillRect(QRect(0, 0, gridSize, gridSize), QBrush(Qt::white));
                  backgroundPainter.setPen(QPen(Qt::darkGreen,0));
                  backgroundPainter.setBrush(Qt::NoBrush);
                  backgroundPainter.drawLine(0, middle, gridSize, middle);
                  backgroundPainter.drawLine(middle, 0, middle, gridSize);
              }
          }

          const int realLeft = gridFloor(rect.left());
          const int realRight = gridCeil(rect.right());
          const int realTop = gridFloor(rect.top());
          const int realBottom = gridCeil(rect.bottom());


          const int firstLeftGridLine = nextSmallerGrid(realLeft, gridSize);
          const int firstTopGridLine = nextSmallerGrid(realTop, gridSize);

          QRectF cacheRect(0, 0, gridSize, gridSize);
          for (int x = firstLeftGridLine; x < realRight; x += gridSize) {
              for (int y = firstTopGridLine; y < realBottom; y += gridSize) {
                  painter->drawPixmap(QRectF(x, y, gridSize, gridSize),
                                      backgroundCache,
                                      cacheRect);
              }
          }
      }

   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 

Uiiii....that was fun... ;-)

[Gopala Krishna]

That's why I mentioned update(). Try reducing the number of items (for example by simplifying the resistor item to consist of only one item), it may improve performance.

This won't be possible since I need node to be independent of component.

Funny... I have just taken a look at the profiling info you provided and it seems that it's not mentioned how many time drawBackground() is called. But it might be because of an incorrect compilation of the application (that's why you don't get detailed profiling information for drawBackground()).

I'll post the proper one after recompilation today.

Increasing boundingRect() causes less modifications of the BSP tree while moving items. Try disabling it entirely.

Could the last post in this thread mean an improvement of performance in Qt4.3 with indexing enabled.