Real time plot doubts

[fjld93]

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. example.png

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!

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

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;}
}

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;}
}

To copy to clipboard, switch view to plain text mode 

but this dont work. and try also:

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;}
}

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;}
}

To copy to clipboard, switch view to plain text mode 

But doesn't work either.

Only with replot work for me

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

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

To copy to clipboard, switch view to plain text mode 

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

gui.jpg

[fjld93]

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: 1.jpg

After resize a little for be able to click the button this is the result: 2.jpg

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:

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

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

To copy to clipboard, switch view to plain text mode 

And I have this result: after_change.png

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: after_resize.jpg

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

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

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

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

}

To copy to clipboard, switch view to plain text mode 

And this is the click event:

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

void MainWindow::on_pushButton_clicked()
{

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

}

To copy to clipboard, switch view to plain text mode 

Thank you again =)

Regards

[fjld93]

Hello, I finally could solve the problem

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

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;
 
};

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;

};

To copy to clipboard, switch view to plain text mode 

Plot.cpp

#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();
}

#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();
}

To copy to clipboard, switch view to plain text mode 

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:

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

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

To copy to clipboard, switch view to plain text mode 

For plot:

updateCurve();

updateCurve();

To copy to clipboard, switch view to plain text mode 

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

[Uwe]

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

[fjld93]

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

[fjld93]

To be more specific this is what I did:

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();
}

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();
}

To copy to clipboard, switch view to plain text mode 

But I was unlucky. This is the result:bad_result.png

And that's how it should be:good_result.png

The red lines are the signals.

Any suggestions?

[fjld93]

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 =(

[fjld93]

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:

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

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

}

To copy to clipboard, switch view to plain text mode 

Button event:

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();
 
    }
 
}

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

    }

}

To copy to clipboard, switch view to plain text mode 

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: 2curves.png

I hope i can help someone with this. =)