put data conversion into a conversion queue

conversionqueue.cpp

@@ -0,0 +1,51 @@
+#include "conversionqueue.h"
+
+
+ConversionRequest::ConversionRequest(QVector<QPointF> *buffer, const DataResult1D &data)
+    :buffer(buffer), data(data) {}
+
+ConversionQueue::ConversionQueue(QObject *parent)
+    :QThread(parent), stopped(false)
+{}
+
+ConversionQueue::~ConversionQueue(){}
+
+void ConversionQueue::run() {
+    mutex.lock();
+    bool stop = stopped || (requestQueue.size() == 0);
+    mutex.unlock();
+    while (!stop) {
+        mutex.lock();
+        if (requestQueue.size() > 0) {
+            ConversionRequest r = requestQueue.front();
+            DataResult1D data = r.data;
+            double min = data.ydata[0];
+            double max = data.ydata[0];
+            for (size_t i = 0; i < data.xdata.size(); ++i) {
+                r.buffer->push_back({data.xdata[i], data.ydata[i]});
+                if (data.ydata[i] < min)
+                    min = data.ydata[i];
+                if (data.ydata[i] > max)
+                    max = data.ydata[i];
+            }
+            emit dataConverted(QString::fromStdString(r.data.entityId), min, max);
+            requestQueue.pop_front();
+            stop = requestQueue.size() == 0 || stopped;
+        }
+        mutex.unlock();
+    }
+}
+
+void ConversionQueue::requestConversion(QVector<QPointF> *buffer, const DataResult1D &data) {
+    mutex.lock();
+    ConversionRequest r(buffer, data);
+    requestQueue.push_back(r);
+    mutex.unlock();
+    start();
+}
+
+void ConversionQueue::stop() {
+    mutex.lock();
+    stopped = true;
+    mutex.unlock();
+}

conversionqueue.h

@@ -0,0 +1,41 @@
+#ifndef CONVERSIONQUEUE_H
+#define CONVERSIONQUEUE_H
+
+#include <QThread>
+#include <deque>
+#include <QVector>
+#include <QPointF>
+
+#include "dataresult1d.h"
+
+struct ConversionRequest {
+public:
+    ConversionRequest(QVector<QPointF> *buffer, const DataResult1D &data);
+
+    QVector<QPointF> *buffer;
+    DataResult1D data;
+};
+
+
+class ConversionQueue : public QThread {
+    Q_OBJECT
+public:
+    ConversionQueue(QObject *parent = 0);
+    ~ConversionQueue();
+
+    void run() override;
+    void stop();
+signals:
+    void dataConverted(QString entityId, double, double);
+
+public slots:
+    void requestConversion(QVector<QPointF> *buffer, const DataResult1D &data);
+
+private:
+    std::deque<ConversionRequest> requestQueue;
+    QMutex mutex;
+    bool stopped;
+};
+
+
+#endif // CONVERSIONQUEUE_H

dataloader.cpp

@@ -8,10 +8,12 @@ DataLoader::DataLoader()
 
 DataResult1D DataLoader::doLoad(DataRequest &request) {
     std::vector<double> x, y;
-    x = request.array.getDimension(1).asSampledDimension().axis(request.count[0], request.start[0]);
+
     if (request.start + request.count > request.array.dataExtent())
         request.count = request.array.dataExtent() - request.start;
+    x = request.array.getDimension(1).asSampledDimension().axis(request.count[0], request.start[0]);
     request.array.getData(y, request.count, request.start);
+    std::cerr << x[0] << std::endl;
     DataResult1D res(request.id, request.array.id(), x, y);
     return res;
 }

mainwindow.cpp

@@ -26,6 +26,7 @@ MainWindow::MainWindow(QWidget *parent) :
     loader->moveToThread(&dataQueue);
 
     dataQueue.start();
+    conversionQueue.start();
     /*
     file = nix::File::open("/home/grewe/zwischenlager/2017-08-17-af-invivo-1/2017-08-17-af-invivo-1.nix",
                            nix::FileMode::ReadOnly);
@@ -36,7 +37,7 @@ MainWindow::MainWindow(QWidget *parent) :
     this->voltage = b.getDataArray("V-1");
     this->eod = b.getDataArray("EOD");
 
-    MultiChartView *mcv = new MultiChartView(&dataQueue);
+    MultiChartView *mcv = new MultiChartView(&dataQueue, &conversionQueue);
     ui->vbox->addWidget(mcv);
 
     mcv->addArray(eod);
@@ -45,11 +46,18 @@ MainWindow::MainWindow(QWidget *parent) :
 
 
 MainWindow::~MainWindow() {
+    std::cerr << "destructor"<< std::endl;
     if (file) {
         file.close();
     }
     dataQueue.stop();
     dataQueue.quit();
     dataQueue.wait();
+    std::cerr << dataQueue.isRunning() << std::endl;
+    conversionQueue.stop();
+    conversionQueue.quit();
+    conversionQueue.wait();
+    std::cerr << conversionQueue.isRunning() << std::endl;
+
     delete ui;
 }

mainwindow.h

@@ -7,6 +7,7 @@
 
 #include "dataservice.h"
 #include "dataqueue.h"
+#include "conversionqueue.h"
 #include "dataresult1d.h"
 #include "chart.h"
 #include "chartview.h"
@@ -28,6 +29,7 @@ public:
 private:
     Ui::MainWindow *ui;
     DataQueue dataQueue;
+    ConversionQueue conversionQueue;
     nix::DataArray voltage, eod;
     nix::File file;
 };

multichartview.cpp

@@ -4,8 +4,8 @@
 
 using namespace QtCharts;
 
-MultiChartView::MultiChartView(DataQueue *queue, QWidget *parent) :
+MultiChartView::MultiChartView(DataQueue *queue, ConversionQueue *cqueue, QWidget *parent) :
-    QWidget(parent), dataQueue(queue),
+    QWidget(parent), dataQueue(queue), conversionQueue(cqueue),
     ui(new Ui::MultiChartView)
 {
     ui->setupUi(this);
@@ -13,6 +13,7 @@ MultiChartView::MultiChartView(DataQueue *queue, QWidget *parent) :
     xRangeMin = 0.0;
     connect(dataQueue, SIGNAL(resultReady(QString)), this, SLOT(dataReady(QString)));
     //connect(&dataQueue, SIGNAL(finished()), &dataQueue, SLOT(deleteLater()));
+    connect(conversionQueue, SIGNAL(dataConverted(QString,double,double)), this, SLOT(dataConverted(QString,double,double)));
     labelFont = QFont("Sans", 10);
     tickLabelFont = QFont("Sans", 7);
     setContentsMargins(QMargins(0,0,0,0));
@@ -134,16 +135,19 @@ void MultiChartView::newDataRequest(const std::string &entity_id, qreal max) {
 
 
 void MultiChartView::dataReady(QString requestId){
-    // need to make sure, that only one tasks does the conversion on the same buffer at the same time.
+    // need to make sure, that only one task does the conversion on the same buffer at the same time.
     std::cerr << "converting data for array: " << requestId.toStdString() << std::endl;
     DataResult1D data = dataQueue->getData(requestId);
     if (data.id.empty()) {
         return;
     }
+    conversionQueue->requestConversion(data_buffer[data.entityId], data);
+    /*
     ConvertToSeries *task = new ConvertToSeries();
     task->setData(data_buffer[data.entityId], data);
     connect(task, SIGNAL(dataConverted(QString, double, double)), this, SLOT(dataConverted(QString, double, double)));
     QThreadPool::globalInstance()->start(task);
+    */
 }
 
 void MultiChartView::dataConverted(QString entityId, double ymin, double ymax) {

multichartview.h

@@ -7,6 +7,7 @@
 #include <nix.hpp>
 
 #include "dataqueue.h"
+#include "conversionqueue.h"
 #include "chart.h"
 #include "chartview.h"
 
@@ -99,7 +100,7 @@ class MultiChartView : public QWidget
     Q_OBJECT
 
 public:
-    explicit MultiChartView(DataQueue *queue, QWidget *parent = 0);
+    explicit MultiChartView(DataQueue *queue, ConversionQueue *cqueue, QWidget *parent = 0);
     ~MultiChartView();
 
     void addArray(const nix::DataArray &array);
@@ -107,6 +108,7 @@ public:
 
 private:
     DataQueue *dataQueue;
+    ConversionQueue *conversionQueue;
     Ui::MultiChartView *ui;
     double xRangeMin, xRangeMax;
     std::map<std::string, nix::DataArray> arrayMap;