Slow plotting of spectrogram

[Anton1]

Hello, i am new in qwt.
My task is plotting data on the spectrogram that come by timer.
For this purpose, I used the example "realtime" in qwt.
At the moment, I'm drawing a spectrogram (data come every 50ms, size of frame 100 points) by adding a new area:
QRect newArea(QPoint( pointX * 100 , pointY ),QSize(100,1));
QRectF rect = QwtScaleMap::transform(
canvasMap( QwtPlot::xBottom),
canvasMap( QwtPlot::yLeft),
newArea );
canvas()->repaint(rect.toRect());
But there is a problem with the speed of data rendering on spectrogram. The schedule is not drawn with the necessary speed.
I do not draw on the full screen. Size of plot is 1000 points on x-axis by 500 on y-axis (but size can be 10000 points on x-axis by 5000 on y-axis).
When drawing on the full screen the speed of data rendering on spectrogram decreases even more.

How can I solve this problem?
May be <qwt_plot glcanvas.h> can help me?
I looked at the topic http://www.qtcentre.org/archive/index.php/t-25795.html. But I did not understand how to use the overload PlotSpectrogram :: renderImage.

Here is my code that is responsible for plotting:

1. incrementalplot.h:

#include <qwt_plot.h>

class QwtPlotSpectrogram;

class IncrementalPlot : public QwtPlot
{
Q_OBJECT

public:
IncrementalPlot( QWidget *parent = NULL );
virtual ~IncrementalPlot();
QwtPlotSpectrogram *d_curve;

void appendPoints( const double, const double );
};


2. incrementalplot.cpp:

#include "incrementalplot.h"
#include <qwt_plot.h>
#include <qwt_plot_canvas.h>
#include <qwt_raster_data.h>
#include <qwt_matrix_raster_data.h>
#include <qwt_plot_spectrogram.h>
#include <qwt_painter.h>
#include "color.h"

class CurveData: public QwtMatrixRasterData
{

public:
double *dataCscan;
int numberOfScansInCscan;
CurveData()
{
//size
numColumns = 1000;
numRaws = 500;
numColors = 100;
//counters
numberOfScansInCscan = 0;
//vector and matrix
QVector <double> values(numColumns*numRaws,0);
dataCscan = values.data();
setValueMatrix( values, numColumns );
//intervals
setInterval( Qt::XAxis,QwtInterval( 0, numColumns, QwtInterval::ExcludeMaximum ) );
setInterval( Qt::YAxis,QwtInterval( 0, numRaws, QwtInterval::ExcludeMaximum ) );
setInterval( Qt::ZAxis, QwtInterval( 0, numColors ) );
}
//size variables
int numColumns;
int numRaws;
int numColors;
//task matrix size
void setMatrixSize()
{
QVector <double> values(numColumns*numRaws,0);
dataCscan = values.data();
setValueMatrix( values, numColumns );
}

void clearNumber()
{
numberOfScansInCscan = 0;
}

public:
//set new data
void rasterDataUpdate()
{
if (numberOfScansInCscan == numColumns*numRaws) qDebug() << "limit exceeded";
else
{
for (int i = 0; i < 100; i++)
dataCscan [ i + numberOfScansInCscan ] = i;
numberOfScansInCscan += 100;
}
}
};

IncrementalPlot::IncrementalPlot( QWidget *parent ):
QwtPlot( parent ),
d_curve( NULL )
{
if ( QwtPainter::isX11GraphicsSystem() )
{
canvas()->setAttribute( Qt::WA_PaintOnScreen, true );
}
//set curve
d_curve = new QwtPlotSpectrogram();
d_curve->setData( new CurveData() );
//set colormap
Color *color = new Color();
d_curve->setColorMap(color);

d_curve->attach( this );

setAutoReplot( false );
}

IncrementalPlot::~IncrementalPlot()
{
delete d_curve;
}

//append new points on curve
void IncrementalPlot::appendPoints( const double pointX, const double pointY)
{
CurveData *data = static_cast<CurveData *>( d_curve->data());
data->rasterDataUpdate();
const bool doClip = !canvas()->testAttribute( Qt::WA_PaintUnclipped );
//repaint part of graph
if ( doClip )
{
QRect newArea(QPoint( pointX * 100 , pointY ),QSize(100,1));
QRectF rect = QwtScaleMap::transform(
canvasMap( QwtPlot::xBottom),
canvasMap( QwtPlot::yLeft),
newArea );
canvas()->repaint(rect.toRect());
}
}

3. plot.h

#include "incrementalplot.h"
#include <qdatetime.h>

class RandomPlot: public IncrementalPlot
{
Q_OBJECT

public:
RandomPlot( QWidget *parent );

virtual QSize sizeHint() const;

//counter and variables for coordinates
int count;
double x;
double y;

public Q_SLOTS:
void stop();
void resetCount();

private Q_SLOTS:
void appendPoint();
};

4. plot.cpp

#include "plot.h"
#include <qglobal.h>
#include <qwt_plot_grid.h>
#include <qwt_plot_canvas.h>
#include <qwt_plot_layout.h>
#include <qwt_scale_widget.h>
#include <qwt_scale_draw.h>
#include <qwt_plot_curve.h>
#include "qwt_symbol.h"

const unsigned int c_rangeMax = 1000;

RandomPlot::RandomPlot( QWidget *parent ):
IncrementalPlot( parent )
{
setFrameStyle( QFrame::NoFrame );
setLineWidth( 0 );

plotLayout()->setAlignCanvasToScales( true );

QwtPlotGrid *grid = new QwtPlotGrid;
grid->setMajorPen( Qt::gray, 0, Qt:otLine );
grid->attach( this );

setCanvasBackground( QColor( 29, 100, 141 ) );

setAxisScale( xBottom, 0, c_rangeMax );
setAxisScale( yLeft, 0, c_rangeMax/2 );

//set coordinates and count
count = 0; x = 0; y =0;

//canvas
QwtPlotCanvas *plotCanvas = qobject_cast<QwtPlotCanvas *>( canvas() );
plotCanvas->setPaintAttribute( QwtPlotCanvas::BackingStore, false );
replot();
}

QSize RandomPlot::sizeHint() const
{
return QSize( 540, 400 );
}

//set x and y position, append points on curve
void RandomPlot::appendPoint()
{
if ( count % 10 == 0)
{
y++;
x = 1;
}
else x++;
IncrementalPlot::appendPoints(x - 1, y - 1);
count++;
}

//do not use
void RandomPlot::stop()
{
QwtPlotCanvas *plotCanvas = qobject_cast<QwtPlotCanvas *>( canvas() );
plotCanvas->setPaintAttribute( QwtPlotCanvas::BackingStore, true );
}

//do not use
void RandomPlot::resetCount()
{
count = 0;
x = 0;
y = 0;
}

5. mainwindow.h

#include <qmainwindow.h>
#include <qaction.h>

class QPushButton;
class RandomPlot;

class MainWindow: public QMainWindow
{
Q_OBJECT
public:
MainWindow();
RandomPlot *d_plot;
// start button
QPushButton *button;
};

6.mainwindow.cpp

#include "plot.h"
#include "mainwindow.h"
#include <QPushButton>

MainWindow::MainWindow()
{
//start button
button = new QPushButton("Paint");
button->show();
//spectrogram
d_plot = new RandomPlot( this );
const int margin = 4;
d_plot->setContentsMargins( margin, margin, margin, margin );

setCentralWidget( d_plot );
}

7. main

#include "mainwindow.h"
#include <QApplication>
#include <QTimer>
#include <QPushButton>
#include "plot.h"

int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow *w = new MainWindow;
//w->resize(500,300);
QTimer *time = new QTimer;
time->setInterval(50);
QObject::connect(w->button, SIGNAL(clicked()), time, SLOT(start()));
QObject::connect(time, SIGNAL(timeout()), w->d_plot, SLOT(appendPoint()));
w->show();
return a.exec();
}

8. colormap

#include<qwt_color_map.h>
class Color: public QwtLinearColorMap
{
public:
Color(): QwtLinearColorMap(Qt::white, Qt::darkRed)
{
//set color
addColorStop(0.10,Qt::blue);
addColorStop(0.25,Qt::darkBlue);
addColorStop(0.40,Qt::green);
addColorStop(0.55,Qt::darkGreen);
addColorStop(0.70,Qt::yellow);
addColorStop(0.80,Qt::darkYellow);
addColorStop(0.90,Qt::red);
}
};

I apologize for such a big post.
Thank you for attention, Anton

[Uwe]

A spectrogram creates an image from your data, by iterating over all pixels of the image, requesting the value from the data object and mapping it to a RGB value using a QwtColorMap. When having an image of 1000x1000 pixels, this is a loop of 10e6 values. The time for blitting the image to screen is no relevant factor then - what answers your question regarding OpenGL as being no optimzation.

So it is about the number of pixels and of course what happens for each pixel. For reducing the number of pixels I see 2 options:

QwtPlotRasterData::pixelHint()
Incremental image composition

QwtPlotRasterData::pixelHint()
Incremental image composition

To copy to clipboard, switch view to plain text mode 

The pixelHint is useful, when the resolution of the data is below the resolution of the screen. In this case the spectrogram needs to calculate RGB values in data resolution only and can fill the other pixels.
When using QwtMatrixRasterData the pixelHint is automatically calculated from the rows/columns, but your code totally disables this optimization by blowing up the data to 1000x500 data pixels manually. As you wrote that you never have more than 100 points per line this alone slows down the image composition by factor 10.

In general I would throw away your code completely - and restart with a simple implementation without any optimization. Use only one spectrogram ( your code disables multi threading as a side effect ) and one QVector <double>, that you modify whenever data comes in. Then have a look what performance you have - maybe by enabling DEBUG_RENDER in qwt_plot_spectrogram.cpp.

Maybe compare your results with the debug output of the spectrogram example. The numbers of your application should be significantly better ( because of the raster hint ) - if not something is totally wrong in your code.

Then when starting with optimizing I recommend not to use QwtMatrixRasterData as you can avoid having to copy the incoming data by putting your own type of QwtPlotRasterData on top of your values. By the way: try to avoid iterating of the points, better use memcpy or methods of QVector based on memcpy.

I would expect, that with removing your "optimizations" you will already have a significant better performance. If this is still not good enough we can have a look at the incremental image composition.

Uwe

[Anton1]

Thank you for your quick response Uwe!
It helped me to solve the problem with the performance.

I have a question about displaying (plotting) data. Resolution of the data is much higher then the resolution of the screen.
Usually the date consists of a lot of low values (5 - 10) and rare single high values (90 - 100). When we display data on spectrogram we often do not see this peak (high value).

Is it possible to do not lose these single maximums on the spectrogram?

I am looking for an analouge for QwtPlotSpectrogram for method "setPoint Attribute (QwtPlotCurve :: FilterPoints, false)" that used for QwtPlotCurve to don't loose peaks?

[Uwe]

Is it possible to do not lose these single maximums on the spectrogram?

This is a problem of the nearest neighbor resampling. It is very fast, but of course might miss peaks.

QwtPlotMatrixData offers another resampling algo - interpolating between the samples - but it might be too expensive for your use case and you lose the pixel hint optimization. Guess you need to find your own strategy, but in any case you would have to overload:

virtual double QwtRasterData::value( double x, double y );

virtual double QwtRasterData::value( double x, double y );

To copy to clipboard, switch view to plain text mode 

But be careful: this method is called for each pixel of the image. Doing expensive operations here will slow down the image composition.

Uwe

[Anton1]

Hello!

After I changed the display to the one with higher resolution (1920 Ñ… 1080) the spectrogram slowed down.

So now I'd like to return to the approach you suggesed erlier "Incremental image composition". Do I understand it right that it is possible to plot only part of the spectrogram OR to add data to the spectrogram?

I looked at the topic "Incremental Spectrogram".
I do not understand how to properly reimplement method QwtPlotSpectrogram::renderImage.

For example, I have a spectrogram, filling from left to right by columns. I want to render only new part of the picture (Today for display I use overloading method QwtRasterData::value and replot all picture).
1. What triggers the method QwtPlotSpectrogram::renderImage? Repaint, replot etc.? Or do I need to call it myself?
2. How to set the return value in an overloaded method?
3. Do I need an analog for method QwtRasterData::value,that i used when call replot?
4. Can you provide a brief description of how to make incremental spectrogram data plotting?

Thank you in advance.

[Uwe]

The very first thing I recommend to do is - again - enable DEBUG_RENDER in qwt_plot_spectrogram.cpp and check the time needed for your image composition.
What type of values have been reported ( of course in release mode ) ?

Uwe

[Anton1]

I set enable DEBUG_RENDER in qwt_plot_spectrogram.cpp.
If the spectrogram takes nearly full screen, there is the following result - renderImage QSize(1818, 909) 179
If the spectrogram takes small part of screen, there is the following result - renderImage QSize(705, 80) 11
Initial screen resolution is 1920x1080. The data size exceeds the size of the spectrogram.
Can you say what should be done?
Thank you in advance.

[Uwe]

QSize(1818, 909) 179
QSize(705, 80) 11

With the spectrogram example I can see on my box ( i7-3770T CPU @ 2.50GHz with 4 cores ) values like:

• QSize(484, 343) 3
• QSize(1804, 1075) 27

As my system is far away from being a burner I guess we are talking about some slow embedded device on your side ?
To compare the systems: could you check the numbers of the spectrogram example on your box ?

--

Concerning the "Incremental image composition":

class YourSpectrogram: public QwtPlotSpectrogram
{
    ....
 
protected:
    virtual QImage renderImage(
        const QwtScaleMap &xMap, const QwtScaleMap &yMap,
        const QRectF &area, const QSize &imageSize ) const override
    {
        if ( m_image.isNull() )
        {
            m_image = QwtPlotSpectrogram::renderImage(
                xMap, yMap, area, imageSize );
        }
        else
        {
            // find the new area, not being part of the previous image
            // and the width/height in pixels
 
            subArea = ...;
            subImageSize = ...
 
            QImage subImage = QwtPlotSpectrogram::renderImage(
                xMap, yMap, subArea, subImageSize );
 
            // shift the pixels in m_image and copy in those from subImage
            m_image = ...
        }
 
        return m_image;
    }
 
private:
    QImage m_image;
};

class YourSpectrogram: public QwtPlotSpectrogram
{
    ....

protected:
    virtual QImage renderImage(
        const QwtScaleMap &xMap, const QwtScaleMap &yMap,
        const QRectF &area, const QSize &imageSize ) const override
    {
        if ( m_image.isNull() )
        {
            m_image = QwtPlotSpectrogram::renderImage(
                xMap, yMap, area, imageSize );
        }
        else
        {
            // find the new area, not being part of the previous image
            // and the width/height in pixels

            subArea = ...;
            subImageSize = ...

            QImage subImage = QwtPlotSpectrogram::renderImage(
                xMap, yMap, subArea, subImageSize );

            // shift the pixels in m_image and copy in those from subImage
            m_image = ...
        }

        return m_image;
    }

private:
    QImage m_image;
};

To copy to clipboard, switch view to plain text mode 

HTH,
Uwe

PS: if you have a good example for a waterfall plot that could be used as an example ( no huge data files ) you could send me your slow implementation. I would do the optimized implementation then.

[Anton1]

Hello Uwe!
In the spectrogram example I see values like: renderImage QSize(1745, 910) 36.
My computer have parameters i7-3770 CPU @ 3.40GHz with 4 cores.
I'm working on a model for a waterfall plot, I think that I can send it to you early next week.
Thank you in advance.

[Anton1]

Good day, Uwe.
I've done program that could be an example after some changes.
I give a link to the archive: https://cloud.mail.ru/public/LPcx/a7VbvrFGx
Now the program is running slowly, but I hope that it is possible to optimize.
Thank you in advance.

[Uwe]

Not sure what this tarball is supposed to be - looks like some downstripped version of your application, but without doing anything. To be honest I was interested in some simple data factory, that can be used for a waterfall plot - and this part is unfortunately missing.

But at least it shows the implementation of your SpectrogramData::value(), that explains why you have a worse image composition performance than the spectrogram example. Regardless of any further optimization I recommend to speed this one up. As it is called for every pixel it is worth to spend some time on writing it in a performant way.

Uwe