GraphicsView performance problems

[Gopala Krishna]

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

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.

#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();
}

#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();
}

To copy to clipboard, switch view to plain text mode 

[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.

[Gopala Krishna]

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.

[wysota]

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!

[Gopala Krishna]

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.

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!

[Gopala Krishna]

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 ?

[rajesh]

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

[Gopala Krishna]

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.

[camel]

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 :-)

[Gopala Krishna]

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.

[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() ?

[camel]

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:

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());
      }

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());
      }

To copy to clipboard, switch view to plain text mode 

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:

#include <cmath>

#include <cmath>

To copy to clipboard, switch view to plain text mode 

for the floor, and ceil to work ;-)

[Gopala Krishna]

...
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

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

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

To copy to clipboard, switch view to plain text mode 

Check for performance now!!

[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.

[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 :-)

#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();
}

#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();
}

To copy to clipboard, switch view to plain text mode 

[Gopala Krishna]

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 )

[wysota]

First do this (or something simmilar):

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);
}

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);
}

To copy to clipboard, switch view to plain text mode 

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

[Gopala Krishna]

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 :-)

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

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

To copy to clipboard, switch view to plain text mode 

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

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

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

To copy to clipboard, switch view to plain text mode 

Should be Qt bug I believe.

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

view->setCacheMode(QGraphicsView::CacheBackground);

view->setCacheMode(QGraphicsView::CacheBackground);

To copy to clipboard, switch view to plain text mode 

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 )

[camel]

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:

#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();
}

#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();
}

To copy to clipboard, switch view to plain text mode 

[Gopala Krishna]

First do this (or something simmilar):

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);
}

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);
}

To copy to clipboard, switch view to plain text mode 

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

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

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]
-----------------------------------------------