GraphicsView performance problems

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

[camel]

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

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

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

Then call

$valgrind --tool=callgrind ./YOUR_APP

this will produce a file called callgrind.out.PID_OF_PROCESS

then you can call

$kcachegrind callgrind.out.PID_OF_PROCESS

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

[Gopala Krishna]

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



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

Then call


this will produce a file called callgrind.out.PID_OF_PROCESS

then you can call


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

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

[wysota]

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

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

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

To copy to clipboard, switch view to plain text mode 

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

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

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

To copy to clipboard, switch view to plain text mode 

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

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

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

To copy to clipboard, switch view to plain text mode 

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

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

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

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

[camel]

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

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

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

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

To copy to clipboard, switch view to plain text mode 

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

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

[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

[Gopala Krishna]

Have you enabled antialiasing ?

view->setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);

view->setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);

To copy to clipboard, switch view to plain text mode 

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