How to do asynchronous points loading.?

Hi all.

I have implemented own class of series data, derived from QwtSeriesData, and use the method setRectOfInterest(),
for loading of data with required interval from the database:

Code:

---

class SourceSeries : public QwtSeriesData<QPointF>
{
    ...
    void setRectOfInterest(const QRectF &rect)
    {
        // do something for querying of data from the database
    }
    ...
}

---

I need to implement the behavior of plot like the "cpuplot" example,
where the X-axis displays timestamps which are updates every second.

When I need to update the data (replot the curve), I do this:

Code:

---

CURVE_UPDATE_INTERVAL_MSECS = 1000; // update every second
 
void Plot::timerEvent(QTimerEvent *)
{
    m_interval =  QwtInterval(m_interval.minValue() + CURVE_UPDATE_INTERVAL_MSECS,
                                       m_interval.maxValue() + CURVE_UPDATE_INTERVAL_MSECS);
 
    setAxisScale(QwtPlot::xBottom, m_interval.minValue(), m_interval.maxValue());
 
    replot();
}

---

But, the problem is that the queries to the database spend some time (they are
synchronous ~200 msec), and I got the "lags" in this time. E.g. when I try to move the
plot's window on a desktop, I see some "jumps" of window.

So, I looked the Qwt sources, and now I have an idea how to avoid this, but I'm
not sure that my idea is correct.

Now, I want to start the future inside of setRectOfInterest() with the query
to the database. And when it finishes, then call the Plot::replot().

Code:

---

QFutureWatcher< QList<QPointF> > *m_watcher = new QFutureWatcher<QList<QPointF>>(this);
    connect(m_watcher, &QFutureWatcher::finished, this, &SourceSeries::update);
 
    void SourceSeries::setRectOfInterest(const QRectF &rect)
    {
        const QFuture< QList<QPointF> > future = QtConcurrent::run(<function to DB query>);
        m_watcher->setFuture(future);
    }
 
    void SourceSeries::update()
    {
        const QList<QPointF> points = m_watcher->result();
        m_points = points;
 
        emit dataUpdated(); // This notified of subscribers that we can do replot
    }

---

Then the Plot's code will be modified to:

Code:

---

void Plot::timerEvent(QTimerEvent *)
{
    m_interval =  QwtInterval(m_interval.minValue() + CURVE_UPDATE_INTERVAL_MSECS,
                                       m_interval.maxValue() + CURVE_UPDATE_INTERVAL_MSECS);
 
    setAxisScale(QwtPlot::xBottom, m_interval.minValue(), m_interval.maxValue());
 
    updateAxes(); /// This will call the setRectOfInterest
}
 
connect(m_series, &SourceSeries::dataUpdated, m_plot, &Plot::redraw);
 
void Plot::redraw()
{
        const bool ok = QMetaObject::invokeMethod(
                canvas(), "replot", Qt::DirectConnection );
}

---

The problem is in that I don't know how to notify the Plot to redraw the canvas contents, as
all Qwt's classes are not derived from the QObject. Of course, I can derive it himself,
but I'm not sure in that it is correct.

Is there are proper way do to asynchronous data loading?


BR,
Denis

Quote:

---

Originally Posted by kuzulis

The problem is in that I don't know how to notify the Plot to redraw the canvas contents,...

---

I can't comment on how you plan to load your data, but forcing a repaint is simply QwtPlot::replot(). The code in Plot::redraw() does not make much sense.

Uwe

Quote:

---

but forcing a repaint is simply QwtPlot::replot().

---

Yes, but if I use QwtPlot::replot(), then it internally calls setRectOfInterest() again. That do not need for me, because it forces to query the data again and blocks UI.

I need just to do replot() without of the intermediate calls of setRectOfInterest() and etc,
so, for this purpose I just do:

Code:

---

canvas()->replot()

---

because it is a "pure" method, as I can see.

In other words, I need some API to notify the Plotter's sub-items (e.g. curves) that they notified own QwtSeriesDatas to start asynchronous queries
to its specific databases with "interest rect interval". And, when the queries will be completed, then the QwtSeriesDatas should notify its Curves,
which notified the parent Plot that it call replot().

i.e. like this:

Direction "from top to bottom":

1. Triggered timerEvent() with the new desired "interest interval of data"
2. Plotter sends to all attached curves the signal, that need to do start asynchronous queries to request the new portion of data from the DB with "interest interval".
3. Curves sends the signals to own QwtSeriesDatas, that need to do start asynchronous queries to request the new portion of data from DB with "interest interval".
4. Each of QwtSeriesDatas of each Curve starts query to DB with "interest interval".

Direction "from bottom to top":

5. All asynchronous queryes are completed.
6. Each of QwtSeriesDatas notified own Curve that new "interest interval" of data are ready.
7. Curves notified the Plot to do replot().

(of course, it is simplification to show an my idea).

BUT, I do not see any of mechanism to asynchronous notifications in Qwt, nor via the signal/slot feature, nor via virtual functions.
All designed for the "synchronous" work, as I can see. And I do not know, where it is better I can to "inject" my code for asynchronous work.

Quote:

---

Originally Posted by kuzulis

In other words, I need some API to notify the Plotter's sub-items (e.g. curves) that they notified own QwtSeriesDatas to start asynchronous queries
to its specific databases with "interest rect interval". And, when the queries will be completed, then the QwtSeriesDatas should notify its Curves,
which notified the parent Plot that it call replot().

---

There is a point in time, when:

1. the decision is made which intervals should be displayed on the plot.
2. the scales have been adjusted
3. the plot gets repainted

Implementing your loading according to 1 is probably the best and you should consider it before trying to find a solution for 2.
If you have to stay with 2 you could try to split the replot operation calling QwtPlot::updateAxes before.

Uwe

Quote:

---

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.

Quote:

---

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

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

---

Is this idea ok, or it is bad? :)

Quote:

---

Originally Posted by kuzulis

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

Quote:

---

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.. :(

Quote:

---

Originally Posted by kuzulis

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

---

No:

Code:

---

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

---

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.

Quote:

---

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

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