Improve performance for realtime moving marker?

[StefanK]

Hello,

I have a plot (see attachment) which shows data over timeline. I use a panner and magnifier for user interaction. In addition I have a realtime 'player' (timer) which updates a time marker walking over the plot. The marker is updated every 100ms. Actually a QwtPlotMarker is used. As we need to replot() every time when the position of the marker changes, the application becomes slow, depending on the number of plot curves and the timer interval. The number of plot curves is generically variable and can be more than 10.

Is there any idea how to get the same view with better performance?

Best Regards
Stefan

[Uwe]

a) One possible solution is to introduce a pixmap cache for all plot items with a smaller z value than the marker. This can be done by overloading QwtPlot::drawItems. When you also overload QwtPlotItem::itemChanged() for all items that should be cached, you can invalidate your cache easily. ( I guess then it is better to disable the builtin cache of the canvas. )

b) Another solution is to implement an overlay widget ( like the rubberband in the picker ).

Uwe

[StefanK]

Hello again

I'm still trying to solve that problem. There is one big issue which I don't know how to solve . The methods to overwrite are all const!

In my PlotCurve class I do:

void PlotCurve::itemChanged(void)
{
   QwtPlotCurve::itemChanged();
   if(plot())
   {
      ((Plot*)plot())->invalidateCache();
   }
}

void PlotCurve::itemChanged(void)
{
   QwtPlotCurve::itemChanged();
   if(plot())
   {
      ((Plot*)plot())->invalidateCache();
   }
}

To copy to clipboard, switch view to plain text mode 

In my Plot class I would like to do:

void Plot::invalidateCache(void)
{
    mPixmapCache = new QPixmap();
}
 
void Plot::drawItems(QPainter *pPainter, const QRect &pRect, const QwtScaleMap pMap[QwtPlot::axisCnt], const QwtPlotPrintFilter &pFilter) const
{
   QwtPlotItemList lAlwaysDrawnItems;
   bool lCacheValid = !mPixmapCache->isNull();
   if(!lCacheValid)
   {
      // Error here: assignment of data-member `Plot::mPixmapCache' in read-only structure
      mPixmapCache = new QPixmap(pRect.size());
   }
   QPainter lCachePainter(mPixmapCache);
 
   const QwtPlotItemList& lItemList = itemList(); 
   for (QwtPlotItemIterator lItemIter = lItemList.begin(); lItemIter != lItemList.end(); ++lItemIter)
   {
      QwtPlotItem *lItem = *lItemIter;
      if (lItem && lItem->isVisible() )
      {
         if ( !(pFilter.options() & QwtPlotPrintFilter::PrintGrid) && lItem->rtti() == QwtPlotItem::Rtti_PlotGrid)
         {
            continue;
         }
         // render items below z-index 1000 when cache is empty only
         if(lItem->z() < 1000)
         {
            if(!lCacheValid)
            {
               lCachePainter.save();
               lCachePainter.setRenderHint(QPainter::Antialiasing, lItem->testRenderHint(QwtPlotItem::RenderAntialiased));
               lItem->draw(&lCachePainter, pMap[lItem->xAxis()], pMap[lItem->yAxis()], pRect);
               lCachePainter.restore();           
            }
         }
         else
         {
            lAlwaysDrawnItems.append(lItem);
         }
      }
   }
 
   pPainter->drawPixmap(contentsRect().topLeft(), *mPixmapCache);
 
   for (QwtPlotItemIterator lItemIter = lAlwaysDrawnItems.begin(); lItemIter != lAlwaysDrawnItems.end(); ++lItemIter)
   {
      QwtPlotItem *lItem = *lItemIter;
      pPainter->save();
      pPainter->setRenderHint(QPainter::Antialiasing, lItem->testRenderHint(QwtPlotItem::RenderAntialiased));
      lItem->draw(pPainter, pMap[lItem->xAxis()], pMap[lItem->yAxis()], pRect);
      pPainter->restore();      
   }
}

void Plot::invalidateCache(void)
{
    mPixmapCache = new QPixmap();
}

void Plot::drawItems(QPainter *pPainter, const QRect &pRect, const QwtScaleMap pMap[QwtPlot::axisCnt], const QwtPlotPrintFilter &pFilter) const
{
   QwtPlotItemList lAlwaysDrawnItems;
   bool lCacheValid = !mPixmapCache->isNull();
   if(!lCacheValid)
   {
      // Error here: assignment of data-member `Plot::mPixmapCache' in read-only structure
      mPixmapCache = new QPixmap(pRect.size());
   }
   QPainter lCachePainter(mPixmapCache);
   
   const QwtPlotItemList& lItemList = itemList(); 
   for (QwtPlotItemIterator lItemIter = lItemList.begin(); lItemIter != lItemList.end(); ++lItemIter)
   {
      QwtPlotItem *lItem = *lItemIter;
      if (lItem && lItem->isVisible() )
      {
         if ( !(pFilter.options() & QwtPlotPrintFilter::PrintGrid) && lItem->rtti() == QwtPlotItem::Rtti_PlotGrid)
         {
            continue;
         }
         // render items below z-index 1000 when cache is empty only
         if(lItem->z() < 1000)
         {
            if(!lCacheValid)
            {
               lCachePainter.save();
               lCachePainter.setRenderHint(QPainter::Antialiasing, lItem->testRenderHint(QwtPlotItem::RenderAntialiased));
               lItem->draw(&lCachePainter, pMap[lItem->xAxis()], pMap[lItem->yAxis()], pRect);
               lCachePainter.restore();           
            }
         }
         else
         {
            lAlwaysDrawnItems.append(lItem);
         }
      }
   }
   
   pPainter->drawPixmap(contentsRect().topLeft(), *mPixmapCache);

   for (QwtPlotItemIterator lItemIter = lAlwaysDrawnItems.begin(); lItemIter != lAlwaysDrawnItems.end(); ++lItemIter)
   {
      QwtPlotItem *lItem = *lItemIter;
      pPainter->save();
      pPainter->setRenderHint(QPainter::Antialiasing, lItem->testRenderHint(QwtPlotItem::RenderAntialiased));
      lItem->draw(pPainter, pMap[lItem->xAxis()], pMap[lItem->yAxis()], pRect);
      pPainter->restore();      
   }
}

To copy to clipboard, switch view to plain text mode 

What can I do to get rid of the "assignment of data-member `Plot::mPixmapCache' in read-only structure" error?

Best Regards
Stefan

[StefanK]

A possible solution seems to be to make the drawItems method with the user code non const and to call it from another overriding const drawItems method after a brute force const_cast of the this pointer.

void Plot::drawItems(QPainter *pPainter, const QRect &pRect, const QwtScaleMap pMap[QwtPlot::axisCnt], const QwtPlotPrintFilter &pFilter) const
{
   Plot* lAccessiblePlot = const_cast<Plot*>(this);
   lAccessiblePlot->drawItems(pPainter,pRect,pMap,pFilter);
}
 
void Plot::drawItems(QPainter *pPainter, const QRect &pRect, const QwtScaleMap pMap[QwtPlot::axisCnt], const QwtPlotPrintFilter &pFilter)
{
   // the user implementation of drawItems
}

void Plot::drawItems(QPainter *pPainter, const QRect &pRect, const QwtScaleMap pMap[QwtPlot::axisCnt], const QwtPlotPrintFilter &pFilter) const
{
   Plot* lAccessiblePlot = const_cast<Plot*>(this);
   lAccessiblePlot->drawItems(pPainter,pRect,pMap,pFilter);
}

void Plot::drawItems(QPainter *pPainter, const QRect &pRect, const QwtScaleMap pMap[QwtPlot::axisCnt], const QwtPlotPrintFilter &pFilter)
{
   // the user implementation of drawItems
}

To copy to clipboard, switch view to plain text mode 

[StefanK]

Hello again,

Still one question. I get the debug output from Qt: "QWidget::repaint: Recursive repaint detected" "QPainter::begin: A paint device can only be painted by one painter at a time."

I adapted the code as follows. The message is emited when calling grabWidget() to save the content to the cache. Any idea why and how to correct?

void Plot::drawItems(QPainter *pPainter, const QRect &pRect, const QwtScaleMap pMap[QwtPlot::axisCnt], const QwtPlotPrintFilter &pFilter)
{
   QwtPlotItemList lAlwaysDrawnItems;
   // null pixmap means cache not valid
   bool lCacheValid = !mPixmapCache->isNull();
 
   const QwtPlotItemList& lItemList = itemList(); 
   for (QwtPlotItemIterator lItemIter = lItemList.begin(); lItemIter != lItemList.end(); ++lItemIter)
   {
      QwtPlotItem *lItem = *lItemIter;
      if (lItem && lItem->isVisible() )
      {
         if ( !(pFilter.options() & QwtPlotPrintFilter::PrintGrid) && lItem->rtti() == QwtPlotItem::Rtti_PlotGrid)
         {
            continue;
         }
         // render items below z-index 1000
         // when cache is invalid only
         if(lItem->z() < 1000)
         {
            if(!lCacheValid)
            {
               pPainter->save();
               pPainter->setRenderHint(QPainter::Antialiasing, lItem->testRenderHint(QwtPlotItem::RenderAntialiased));
               lItem->draw(pPainter, pMap[lItem->xAxis()], pMap[lItem->yAxis()], pRect);
               pPainter->restore();           
            }
         }
         else
         {
            // all items above z-index 1000 are added to a list in order to draw after cache content
            lAlwaysDrawnItems.append(lItem);
         }
      }
   }
 
   if(lCacheValid)
   {
      // if cache has been valid then paint from pixmap cache
      pPainter->drawPixmap(pRect, *mPixmapCache);
   }
   else
   {
      // create new pixmap when cache not valid
      mPixmapCache = new QPixmap(pRect.size());
      // else make a snapshot from the plot canvas curves
      *mPixmapCache = QPixmap::grabWidget(canvas(), pRect);      
   }
 
   // finally draw the rest to be rendered each time (z-index > 1000)
   for (QwtPlotItemIterator lItemIter = lAlwaysDrawnItems.begin(); lItemIter != lAlwaysDrawnItems.end(); ++lItemIter)
   {
      QwtPlotItem *lItem = *lItemIter;
      pPainter->save();
      pPainter->setRenderHint(QPainter::Antialiasing, lItem->testRenderHint(QwtPlotItem::RenderAntialiased));
      lItem->draw(pPainter, pMap[lItem->xAxis()], pMap[lItem->yAxis()], pRect);
      pPainter->restore();      
   }
}

void Plot::drawItems(QPainter *pPainter, const QRect &pRect, const QwtScaleMap pMap[QwtPlot::axisCnt], const QwtPlotPrintFilter &pFilter)
{
   QwtPlotItemList lAlwaysDrawnItems;
   // null pixmap means cache not valid
   bool lCacheValid = !mPixmapCache->isNull();

   const QwtPlotItemList& lItemList = itemList(); 
   for (QwtPlotItemIterator lItemIter = lItemList.begin(); lItemIter != lItemList.end(); ++lItemIter)
   {
      QwtPlotItem *lItem = *lItemIter;
      if (lItem && lItem->isVisible() )
      {
         if ( !(pFilter.options() & QwtPlotPrintFilter::PrintGrid) && lItem->rtti() == QwtPlotItem::Rtti_PlotGrid)
         {
            continue;
         }
         // render items below z-index 1000
         // when cache is invalid only
         if(lItem->z() < 1000)
         {
            if(!lCacheValid)
            {
               pPainter->save();
               pPainter->setRenderHint(QPainter::Antialiasing, lItem->testRenderHint(QwtPlotItem::RenderAntialiased));
               lItem->draw(pPainter, pMap[lItem->xAxis()], pMap[lItem->yAxis()], pRect);
               pPainter->restore();           
            }
         }
         else
         {
            // all items above z-index 1000 are added to a list in order to draw after cache content
            lAlwaysDrawnItems.append(lItem);
         }
      }
   }
   
   if(lCacheValid)
   {
      // if cache has been valid then paint from pixmap cache
      pPainter->drawPixmap(pRect, *mPixmapCache);
   }
   else
   {
      // create new pixmap when cache not valid
      mPixmapCache = new QPixmap(pRect.size());
      // else make a snapshot from the plot canvas curves
      *mPixmapCache = QPixmap::grabWidget(canvas(), pRect);      
   }

   // finally draw the rest to be rendered each time (z-index > 1000)
   for (QwtPlotItemIterator lItemIter = lAlwaysDrawnItems.begin(); lItemIter != lAlwaysDrawnItems.end(); ++lItemIter)
   {
      QwtPlotItem *lItem = *lItemIter;
      pPainter->save();
      pPainter->setRenderHint(QPainter::Antialiasing, lItem->testRenderHint(QwtPlotItem::RenderAntialiased));
      lItem->draw(pPainter, pMap[lItem->xAxis()], pMap[lItem->yAxis()], pRect);
      pPainter->restore();      
   }
}

To copy to clipboard, switch view to plain text mode 

Any suggestion for improvement appreciated.

Best Regards
Stefan

[Uwe]

a) grabWidget triggers a repaint of the widget with a redirected QPainter. This will never work when you call it in QPaintEvent.

b) Better paint your cached items to a image/pixmap with a transparent background. This can be painted later easily between background and your marker.

c) Maybe QwtPlotCanvas::paintCache is of use. Look how it is implemented in Qwt. It could help to find out how you can setup your own cache.

d) To avoid constness problems with your pixmap cache declare it as "mutable". ( See in your C++ reference if you never heard of it ).

Uwe

[StefanK]

Thank you Uwe!

d) I found it (Stroustrup, page 223)

As work arround I get the pixmap now from the canvas cache. That works fine and I get a lot faster plot. May be there are better ways as you suggested in d) as we could disable the canvas cache. I will check that later.

void Plot::drawItems(QPainter *pPainter, const QRect &pRect, const QwtScaleMap pMap[QwtPlot::axisCnt], const QwtPlotPrintFilter &pFilter) const
{
   QwtPlotItemList lAlwaysDrawnItems;
   // null pixmap means cache not valid
   bool lCacheValid = !mPixmapCache->isNull();
 
   const QwtPlotItemList& lItemList = itemList(); 
   for (QwtPlotItemIterator lItemIter = lItemList.begin(); lItemIter != lItemList.end(); ++lItemIter)
   {
      QwtPlotItem *lItem = *lItemIter;
      if (lItem && lItem->isVisible() )
      {
         if ( !(pFilter.options() & QwtPlotPrintFilter::PrintGrid) && lItem->rtti() == QwtPlotItem::Rtti_PlotGrid)
         {
            continue;
         }
         // render items below z-index 1000
         // when cache is invalid only
         if(lItem->z() < 1000)
         {
            if(!lCacheValid)
            {
               pPainter->save();
               pPainter->setRenderHint(QPainter::Antialiasing, lItem->testRenderHint(QwtPlotItem::RenderAntialiased));
               lItem->draw(pPainter, pMap[lItem->xAxis()], pMap[lItem->yAxis()], pRect);
               pPainter->restore();           
            }
         }
         else
         {
            // all items above z-index 1000 are added to a list in order to draw after cache content
            lAlwaysDrawnItems.append(lItem);
         }
      }
   }
 
   if(lCacheValid)
   {
      // if cache has been valid then paint from pixmap cache
      pPainter->drawPixmap(pRect.topLeft(), *mPixmapCache);
   }
   else
   {
      mPixmapCache = new QPixmap(*canvas()->paintCache());
   }
 
   // finally draw the rest to be rendered each time (z-index > 1000)
   for (QwtPlotItemIterator lItemIter = lAlwaysDrawnItems.begin(); lItemIter != lAlwaysDrawnItems.end(); ++lItemIter)
   {
      QwtPlotItem *lItem = *lItemIter;
      pPainter->save();
      pPainter->setRenderHint(QPainter::Antialiasing, lItem->testRenderHint(QwtPlotItem::RenderAntialiased));
      lItem->draw(pPainter, pMap[lItem->xAxis()], pMap[lItem->yAxis()], pRect);
      pPainter->restore();      
   }
}

void Plot::drawItems(QPainter *pPainter, const QRect &pRect, const QwtScaleMap pMap[QwtPlot::axisCnt], const QwtPlotPrintFilter &pFilter) const
{
   QwtPlotItemList lAlwaysDrawnItems;
   // null pixmap means cache not valid
   bool lCacheValid = !mPixmapCache->isNull();
  
   const QwtPlotItemList& lItemList = itemList(); 
   for (QwtPlotItemIterator lItemIter = lItemList.begin(); lItemIter != lItemList.end(); ++lItemIter)
   {
      QwtPlotItem *lItem = *lItemIter;
      if (lItem && lItem->isVisible() )
      {
         if ( !(pFilter.options() & QwtPlotPrintFilter::PrintGrid) && lItem->rtti() == QwtPlotItem::Rtti_PlotGrid)
         {
            continue;
         }
         // render items below z-index 1000
         // when cache is invalid only
         if(lItem->z() < 1000)
         {
            if(!lCacheValid)
            {
               pPainter->save();
               pPainter->setRenderHint(QPainter::Antialiasing, lItem->testRenderHint(QwtPlotItem::RenderAntialiased));
               lItem->draw(pPainter, pMap[lItem->xAxis()], pMap[lItem->yAxis()], pRect);
               pPainter->restore();           
            }
         }
         else
         {
            // all items above z-index 1000 are added to a list in order to draw after cache content
            lAlwaysDrawnItems.append(lItem);
         }
      }
   }
   
   if(lCacheValid)
   {
      // if cache has been valid then paint from pixmap cache
      pPainter->drawPixmap(pRect.topLeft(), *mPixmapCache);
   }
   else
   {
      mPixmapCache = new QPixmap(*canvas()->paintCache());
   }
   
   // finally draw the rest to be rendered each time (z-index > 1000)
   for (QwtPlotItemIterator lItemIter = lAlwaysDrawnItems.begin(); lItemIter != lAlwaysDrawnItems.end(); ++lItemIter)
   {
      QwtPlotItem *lItem = *lItemIter;
      pPainter->save();
      pPainter->setRenderHint(QPainter::Antialiasing, lItem->testRenderHint(QwtPlotItem::RenderAntialiased));
      lItem->draw(pPainter, pMap[lItem->xAxis()], pMap[lItem->yAxis()], pRect);
      pPainter->restore();      
   }
}

To copy to clipboard, switch view to plain text mode 

Best Regards
Stefan