Real time plot doubts

Hello, I'm new in this site, and I am not an expert programmer so, any help will be great for me ;)

I am creating a GUI, where in one graph, 6 signals are plotted, and in another graph, 6 other signals. Attachment 12371

So these signals come from a serial port, and I need to graph them in real time and send them in real time.
For now, I worry about the plotting part

What I thought at first, was replot every time a new sample arrived, but I think this would be inefficient and I do not know if having 12 signals with approximately 2500 samples each, finish making the program slow.

I was reading here, and found similar questions, I read the oscilloscope and real_time examples, but some parts do not become very clear to me.

Probably you are already tired of responding to them, but I really still have doubts.

I understand that:

- I need to use a QVector for append new sample.
- I need to set this samples to a QwtPlotCurve.
- I need to use QwtPlotDirectPainter::drawSeries for draw only the las sample.

Also need to use a QRect, but I dont understand well how this work.

In the real_time example, I think the most important art is at incrementalplot.cpp rigth?

but in the MainWindow.cpp file, never create and object of this class, only a randomplot object. I see that randomplot use the incrementalplot class and the method appendPoint (I think this is what I need), but I do not see the order in which the instructions are executed.

In the oscilloscope example, something similar is used at plot.cpp specifically Plot::updateCurve().

this, use a CurveData, that use a signaldata for append samples i think. (I think use a QVector for this rigth?).
and after, the same of real_time: QwtScaleMap, QRect and QwtPlotDirectPainter::drawSeries. but this differs in that it verifies if it can write in the array before doing it, and if it is not possible, it saves in a buffer. Is this correct? I was never use QReadWriteLock so i dont know how it work.

I have the same doubts as in the other example, I do not see the order in which the instructions are executed.

But the principal question is how can I use the QwtPlotDirectPainter::drawSeries, why need to use a canvasMap and how use the QRect. :(

Maybe are so many questions and maybe are trivials but, for me is a little difficult to understand.

Any help will be greatly appreciated! :D

I try with little examples using a qwtplot and 1 button, When I press the button, a new sample should be added:

Code:

---

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    i=0; c = 0;
    ya = false;
    graf = new QwtPlotCurve("");
    graf->attach(ui->qwtPlot);
    d_directPainter = new QwtPlotDirectPainter();
 
}
 
void MainWindow::on_pushButton_clicked()
{
    QPointF point = QPointF(c++,i);
    dat.append(point);
    graf->setSamples(dat);
 
    xMap = ui->qwtPlot->canvasMap( graf->xAxis() );
    yMap = ui->qwtPlot->canvasMap( graf->yAxis() );
 
    const QPointF center =
    QwtScaleMap::transform( xMap, yMap, point );
    r.moveCenter( center.toPoint() );
    clipRect += r;
 
    d_directPainter->setClipRegion( clipRect );
 
    d_directPainter->drawSeries( graf, dat.size() - 2, dat.size() - 1 );
 
    if(!ya) {i++; if(i==10)ya=true;}
    else {i--; if(i==0)ya=false;}
}

---

but this dont work. and try also:

Code:

---

void MainWindow::on_pushButton_clicked()
{
    QPointF point = QPointF(c++,i);
    dat.append(point);
    graf->setSamples(dat);
 
    xMap = ui->qwtPlot->canvasMap( graf->xAxis() );
    yMap = ui->qwtPlot->canvasMap( graf->yAxis() );
 
    const QSize symbolSize = graf->symbol()->size();
    QRect r( 0, 0, symbolSize.width() + 2, symbolSize.height() + 2 );
 
    clipRect = QwtScaleMap::transform( xMap, yMap, br ).toRect();
    d_directPainter->setClipRegion( clipRect );
 
    d_directPainter->drawSeries( graf, dat.size() - 2, dat.size() - 1 );
 
    if(!ya) {i++; if(i==10)ya=true;}
    else {i--; if(i==0)ya=false;}
}

---

But doesn't work either.

Only with replot work for me :(

Code:

---

QPointF point = QPointF(c++,i);
    dat.append(point);
    graf->setSamples(dat);
 
    datos << QPointF(c++,i);
    graf->setSamples(datos);
    if(!ya) {i++; if(i==10)ya=true;}
    else {i--; if(i==0)ya=false;}
 
    ui->qwtPlot->replot();

---

Thanks in advance, I hope someone can help me

Here an image of how my interface is going, any comments or suggestions are also welcome

Attachment 12372

Hello, im working in the code, and now I finally can plot in "real time" without reploting every time a sample arrive.

I used the classes plot, curvedata and signaldata of the "Oscilloscope" example.

The first time, I use the classes without reimplement nothing. This work fine in my "mini example", every time I had clicked the button, the graphic is plotting the sample =D.

But this have one problem, create another plot over my original plot and even over the button: Attachment 12393

After resize a little for be able to click the button this is the result: Attachment 12392

So, you can see, the plot is over all and without layout.

I want to use a QwtPlot that already exist, so I change a little the constructor of Plot:

Code:

---

Plot::Plot( QwtPlot *parent ):
 //   QwtPlot( parent ),
    d_paintedPoints( 0 ),
    d_interval( 0.0, 100000.0 ),
    d_timerId( -1 )
{
    d_directPainter = new QwtPlotDirectPainter();
 
    parent->setAutoReplot( false );
    parent->setCanvas( new Canvas() );
 
    plotLayout()->setAlignCanvasToScales( true );
 
    parent->setAxisTitle( QwtPlot::xBottom, "Time [s]" );
    parent->setAxisScale( QwtPlot::xBottom, d_interval.minValue(), d_interval.maxValue() );
    parent->setAxisScale( QwtPlot::yLeft, 0.0, 2000.0 );
 
    QwtPlotGrid *grid = new QwtPlotGrid();
    grid->setPen( Qt::gray, 0.0, Qt::DotLine );
    grid->enableX( true );
    grid->enableXMin( true );
    grid->enableY( true );
    grid->enableYMin( false );
    grid->attach( parent );
 
    d_origin = new QwtPlotMarker();
    d_origin->setLineStyle( QwtPlotMarker::Cross );
    d_origin->setValue( d_interval.minValue() + d_interval.width() / 2.0, 0.0 );
    d_origin->setLinePen( Qt::gray, 0.0, Qt::DashLine );
    d_origin->attach( parent );
 
    d_curve = new QwtPlotCurve();
    d_curve->setStyle( QwtPlotCurve::Lines );
    d_curve->setPen( canvas()->palette().color( QPalette::WindowText ) );
    d_curve->setRenderHint( QwtPlotItem::RenderAntialiased, true );
    d_curve->setPaintAttribute( QwtPlotCurve::ClipPolygons, false );
    d_curve->setData( new CurveData() );
    d_curve->attach( parent );
}

---

And I have this result: Attachment 12394

But this have a problem, when I press the button the graphic dont plot nothing. First I was think this dont work, but after resize the window, the samples appear.

So, the data only appear when I resize the window: Attachment 12395

If anyone can help me with this I will appreciate it very much :D

I know maybe are stupid questions but Im not and expert programmer and some things are diffucult to understand for me.

This is the MainWindow.cpp

Code:

---

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    i=0; c = 0;
    d_plot = new Plot( ui->qwtPlot );
//    d_plot->setIntervalLength( 100000 );
 
}

---

And this is the click event:

Code:

---

void MainWindow::on_pushButton_clicked()
{
 
for(i=0;i<2000;i++){
    SignalData::instance().append( QPointF(c++,i) );
    d_plot->updateCurve();
}
 
}

---

Thank you again =)

Regards

Hello, I finally could solve the problem :D

I reimplemented the Plot class and now, it is no longer a class derived from QwtPlot.

Now I will show you the files in case in the future someone is presented with the same doubt as me:

Plot.h

Code:

---

class Plot
{
 
public:
    Plot(QwtPlot * = NULL );
    ~Plot();
 
    void replot();
 
    void updateCurve();
 
    void setXinterval( double min, double max );
 
    void setYinterval( double min, double max );
 
    void setPen(const QColor &color, qreal width=0.0, Qt::PenStyle style = Qt::SolidLine);
 
 
private:
 
 
    QwtPlot *plot;
 
    QwtPlotCurve *d_curve;
    int d_paintedPoints;
 
    QwtPlotDirectPainter *d_directPainter;
 
    QwtInterval x_interval;
    QwtInterval y_interval;
 
};

---

Plot.cpp

Code:

---

#include "plot.h"
#include "curvedata.h"
#include "signaldata.h"
#include <qwt_plot_canvas.h>
#include <qwt_plot_marker.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_directpainter.h>
#include <qwt_curve_fitter.h>
#include <qwt_painter.h>
 
class Canvas: public QwtPlotCanvas
{
public:
    Canvas( QwtPlot *plot = NULL ):
        QwtPlotCanvas( plot )
    {
        // The backing store is important, when working with widget
        // overlays ( f.e rubberbands for zooming ).
        // Here we don't have them and the internal
        // backing store of QWidget is good enough.
 
        setPaintAttribute( QwtPlotCanvas::BackingStore, false );
        setBorderRadius( 10 );
 
        if ( QwtPainter::isX11GraphicsSystem() )
        {
#if QT_VERSION < 0x050000
            // Even if not liked by the Qt development, Qt::WA_PaintOutsidePaintEvent
            // works on X11. This has a nice effect on the performance.
 
            setAttribute( Qt::WA_PaintOutsidePaintEvent, true );
#endif
 
            // Disabling the backing store of Qt improves the performance
            // for the direct painter even more, but the canvas becomes
            // a native window of the window system, receiving paint events
            // for resize and expose operations. Those might be expensive
            // when there are many points and the backing store of
            // the canvas is disabled. So in this application
            // we better don't disable both backing stores.
 
            if ( testPaintAttribute( QwtPlotCanvas::BackingStore ) )
            {
                setAttribute( Qt::WA_PaintOnScreen, true );
                setAttribute( Qt::WA_NoSystemBackground, true );
            }
        }
 
    }
 
};
 
Plot::Plot( QwtPlot *parent ):
    plot( parent ),
    d_paintedPoints( 0 ),
    x_interval( 0.0, 100000.0 ),
    y_interval( 0.0, 2000.0 )
{
    d_directPainter = new QwtPlotDirectPainter();
 
    plot->setAutoReplot( false );
    plot->setCanvas( new Canvas() );
 
    plot->setAxisScale( QwtPlot::xBottom, x_interval.minValue(), x_interval.maxValue() );
    plot->setAxisScale( QwtPlot::yLeft, y_interval.minValue(), y_interval.maxValue() );
 
    d_curve = new QwtPlotCurve();
    d_curve->setStyle( QwtPlotCurve::Lines );
 //   d_curve->setPen( plot->canvas()->palette().color( QPalette::WindowText ) );
    d_curve->setRenderHint( QwtPlotItem::RenderAntialiased, true );
    d_curve->setPaintAttribute( QwtPlotCurve::ClipPolygons, false );
    d_curve->setData( new CurveData() );
    d_curve->attach( plot );
}
 
Plot::~Plot()
{
    delete d_directPainter;
}
 
 
 
void Plot::replot()
{
    CurveData *data = static_cast<CurveData *>( d_curve->data() );
    data->values().lock();
 
    plot->replot();
    d_paintedPoints = data->size();
 
    data->values().unlock();
}
 
void Plot::setXinterval( double min, double max )
{
        x_interval.setMaxValue( max );
        x_interval.setMinValue( min );
        plot->setAxisScale( QwtPlot::xBottom,
            x_interval.minValue(), x_interval.maxValue() );
 
        replot();
}
 
void Plot::setYinterval( double min, double max )
{
        y_interval.setMaxValue( max );
        y_interval.setMinValue( min );
        plot->setAxisScale( QwtPlot::yLeft,
            y_interval.minValue(), y_interval.maxValue() );
 
        replot();
}
 
void Plot::setPen(const QColor &color, qreal width, Qt::PenStyle style)
{
    d_curve->setPen(color, width, style);
}
 
void Plot::updateCurve()
{
    CurveData *data = static_cast<CurveData *>( d_curve->data() );
    data->values().lock();
 
    const int numPoints = data->size();
    if ( numPoints > d_paintedPoints )
    {
        const bool doClip = !plot->canvas()->testAttribute( Qt::WA_PaintOnScreen );
        if ( doClip )
        {
            /*
                Depending on the platform setting a clip might be an important
                performance issue. F.e. for Qt Embedded this reduces the
                part of the backing store that has to be copied out - maybe
                to an unaccelerated frame buffer device.
            */
 
            const QwtScaleMap xMap = plot->canvasMap( d_curve->xAxis() );
            const QwtScaleMap yMap = plot->canvasMap( d_curve->yAxis() );
 
            QRectF br = qwtBoundingRect( *data,
                d_paintedPoints - 1, numPoints - 1 );
 
            const QRect clipRect = QwtScaleMap::transform( xMap, yMap, br ).toRect();
            d_directPainter->setClipRegion( clipRect );
        }
 
        d_directPainter->drawSeries( d_curve,
            d_paintedPoints - 1, numPoints - 1 );
        d_paintedPoints = numPoints;
    }
 
    data->values().unlock();
}

---

The curvedata.h, curvedata.cpp, signaldata.h and signaldata.cpp are the same of the ocsilloscope example.

You need to copy this files on your project.

For append data only need to use the command:

Code:

---

SignalData::instance().append( QPointF value ); // where value is your data to append

---

For plot:

Code:

---

updateCurve();

---

I only have one doubt now, if I want to plot more than 1 signal in the same QwtPlot, how can I make this?

I hope I can be of help to some =)

And hope than someone can help me with this doubt. Thank you

It's always hard to say something useful, when questions are too complex, where I would need to see/check lot of code - sorry for not being responsive.
Considering your final question: of course you can have as many signals as you want to. All you need to do is to use one curve per signal.

Uwe

Hello, thanks for answer :)

How can I do that? I tried declaring 2 curvedata objects and 2 plot object, but when I plot the signals, it is like if I had only one datacurve and one "plot" object, and is like if I append the data of both signals in the same curve. Is a disaster when is plotting.

Thanks again :)

To be more specific this is what I did:

Code:

---

d1 = new CurveData;
d2 = new CurveData;
 
d_plot = new Plot( ui->qwtPlot );
p2 = new Plot( ui->qwtPlot );
 
for(i=0;i<2000;i++){
    d1->values().append( QPointF(c++,i) );
    d_plot->updateCurve();
    d2->values().append( QPointF(c+50000,2000-i) );
    p2->updateCurve();
}

---

But I was unlucky. This is the result:Attachment 12402

And that's how it should be:Attachment 12403

The red lines are the signals.

Any suggestions?

Hello, I disappeared a while because I was a little busy.

Maybe I do not need to use the SignalData like a Static type?

I dont understand how this work very well. Any one can help me?

I still can not graph more than one signal in real time in the same QwtPlot.

Please help me with that =(

Finally i was able to solve the problem =D

I just copy the classes plot, curvedata and signaldata, and rename them.

This is the code:

MainWindow:

Code:

---

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    i=0; c = 0;
 
    d1 = new CurveData;
    d2 = new CurveData_copy;
 
    d_plot = new Plot( ui->qwtPlot );
    p2 = new Plot_copy( ui->qwtPlot );
    p2->setPen(Qt::blue,1.0);
 
}

---

Button event:

Code:

---

void MainWindow::on_pushButton_clicked()
{ 
    for(i=0;i<2000;i++){
 
        d1->values().append( QPointF(c++,i) );
        d_plot->updateCurve();
        d2->values().append( QPointF(c+50000,2000-i) );
        p2->updateCurve();
 
    }
 
}

---

The "problem" is that I need to use 12 signals, and I dont know if this is the most "efficient" method.

Any suggestion is welcome =)

Here a picture of the result: Attachment 12421

I hope i can help someone with this. =)