GraphicsView performance problems

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

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

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

[camel]

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

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.
Or it could have been inlined, again not really helpfull :-/


Have you tried valgrind/callgrind and KCacheGrind as a profiler? It is rather nice :-)

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

[arjunasd]

Hi

I posted in the old thread too.

Did you find a solution to draw the grid efficiently? I am running into the same problem. Also, when I zoomIn or zoomOut, my grid spacing is irregular.

Kindly help me with suggestions.

Thanks
Arjun

[Gopala Krishna]

I solved my problem by a change in representation of grids. Now i use points with no brush and pen of 0 width to represent grids instead of lines. This has given me significant improvement. Also i switched from qt4.2 to qt4.3 , which gave me freedom to optimize the view more. Setting the view's update mode to smart mode remarkably improved the performance and i no longer need to optimize it anymore

As far as your problem is concerned can you give me some details of your application ? Some code or screenshots definitely help us understand your problem

[arjunasd]

Hi

I did the changes you suggested and the grid works fine now.

I have another problem though. I have basic shapes like circle, ellipse, rectangle etc in my view and they are drawn with a penwidth of 2. When I zoomin, the rectangle is fine but the curves of circle and ellipse appear discontinuous.

I know zooming will decrease the quality. But is there any way to overcome this and make the circle continuous.

Thanks
Arjun

[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 

[camel]

Well...[CUT BECAUSE SOMETHING WEIRD IS GOING ON...it seems to be as if drawing the lines one by one is faster...but somehow that is rather unbelievable on second thought]...


Another method of getting rid of spurious mallocs is to reuse Pens and Brushes...

I guess i will not repost all of the code for these little changes...



Does anyone has access to a profiler on windows/mac? I would like to know if those changes that were good for linux (ellipses, rect -> painterpath) lines drawn one by one, is also good for these palatforms ;-)

[Gopala Krishna]

Well, after some more testing I found out that it is cheaper (in the drawBackground) method to draw the lines one by one, than to regenerate a new painterpath everytime.

Another method of getting rid of spurious mallocs is to reuse Pens and Brushes...

I guess i will not repost all of the code for these little changes...



Does anyone has access to a profiler on windows/mac? I would like to know if those changes that were good for linux (ellipses, rect -> painterpath) lines drawn one by one, is also good for these palatforms ;-)

Yeah exactly I too would like to know opinion on windows especially. Did anyone notice performance difference between windows and linux when you select and move all items ?

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

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 )