How to do asynchronous points loading.?

[kuzulis]

1. the decision is made which intervals should be displayed on the plot

This decision is known, I always know which of interval I need to display in each moment of a time.
It is not a problem.

Implementing your loading according to 1 is probably the best

Yes, I can start the asynchronous loading of the new data chunks in this 1st moment
(in a moment, when I know the bounds of new "interest interval)", It is not a problem.

I think, I can calculate the "rect of interest" from the "interval of interest",
similar to as it does inside of Qwt. And then, when the new data will be loaded, then
I just will call Plot::replot(). It is not a problem, that the replot() will calls setRectOfInterest(),
because this new "rect of interest" will be same, which is already has been read/prepared
(besides, I can disable the ScaleInterest feature at all.. yes?).

The problem is in access to the "low-level" QwtSeriesData from the parent Plot.
Should I do it like this (pseudo code) ?

// This is 1st moment, when I want the new desired "interest interval" of data.
void Plot::timerEvent(...)
{
    // The new interest interval of data, which is in time 
    // on 1 second to future(repeats each second).
    const QwtInterval currentInterval = QwtInterval(m_interval.minValue() + 1000, 
                                                                     m_interval.maxValue() + 1000);
 
    // Now, I need calculate the "new desired rect of interest"? How do it?
    const QRectF rect = rectFromCurrentInterval(currentInterval);
 
    // Now. I need to iterate of all attached curves and to get pointers to its data series.
    const auto curves = <get curves of this plot>;
    for (auto curve : curves) {
        auto series = curve->data();
 
        // Starts asynchronous data loading.
        series->setRectOfInterest(rect); 
    }
 
    // save current interval
    m_interval = currentInterval;
 
}
 
// This is 2st and 3st moments, when all curves's series notifies us (how??) that all data are ready.
void Plot::onAllDataReady(...)
{
    // Adjust scales
    setAxisScale(QwtPlot::xBottom, m_interval.minValue(), m_interval.maxValue());
 
    // Replot
    replot(); // This calls setRectOfInterest() again, but it is not a problem... besides I can disable this feature...
}

// This is 1st moment, when I want the new desired "interest interval" of data.
void Plot::timerEvent(...)
{
    // The new interest interval of data, which is in time 
    // on 1 second to future(repeats each second).
    const QwtInterval currentInterval = QwtInterval(m_interval.minValue() + 1000, 
                                                                     m_interval.maxValue() + 1000);

    // Now, I need calculate the "new desired rect of interest"? How do it?
    const QRectF rect = rectFromCurrentInterval(currentInterval);

    // Now. I need to iterate of all attached curves and to get pointers to its data series.
    const auto curves = <get curves of this plot>;
    for (auto curve : curves) {
        auto series = curve->data();

        // Starts asynchronous data loading.
        series->setRectOfInterest(rect); 
    }

    // save current interval
    m_interval = currentInterval;

}

// This is 2st and 3st moments, when all curves's series notifies us (how??) that all data are ready.
void Plot::onAllDataReady(...)
{
    // Adjust scales
    setAxisScale(QwtPlot::xBottom, m_interval.minValue(), m_interval.maxValue());

    // Replot
    replot(); // This calls setRectOfInterest() again, but it is not a problem... besides I can disable this feature...
}

To copy to clipboard, switch view to plain text mode 

Is this idea ok, or it is bad?

[Uwe]

The problem is in access to the "low-level" QwtSeriesData from the parent Plot.
Should I do it like this (pseudo code)

The idea of QwtSeriesData is to have abstract API for the curve to retrieve data, but the application is free to organize the data itself according to what is best for the use case.
So why not simply load your data into some buffer - an operation unrelated to Qwt. Once this is done connect your curve data object to this buffer and call replot.

Uwe

[kuzulis]

Once this is done connect your curve data object to this buffer and call replot.

Do you mean to use the set of setSamples() methods?

If so, then it is not an optionn for me, because it causes an overheads:
it copies and re-creates the internal QwtSeriesData objects each time when calls setSamples() (as I can see).

The "right" way for me - it is to call the Curve::setData() once.

Let's me explain:

let's assume that an initial interval of interests data is: 2 second - 10 second (width is 8 second).

The next interval will be: 3 second - 11 second (width is 8 second too)..

So, I do not need to re-fill the whole buffer for 3 second - 11 second.
I need just to append to the buffer the points between 10-11 seconds,
and to remove the points from 2-3 second (to keep the width same 8 second).

But, of course, in case of changing of the width of interval, I will re-fill whole buffer with new points
(because in this case the detail level is changed, its like the zoom changed).

So, as I understand, it is better for me to have an *one* custom QwtSeriesData object with
"tricks", related to re-implementing of the setRectOfInterest() (where I will my buffer what I need).

UPD:

Maybe, even I can do not use the QwtSeriesData at all, and just override the dataSize(), dataRect() and
setRectOfInterest() of QwtPlotCurve class... But, I'm afraid that it is wrong..

[Uwe]

Do you mean to use the set of setSamples() methods?

No:

class YourData: public QwtSeriesData<QPointF>
{
    virtual size_t size() const override
    {
        return ...;
    }
 
    virtual QPointF sample( size_t i ) const override
    {
        return ...;
    }
 
    virtual QRectF boundingRect() const override
    {
         // be careful with not introdicing a performance bottleneck here
         // better calculate it in advance an cache it
         return ...;
    }
};
 
curve->setData( new YourData() );

class YourData: public QwtSeriesData<QPointF>
{
    virtual size_t size() const override
    {
        return ...;
    }

    virtual QPointF sample( size_t i ) const override
    {
        return ...;
    }

    virtual QRectF boundingRect() const override
    {
         // be careful with not introdicing a performance bottleneck here
         // better calculate it in advance an cache it
         return ...;
    }
};

curve->setData( new YourData() );

To copy to clipboard, switch view to plain text mode 

It's totally up to you how these methods are implemented, but I guess they return values from some custom buffer. How these values come to this buffer is up the the application, Qwt does not see it.

setSamples()

Qt containers are implicitly shared: see http://doc.qt.io/qt-5/implicit-sharing.html.

So if you load your values only for the purpose of displaying it on the plot using a QPolygonF + setSamples is just fine. The only thing you could consider is to call setSamples( QPolygonF() ) before loading a new set of samples. Otherwise you need memory for 2 buffers until you can pass the new one in.

Uwe

[kuzulis]

Ok, many thanks for your help. I will think...