GraphicsView performance problems

Hi,
Actually this is continuation of this thread but the question is quite different.
I am running into performance problems when multiple items are moved. The peformance is better when I disable the children of resistor(nodes and text item). But I want those features in my app. Also the grid look corrupted when items are moved. Any suggestion for that ?
Here is the profile output

Quote:

---

Flat profile:

Each sample counts as 0.01 seconds.
% cumulative self self total
time seconds seconds calls Ts/call Ts/call name
75.08 0.03 0.03 GridScene::drawBackground(QPainter*, QRectF const&)
25.03 0.04 0.01 Resistor::boundingRect() const
0.00 0.04 0.00 119168 0.00 0.00 QVarLengthArray<QLineF, 100>::realloc(int, int)

---

Here is the shorter version of the code. Select all items and move so that you can see what I mean. Please help me. :)

Code:

---

#include <QtGui>
 
class GridScene : public QGraphicsScene
{
   public:
      GridScene(qreal x, qreal y, qreal w, qreal h)
         : QGraphicsScene(x, y, w, h)
      { }
 
   protected:
      void drawBackground(QPainter *painter, const QRectF &rect)
      {
         const int gridSize = 25;
         painter->setPen(QPen(Qt::darkGreen,0));
         qreal left = int(rect.left()) - (int(rect.left()) % gridSize);
         qreal top = int(rect.top()) - (int(rect.top()) % gridSize);
 
         QVarLengthArray<QLineF, 100> lines;
 
         for (qreal x = left; x < rect.right(); x += gridSize)
            lines.append(QLineF(x, rect.top(), x, rect.bottom()));
         for (qreal y = top; y < rect.bottom(); y += gridSize)
            lines.append(QLineF(rect.left(), y, rect.right(), y));
 
         painter->drawLines(lines.data(), lines.size());
      }
};
 
class Node : public QGraphicsItem
{
   public:
      Node(QPointF pos ,QGraphicsItem *par = 0, QGraphicsScene *sc = 0) : QGraphicsItem(par,sc)
      {
         setPos(pos);
         setFlags(0);
         setAcceptedMouseButtons(0);
      }
 
      void paint(QPainter* p,const QStyleOptionGraphicsItem *, QWidget *)
      {
         p->setPen(Qt::darkRed);
         p->drawEllipse(QRectF(-3, -3, 2*3, 2*3));
      }
 
      QPainterPath shape() const
      {
         QPainterPath path;
         path.addEllipse(QRectF(-3, -3, 2*3, 2*3));
         return path;
      }
 
      QRectF boundingRect() const
      {
         return QRectF(-3, -3, 2*3, 2*3);
      }
 
};
 
class Resistor : public QGraphicsItem
{
   public:
      Resistor(QGraphicsItem *par = 0, QGraphicsScene *scene = 0) : QGraphicsItem(par,scene)
      {
         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);
         new Node(QPointF(-30,0),this,scene);
         new Node(QPointF(30,0),this,scene);
      }
 
      void paint(QPainter *p, const QStyleOptionGraphicsItem *o, QWidget *)
      {
         if(!(o->state & QStyle::State_Open))
            p->setPen(Qt::darkBlue);
         if(o->state & QStyle::State_Selected)
            p->setPen(QPen(Qt::darkGray,1));
 
         p->drawLine(-18, -9, 18, -9);
         p->drawLine( 18, -9, 18,  9);
         p->drawLine( 18,  9,-18,  9);
         p->drawLine(-18,  9,-18, -9);
         p->drawLine(-27,  0,-18,  0);
         p->drawLine( 18,  0, 27,  0);
      }
 
      QRectF boundingRect() const
      {
         qreal pw = 0.5;
         return QRectF(-27,-9,54,18).adjusted(-pw,-pw,pw,pw);
      }
};
 
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();
}

---

In your main function just add

view->setViewport(new QGLWidget);

I am sure, this will improve the performence.
please add QGLWidget include file & path in settings.

Quote:

---

Originally Posted by rajesh

In your main function just add

view->setViewport(new QGLWidget);

I am sure, this will improve the performence.
please add QGLWidget include file & path in settings.

---

Wish I could have done that but I can't use opengl since the app is targeted to platforms even without opengl support.
But I tested it now and found some improvement but sadly I can't use it.

What if you disable the render hints while painting the background? Do you get a significant performance gain? Could you also please include information about profiling for drawBackground()? It might require a recompilation of Qt!

Quote:

---

Originally Posted by wysota

What if you disable the render hints while painting the background? Do you get a significant performance gain?

---

Disabling render hints didn't improve the performance significantly.

Quote:

---

Originally Posted by wysota

Could you also please include information about profiling for drawBackground()?!It might require a recompilation of Qt

---

I can do that but i may have to do re-recompilation later :(
Before that, do you see any problems in my code ? Did you see performance difference after commenting the lines ? Atleast I would like to wait till Bitto answers something since compiling qt is time consuming!

As I already pointed out that performance is better without those nodes and textitems as children. Does that mean drawBackground() is being called twice for same area ? Does the framework lack any optimization in calculating this before hand ?

drawBackground() get called every time whenever your window painted, means when ever you move window or resize..

Quote:

---

Originally Posted by rajesh

drawBackground() get called every time whenever your window painted, means when ever you move window or resize..

---

No. That is just one of the case. drawBackground() is called always before updating the required item(eg when its moved) with the probably the item's bounding rect. You can check that by just printing something say qDebug() << rect; in the method.

Quote:

---

Originally Posted by Gopala Krishna

Also the grid look corrupted when items are moved. Any suggestion for that ?

---

In my experience floating point arithmetic is always a nice way to get unexpected results...

Have you tried using QLine instead of QLineF
(It might give you a little speedup too, since often integer calculations are faster than floating point calculations.)


Also, do you know which rounding functions the int cast uses?
Does it "round to nearest"? Does it do a "floor"? Does it do a "ceil"?
It might make a difference, so you might want to be explicit there.


Good luck :-)

Quote:

---

Originally Posted by camel

In my experience loating point arithmetic is always a nice way to get unexpected results (in my experience)...

Have you tried using QLine instead of QLineF
(It might give you a little speedup too, since often integer calculations are faster than floating point calculations.)


Also, do you know which rounding functions the int cast uses?
Does it "round to nearest"? Does it do a "floor"? Does it do a "ceil"?
It might make a difference, so you might want to be explicit there.


Good luck :-)

---

I think you are right. I will test with QLine since I don't need floating points for the grid. Thanks for pointing this. :)

I tested with QLine but that didn't make a difference. Also i am not sure what the int cast does - i feel it just takes int part without rounding. But do you think this will make a difference since I am following one convention in all places in drawBackground() ?

Quote:

---

Originally Posted by Gopala Krishna

I tested with QLine but that didn't make a difference. Also i am not sure what the int cast does - i feel it just takes int part without rounding. But do you think this will make a difference since I am following one convention in all places in drawBackground() ?

---

It does make a difference:

Code:

---

void drawBackground(QPainter *painter, const QRectF &rect)
      {
         const int gridSize = 25;
 
         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);
 
         QVarLengthArray<QLine, 100> lines;
 
         for (int x = firstLeftGridLine; x <= realRight; x += gridSize)
            lines.append(QLine(x, realTop, x, realBottom));
         for (int y = firstTopGridLine; y <= realBottom; y += gridSize)
            lines.append(QLine(realLeft, y, realRight, y));
 
 
         painter->setPen(QPen(Qt::darkGreen,0));
         painter->drawLines(lines.data(), lines.size());
      }

---

As you see I make three changes
a) integer instead of float
b) using the containing integer rect as basis (i.e. the smallest integer rect that contains the float rect)
c) I changed the "<" in your for loops to a "<=", i thing part of your corruption was that it did not always repaint the grid when the line was at the border of the exposed rect.


The result: no more corruption of the grid...only weird color changes that I am trying to track down ;-)


EDIT: Of course you now need:

Code:

---

#include <cmath>

---

for the floor, and ceil to work ;-)

Quote:

---

Originally Posted by camel

...
The result: no more corruption of the grid...only weird color changes that I am trying to track down ;-)
for the floor, and ceil to work ;-)

---

As you said no more corruption but yeah even I am cracking my head a lot on how to remove those weird color changes.
But I tell you I found one magic while experimenting. Try , its fun.

change the bounding rect of Resistor to

Code:

---

QRectF Resistor::boundingRect() const
{
     qreal pw = 0.5;
    return QRectF(-47,-9,47*2,18).adjusted(-pw,-pw,pw,pw);
}

---

Check for performance now!! :p

I really suggest to recompile Qt with profiling information. You're shooting blind now. Profiling will give you the exact bottleneck point. Furthermore make sure your app is compiled correctly, I think you should be able to have a decomposition of the drawBackground() method in the profiling information as well. It should then tell you which part of the method takes most time and it should be possible to obtain without recompiling Qt.

Hey,

I just changed your source a bit so that the boundingrects and shapes are only calculated once...

check if that helps with the performance a bit...

(since I cannot realy judge it here... :-)



I also found that the grid-color-problem is lessend (but not gone) when you fill the rect in the draw background,

And the error is gone completely when you turn off anti-aliasing.

Might be a Qt-Bug :-/


Anyways, my version of your code :-)

Code:

---

#include <QtGui>
#include <cmath>
 
class GridScene : public QGraphicsScene
{
   public:
      GridScene(qreal x, qreal y, qreal w, qreal h)
         : QGraphicsScene(x, y, w, h)
      { }
 
   protected:
      void drawBackground(QPainter *painter, const QRectF &rect)
      {
         const int gridSize = 25;
 
         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);
 
         QVarLengthArray<QLine, 100> lines;
 
         for (int x = firstLeftGridLine; x <= realRight; x += gridSize)
            lines.append(QLine(x, realTop, x, realBottom));
         for (int y = firstTopGridLine; y <= realBottom; y += gridSize)
            lines.append(QLine(realLeft, y, realRight, y));
 
//If you uncomment this, you will find the color problem lessened...
//why? well your guess is as good as mine ;-)
//         painter->fillRect(QRect(QPoint(realLeft, realTop), QPoint(realRight, realBottom)), QBrush(Qt::white));
 
         painter->setOpacity(1.0);
         painter->setPen(QPen(Qt::darkGreen,0));
         painter->drawLines(lines.data(), lines.size());
      }
};
 
namespace {
    static inline QPainterPath constructNodeShape(const QRect& elipseRect)
    {
        QPainterPath path;
        path.addEllipse(elipseRect);
        return path;
    }
}
 
class Node : public QGraphicsItem
{
   public:
      Node(QPointF pos ,QGraphicsItem *par = 0, QGraphicsScene *sc = 0)
          : QGraphicsItem(par,sc),
            elipseRect(-3, -3, 2*3, 2*3),
            elipseShape(constructNodeShape(elipseRect))
      {
         setPos(pos);
         setFlags(0);
         setAcceptedMouseButtons(0);
      }
 
      void paint(QPainter* p,const QStyleOptionGraphicsItem *, QWidget *)
      {
         p->setPen(Qt::darkRed);
         p->setBrush(Qt::NoBrush);
         p->setOpacity(1.0);
         p->drawEllipse(elipseRect);
      }
 
      QPainterPath shape() const
      {
         return elipseShape;
      }
 
      QRectF boundingRect() const
      {
         return elipseRect;
      }
 
    protected:
      const QRect elipseRect;
      const QPainterPath elipseShape;
};
 
class Resistor : public QGraphicsItem
{
   public:
      Resistor(QGraphicsItem *par = 0, QGraphicsScene *scene = 0)
          : QGraphicsItem(par,scene),
            resistorBox(-18, -9, 36, 18),
            connectors(new QLine[2])
      {
         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);
         new Node(QPointF(-30,0),this,scene);
         new Node(QPointF(30,0),this,scene);
 
        connectors[0] = QLine(-27, 0, -18, 0);
        connectors[1] = QLine(18, 0, 27, 0);
 
        boundingBox |= resistorBox;
        boundingBox |= QRectF(connectors[0].x1(), connectors[0].y1(), connectors[0].x2(), connectors[0].y2() );
        boundingBox |= QRectF(connectors[1].x1(), connectors[1].y1(), connectors[1].x2(), connectors[1].y2() );
        boundingBox.adjust(-0.5, -0.5, 0.5, 0.5);
      }
 
      ~Resistor()
      {
          delete[] connectors;
      }
 
      void paint(QPainter *p, const QStyleOptionGraphicsItem *o, QWidget *)
      {
         if(!(o->state & QStyle::State_Open))
            p->setPen(Qt::darkBlue);
         if(o->state & QStyle::State_Selected)
            p->setPen(QPen(Qt::darkGray,1));
 
         p->setBrush(Qt::NoBrush);
         p->drawRect(resistorBox);
         p->drawLines(connectors, 2);
      }
 
      QRectF boundingRect() const
      {
        return boundingBox;
      }
 
   private:
      QRect resistorBox;
      QLine* connectors;
      QRectF boundingBox;
};
 
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);
// Turn of antialiasing and the color problem is gone...
   view->setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
   view->setDragMode(QGraphicsView::RubberBandDrag);
   view->show();
   return app.exec();
}

---

Quote:

---

Originally Posted by wysota

I really suggest to recompile Qt with profiling information. You're shooting blind now. Profiling will give you the exact bottleneck point. Furthermore make sure your app is compiled correctly, I think you should be able to have a decomposition of the drawBackground() method in the profiling information as well. It should then tell you which part of the method takes most time and it should be possible to obtain without recompiling Qt.

---

ok finally I agree. You are right . I guess there is no decomposition because most method are inlined. Well I'll do that recompilation tomorrow(nice job in the weekend ;) )

First do this (or something simmilar):

Code:

---

void drawLines(QPainter *painter, QVarLengthArray<QLineF, 100> &lines){
         painter->drawLines(lines.data(), lines.size());
}
 
void setupArray(QVarLengthArray<QLineF, 100> &lines){
         const int gridSize = 25;
         qreal left = int(rect.left()) - (int(rect.left()) % gridSize);
         qreal top = int(rect.top()) - (int(rect.top()) % gridSize);
         for (qreal x = left; x < rect.right(); x += gridSize)
            lines.append(QLineF(x, rect.top(), x, rect.bottom()));
         for (qreal y = top; y < rect.bottom(); y += gridSize)
            lines.append(QLineF(rect.left(), y, rect.right(), y));
}
void drawBackground(QPainter *painter, const QRectF &rect){
         painter->setPen(QPen(Qt::darkGreen,0));         
         QVarLengthArray<QLineF, 100> lines;
         setupArray(lines);
         drawLines(painter, lines);
}

---

This should allow you to measure how much time does it take to setup the array and how much to paint it.

Quote:

---

Originally Posted by camel

Hey,

I just changed your source a bit so that the boundingrects and shapes are only calculated once...

check if that helps with the performance a bit...

(since I cannot realy judge it here... :-)



I also found that the grid-color-problem is lessend (but not gone) when you fill the rect in the draw background,

And the error is gone completely when you turn off anti-aliasing.

Might be a Qt-Bug :-/


Anyways, my version of your code :-)

Code:

---

#include <QtGui>
#include <cmath>
 
class GridScene : public QGraphicsScene
{
   public:
   ....

---

---

I am really thankful to your support. :)

Yeah you are right. The colouring is gone without antialiasing. But I also experimented with one more thing.
I did this in drawBackground() which didn't alter much

Code:

---

void GridScene::drawBackground(QPainter *p, const QRectF& rect) const
{
        QPainter::RenderHints rh = p->renderHints();
        p->setRenderHints(0);
      ...
       p->setRenderHints(rh);
}

---

Should be Qt bug I believe. :confused:

Calculating bounding rect beforehand did show improvement in performance. But I feel the main performance blow is in drawBackground(). Somehow I feel that drawBackground() is called more than required times which is causing all these. For example try with this

Code:

---

view->setCacheMode(QGraphicsView::CacheBackground);

---

The performance improves but the background corrupts when we scroll. Also as I pointed in my last but one post, increasing bounding rect of resistor so that it covers node also sigificantly improved performance. This suggests that the rects are not ORred properly before updating that region. ( I may be wrong, correct me if I am)
Well to exactly solve this we need to profile the code (with profiling enabled for qt lib) or use some intelligent techniques (which I am not aware of )

Well, I already did profile it globally and found something rather interesting.

There is no use, trying to draw anything via the qpainter->draw(Rect, Elipsis, Polygons) whatever in Graphics view, since it is going to be converted to a painterpath anyways.


That means, that for every paint, you create a new painterpath, which means that you need to allocate memory, which is slow.

Why a painterpath?
If you check the x11 paintengine, you see that as soon as antialiasing is enabled (or there is a certain amount of TxTranslate, whatever that means), drawing is done using the "path_fallback", which means primitives are first converted to paths before being drawn.
Why? No clue ;-)

But as a result that means, if you draw a lot of (rects, ellipses and polygons, lines...), use a painterpath instead. Preferably even one that you do not recalculate every time you are asked to draw something.. :-)


The source after this transition:

Code:

---

#include <QtGui>
#include <cmath>
 
class GridScene : public QGraphicsScene
{
   public:
      GridScene(qreal x, qreal y, qreal w, qreal h)
         : QGraphicsScene(x, y, w, h)
      { }
 
   protected:
      void drawBackground(QPainter *painter, const QRectF &rect)
      {
         const int gridSize = 25;
 
         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) {
             background.moveTo(x, realTop);
             background.lineTo(x, realBottom);
             background.closeSubpath();
         }
         for (int y = firstTopGridLine; y <= realBottom; y += gridSize) {
             background.moveTo(realLeft, y);
             background.lineTo(realRight, y);
             background.closeSubpath();
         }
 
//If you uncomment this, you will find the color problem lessened...
//why? well your guess is as good as mine ;-)
//         painter->fillRect(QRect(QPoint(realLeft, realTop), QPoint(realRight, realBottom)), QBrush(Qt::white));
 
         painter->setOpacity(1.0);
         painter->setPen(QPen(Qt::darkGreen,0));
         painter->drawPath(background);
      }
};
 
namespace {
    static inline QPainterPath constructNodeShape(const QRect& elipseRect)
    {
        QPainterPath path;
        path.addEllipse(elipseRect);
        return path;
    }
}
 
class Node : public QGraphicsItem
{
   public:
      Node(QPointF pos ,QGraphicsItem *par = 0, QGraphicsScene *sc = 0)
          : QGraphicsItem(par,sc),
            elipseRect(-3, -3, 2*3, 2*3),
            elipseShape(constructNodeShape(elipseRect))
      {
         setPos(pos);
         setFlags(0);
         setAcceptedMouseButtons(0);
      }
 
      void paint(QPainter* p,const QStyleOptionGraphicsItem *, QWidget *)
      {
         p->setPen(Qt::darkRed);
         p->setBrush(Qt::NoBrush);
         p->setOpacity(1.0);
 
         p->drawPath(elipseShape);
      }
 
      QPainterPath shape() const
      {
         return elipseShape;
      }
 
      QRectF boundingRect() const
      {
         return elipseRect;
      }
 
    protected:
      const QRect elipseRect;
      const QPainterPath elipseShape;
};
 
class Resistor : public QGraphicsItem
{
   public:
      Resistor(QGraphicsItem *par = 0, QGraphicsScene *scene = 0)
          : QGraphicsItem(par,scene)
      {
         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);
         new Node(QPointF(-30,0),this,scene);
         new Node(QPointF(30,0),this,scene);
 
 
        resistorPath.addRect(QRectF(-18.0, -9.0, 36.0, 18.0));
        resistorPath.moveTo(-27, 0);
        resistorPath.lineTo(-18, 0);
        resistorPath.closeSubpath();
        resistorPath.moveTo(18, 0);
        resistorPath.lineTo(27, 0);
        resistorPath.closeSubpath();
 
        boundingBox = resistorPath.boundingRect();
      }
 
      void paint(QPainter *p, const QStyleOptionGraphicsItem *o, QWidget *)
      {
         if(!(o->state & QStyle::State_Open))
            p->setPen(Qt::darkBlue);
         if(o->state & QStyle::State_Selected)
            p->setPen(QPen(Qt::darkGray,1));
 
         p->setBrush(Qt::NoBrush);
         p->drawPath(resistorPath);
      }
 
      QRectF boundingRect() const
      {
        return boundingBox;
      }
 
   private:
      QPainterPath resistorPath;
      QRectF boundingBox;
};
 
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);
// Turn of antialiasing and the color problem is gone...
   view->setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
   view->setDragMode(QGraphicsView::RubberBandDrag);
   view->show();
   return app.exec();
}

---

Quote:

---

Originally Posted by wysota

First do this (or something simmilar):

Code:

---

void drawLines(QPainter *painter, QVarLengthArray<QLineF, 100> &lines){
         painter->drawLines(lines.data(), lines.size());
}
 
void setupArray(QVarLengthArray<QLineF, 100> &lines){
         const int gridSize = 25;
         qreal left = int(rect.left()) - (int(rect.left()) % gridSize);
         qreal top = int(rect.top()) - (int(rect.top()) % gridSize);
         for (qreal x = left; x < rect.right(); x += gridSize)
            lines.append(QLineF(x, rect.top(), x, rect.bottom()));
         for (qreal y = top; y < rect.bottom(); y += gridSize)
            lines.append(QLineF(rect.left(), y, rect.right(), y));
}
void drawBackground(QPainter *painter, const QRectF &rect){
         painter->setPen(QPen(Qt::darkGreen,0));         
         QVarLengthArray<QLineF, 100> lines;
         setupArray(lines);
         drawLines(painter, lines);
}

---

This should allow you to measure how much time does it take to setup the array and how much to paint it.

---

Ok I did that, the profile now says

Quote:

---

Flat profile:

Each sample counts as 0.01 seconds.
% cumulative self self total
time seconds seconds calls Ts/call Ts/call name
50.05 0.02 0.02 Node:: paint(QPainter*, QStyleOptionGraphicsItem const*, QWidget*)
25.03 0.03 0.01 GridScene::drawBackground(QPainter*, QRectF const&)
25.03 0.04 0.01 Resistor::boundingRect() const
0.00 0.04 0.00 192004 0.00 0.00 QVarLengthArray<QLineF, 100>::realloc(int, int)
0.00 0.04 0.00 36506 0.00 0.00 GridScene::setupArray(QVarLengthArray<QLineF, 100>&, QRectF const&)
0.00 0.04 0.00 36506 0.00 0.00 GridScene::drawLines(QPainter*, QVarLengthArray<QLineF, 100>&)
0.00 0.04 0.00 1 0.00 0.00 global constructors keyed to _ZN9GridScene9drawLinesEP8QPainterR15QVarLengthArr ayI6QLineFLi100EE
0.00 0.04 0.00 1 0.00 0.00 __static_initialization_and_destruction_0(int, int)

---

Further

Quote:

---

Call graph (explanation follows)


granularity: each sample hit covers 2 byte(s) for 24.97% of 0.04 seconds

index % time self children called name
<spontaneous>
[1] 50.0 0.02 0.00 Node:: paint(QPainter*, QStyleOptionGraphicsItem const*, QWidget*) [1]
-----------------------------------------------
<spontaneous>
[2] 25.0 0.01 0.00 GridScene::drawBackground(QPainter*, QRectF const&) [2]
0.00 0.00 36506/36506 GridScene::setupArray(QVarLengthArray<QLineF, 100>&, QRectF const&) [12]
0.00 0.00 36506/36506 GridScene::drawLines(QPainter*, QVarLengthArray<QLineF, 100>&) [13]
-----------------------------------------------
<spontaneous>
[3] 25.0 0.01 0.00 Resistor::boundingRect() const [3]
-----------------------------------------------
0.00 0.00 192004/192004 GridScene::setupArray(QVarLengthArray<QLineF, 100>&, QRectF const&) [12]
[11] 0.0 0.00 0.00 192004 QVarLengthArray<QLineF, 100>::realloc(int, int) [11]
-----------------------------------------------
0.00 0.00 36506/36506 GridScene::drawBackground(QPainter*, QRectF const&) [2]
[12] 0.0 0.00 0.00 36506 GridScene::setupArray(QVarLengthArray<QLineF, 100>&, QRectF const&) [12]
0.00 0.00 192004/192004 QVarLengthArray<QLineF, 100>::realloc(int, int) [11]
-----------------------------------------------
0.00 0.00 36506/36506 GridScene::drawBackground(QPainter*, QRectF const&) [2]
[13] 0.0 0.00 0.00 36506 GridScene::drawLines(QPainter*, QVarLengthArray<QLineF, 100>&) [13]
-----------------------------------------------
0.00 0.00 1/1 __do_global_ctors_aux [25]
[14] 0.0 0.00 0.00 1 global constructors keyed to _ZN9GridScene9drawLinesEP8QPainterR15QVarLengthArr ayI6QLineFLi100EE [14]
0.00 0.00 1/1 __static_initialization_and_destruction_0(int, int) [15]
-----------------------------------------------
0.00 0.00 1/1 global constructors keyed to _ZN9GridScene9drawLinesEP8QPainterR15QVarLengthArr ayI6QLineFLi100EE [14]
[15] 0.0 0.00 0.00 1 __static_initialization_and_destruction_0(int, int) [15]
-----------------------------------------------

---