Added some tests for massive arrays

Change-Id: Iac99e4fddbbbcb9074051199815e0c58412582fa
Reviewed-by: Tomi Korpipää <tomi.korpipaa@digia.com>

6 files changed, 336 insertions, 5 deletions

diff --git a/tests/scattertest/main.cpp b/tests/scattertest/main.cpp
index 2bd60aff..78bab934 100644
--- a/tests/scattertest/main.cpp
+++ b/tests/scattertest/main.cpp
@@ -120,6 +120,9 @@ int main(int argc, char **argv)
     QPushButton *startTimerButton = new QPushButton(widget);
     startTimerButton->setText(QStringLiteral("Start/stop timer"));
 
+    QPushButton *massiveDataTestButton = new QPushButton(widget);
+    massiveDataTestButton->setText(QStringLiteral("Massive data test"));
+
     QLinearGradient grBtoY(0, 0, 100, 0);
     grBtoY.setColorAt(1.0, Qt::black);
     grBtoY.setColorAt(0.67, Qt::blue);
@@ -229,12 +232,13 @@ int main(int argc, char **argv)
     vLayout->addWidget(toggleSeriesVisibilityButton, 0, Qt::AlignTop);
     vLayout->addWidget(changeSeriesNameButton, 0, Qt::AlignTop);
     vLayout->addWidget(startTimerButton, 0, Qt::AlignTop);
-    vLayout->addWidget(gradientBtoYPB, 0, Qt::AlignTop);
-    vLayout->addWidget(backgroundCheckBox);
-    vLayout->addWidget(gridCheckBox);
-    vLayout->addWidget(new QLabel(QStringLiteral("Adjust shadow quality")));
-    vLayout->addWidget(shadowQuality, 1, Qt::AlignTop);
+    vLayout->addWidget(massiveDataTestButton, 1, Qt::AlignTop);
 
+    vLayout2->addWidget(gradientBtoYPB, 0, Qt::AlignTop);
+    vLayout2->addWidget(backgroundCheckBox);
+    vLayout2->addWidget(gridCheckBox);
+    vLayout2->addWidget(new QLabel(QStringLiteral("Adjust shadow quality")));
+    vLayout2->addWidget(shadowQuality, 0, Qt::AlignTop);
     vLayout2->addWidget(new QLabel(QStringLiteral("Adjust point size")));
     vLayout2->addWidget(pointSizeSlider, 0, Qt::AlignTop);
     vLayout2->addWidget(new QLabel(QStringLiteral("Adjust data window")));
@@ -296,6 +300,8 @@ int main(int argc, char **argv)
                      &ScatterDataModifier::changeSeriesName);
     QObject::connect(startTimerButton, &QPushButton::clicked, modifier,
                      &ScatterDataModifier::startStopTimer);
+    QObject::connect(massiveDataTestButton, &QPushButton::clicked, modifier,
+                     &ScatterDataModifier::massiveDataTest);
     QObject::connect(gradientBtoYPB, &QPushButton::clicked, modifier,
                      &ScatterDataModifier::setGradient);
     QObject::connect(themeButton, &QPushButton::clicked, modifier,
diff --git a/tests/scattertest/scatterchart.cpp b/tests/scattertest/scatterchart.cpp
index 2e208926..c9404736 100644
--- a/tests/scattertest/scatterchart.cpp
+++ b/tests/scattertest/scatterchart.cpp
@@ -62,6 +62,8 @@ ScatterDataModifier::ScatterDataModifier(Q3DScatter *scatter)
                      &ScatterDataModifier::handleAxisYChanged);
     QObject::connect(m_chart, &Q3DScatter::axisZChanged, this,
                      &ScatterDataModifier::handleAxisZChanged);
+    QObject::connect(m_chart, &QAbstract3DGraph::currentFpsChanged, this,
+                     &ScatterDataModifier::handleFpsChange);
 }
 
 ScatterDataModifier::~ScatterDataModifier()
@@ -74,6 +76,161 @@ void ScatterDataModifier::start()
     addData();
 }
 
+static const int itemsPerUnit = 100; // "unit" is one unit range along Z-axis
+
+void ScatterDataModifier::massiveDataTest()
+{
+    static int testPhase = 0;
+    static QTimer *massiveTestTimer = 0;
+
+    if (!massiveTestTimer)
+        massiveTestTimer = new QTimer;
+
+    int items = 1000000;
+    int visibleRange = 200;
+    int unitCount = items / itemsPerUnit;
+    int cacheSize = visibleRange * itemsPerUnit * 5;
+
+    switch (testPhase) {
+    case 0: {
+        float yRangeMin = 0.0f;
+        float yRangeMax = 1.0f;
+        float yRangeMargin = 0.05f;
+        float minY = yRangeMin + yRangeMargin;
+        float maxY = yRangeMax - yRangeMargin;
+        float unitBase = minY;
+        float direction = 1.0f;
+
+        if (!m_massiveTestCacheArray.size()) {
+            m_massiveTestCacheArray.resize(cacheSize);
+            int totalIndex = 0;
+            for (int i = 0; i < unitCount && totalIndex < cacheSize; i++) {
+                unitBase += direction * (float(rand() % 3) / 100.0f);
+                if (unitBase > maxY) {
+                    unitBase = maxY;
+                    direction = -1.0f;
+                } else if (unitBase < minY) {
+                    unitBase = minY;
+                    direction = 1.0f;
+                }
+                for (int j = 0; j < itemsPerUnit && totalIndex < cacheSize; j++) {
+                    float randFactor = float(rand() % 100) / (100 / yRangeMargin);
+                    m_massiveTestCacheArray[totalIndex].setPosition(
+                                QVector3D(float(qrand() % itemsPerUnit),
+                                          unitBase + randFactor, 0.0f));
+                    // Z value is irrelevant, we replace it anyway when we take item to use
+                    totalIndex++;
+                }
+            }
+        }
+
+        qDebug() << __FUNCTION__ << testPhase << ": Setting the graph up...";
+        QValue3DAxis *xAxis = new QValue3DAxis();
+        QValue3DAxis *yAxis = new QValue3DAxis();
+        QValue3DAxis *zAxis = new QValue3DAxis();
+        xAxis->setRange(0.0f, float(itemsPerUnit - 1));
+        yAxis->setRange(yRangeMin, yRangeMax);
+        zAxis->setRange(0.0f, float(visibleRange - 1));
+        xAxis->setSegmentCount(1);
+        yAxis->setSegmentCount(1);
+        zAxis->setSegmentCount(1);
+        m_chart->setMeasureFps(true);
+        m_chart->setAxisX(xAxis);
+        m_chart->setAxisY(yAxis);
+        m_chart->setAxisZ(zAxis);
+        m_chart->scene()->activeCamera()->setCameraPreset(Q3DCamera::CameraPresetRight);
+        m_chart->setShadowQuality(QAbstract3DGraph::ShadowQualityNone);
+        foreach (QAbstract3DSeries *series, m_chart->seriesList())
+            m_chart->removeSeries(static_cast<QScatter3DSeries *>(series));
+
+        qDebug() << __FUNCTION__ << testPhase << ": Creating massive array..." << items;
+        QScatterDataArray *massiveArray = new QScatterDataArray;
+        massiveArray->resize(items);
+
+        int cacheIndex = 0;
+        for (int i = 0; i < items; i++) {
+            // Use qreals for precicion as the numbers can overflow int
+            float currentZ = float(qreal(i) * qreal(unitCount) / qreal(items));
+            (*massiveArray)[i] = m_massiveTestCacheArray.at(cacheIndex++);
+            (*massiveArray)[i].setZ(currentZ);
+            if (cacheIndex >= cacheSize)
+                cacheIndex = 0;
+        }
+        qDebug() << __FUNCTION__ << testPhase << ": Massive array creation finished!";
+
+        QScatter3DSeries *series =  new QScatter3DSeries;
+        series->dataProxy()->resetArray(massiveArray);
+        series->setMesh(QAbstract3DSeries::MeshPoint);
+        m_chart->addSeries(series);
+        break;
+    }
+    case 1: {
+        qDebug() << __FUNCTION__ << testPhase << ": Scroll";
+        QObject::disconnect(massiveTestTimer, 0, this, 0);
+        QObject::connect(massiveTestTimer, &QTimer::timeout, this,
+                         &ScatterDataModifier::massiveTestScroll);
+        massiveTestTimer->start(16);
+        break;
+    }
+    case 2: {
+        qDebug() << __FUNCTION__ << testPhase << ": Append and scroll";
+        massiveTestTimer->stop();
+        QObject::disconnect(massiveTestTimer, 0, this, 0);
+        QObject::connect(massiveTestTimer, &QTimer::timeout, this,
+                         &ScatterDataModifier::massiveTestAppendAndScroll);
+        m_chart->axisZ()->setRange(unitCount - visibleRange, unitCount);
+        massiveTestTimer->start(16);
+        break;
+    }
+    default:
+        QObject::disconnect(massiveTestTimer, 0, this, 0);
+        massiveTestTimer->stop();
+        qDebug() << __FUNCTION__ << testPhase << ": Resetting the test";
+        testPhase = -1;
+    }
+    testPhase++;
+}
+
+void ScatterDataModifier::massiveTestScroll()
+{
+    const int scrollAmount = 20;
+    int itemCount = m_chart->seriesList().at(0)->dataProxy()->itemCount();
+    int min = m_chart->axisZ()->min() + scrollAmount;
+    int max = m_chart->axisZ()->max() + scrollAmount;
+    if (max >= itemCount / itemsPerUnit) {
+        max = max - min - 1;
+        min = 0;
+    }
+    m_chart->axisZ()->setRange(min, max);
+}
+
+void ScatterDataModifier::massiveTestAppendAndScroll()
+{
+    const int addedUnits = 50;
+    const int addedItems = itemsPerUnit * addedUnits;
+    int cacheSize = m_massiveTestCacheArray.size();
+    int itemCount = m_chart->seriesList().at(0)->dataProxy()->itemCount();
+    static int cacheIndex = 0;
+
+    // Copy items from cache
+    QScatterDataArray appendArray;
+    appendArray.resize(addedItems);
+
+    float zOffset = m_chart->seriesList().at(0)->dataProxy()->itemAt(itemCount - 1)->z();
+    for (int i = 0; i < addedItems; i++) {
+        float currentZ = zOffset + float(qreal(i) * qreal(addedUnits) / qreal(addedItems));
+        appendArray[i] = m_massiveTestCacheArray.at(cacheIndex++);
+        appendArray[i].setZ(currentZ);
+        if (cacheIndex >= cacheSize)
+            cacheIndex = 0;
+    }
+
+    m_chart->seriesList().at(0)->dataProxy()->addItems(appendArray);
+    int min = m_chart->axisZ()->min() + addedUnits;
+    int max = m_chart->axisZ()->max() + addedUnits;
+    m_chart->axisZ()->setRange(min, max);
+}
+
 void ScatterDataModifier::addData()
 {
     // Add labels
@@ -514,6 +671,11 @@ void ScatterDataModifier::handleAxisZChanged(QValue3DAxis *axis)
     qDebug() << __FUNCTION__ << axis << axis->orientation() << (axis == m_chart->axisZ());
 }
 
+void ScatterDataModifier::handleFpsChange(qreal fps)
+{
+    qDebug() << "FPS:" << fps;
+}
+
 void ScatterDataModifier::changeShadowQuality(int quality)
 {
     QAbstract3DGraph::ShadowQuality sq = QAbstract3DGraph::ShadowQuality(quality);
diff --git a/tests/scattertest/scatterchart.h b/tests/scattertest/scatterchart.h
index 1470f07b..66f69625 100644
--- a/tests/scattertest/scatterchart.h
+++ b/tests/scattertest/scatterchart.h
@@ -52,6 +52,9 @@ public:
     void setMaxY(int max);
     void setMaxZ(int max);
     void start();
+    void massiveDataTest();
+    void massiveTestScroll();
+    void massiveTestAppendAndScroll();
 
 public slots:
     void changeShadowQuality(int quality);
@@ -80,6 +83,7 @@ public slots:
     void handleAxisXChanged(QValue3DAxis *axis);
     void handleAxisYChanged(QValue3DAxis *axis);
     void handleAxisZChanged(QValue3DAxis *axis);
+    void handleFpsChange(qreal fps);
 
 signals:
     void shadowQualityChanged(int quality);
@@ -94,6 +98,7 @@ private:
     int m_loopCounter;
     int m_selectedItem;
     QScatter3DSeries *m_targetSeries;
+    QScatterDataArray m_massiveTestCacheArray;
 };
 
 #endif
diff --git a/tests/surfacetest/graphmodifier.cpp b/tests/surfacetest/graphmodifier.cpp
index c87eb2fc..a4eb3a27 100644
--- a/tests/surfacetest/graphmodifier.cpp
+++ b/tests/surfacetest/graphmodifier.cpp
@@ -117,6 +117,8 @@ GraphModifier::GraphModifier(Q3DSurface *graph)
                      &GraphModifier::handleAxisYChanged);
     QObject::connect(m_graph, &Q3DSurface::axisZChanged, this,
                      &GraphModifier::handleAxisZChanged);
+    QObject::connect(m_graph, &QAbstract3DGraph::currentFpsChanged, this,
+                     &GraphModifier::handleFpsChange);
 }
 
 GraphModifier::~GraphModifier()
@@ -693,6 +695,11 @@ void GraphModifier::handleAxisZChanged(QValue3DAxis *axis)
     qDebug() << __FUNCTION__ << axis << axis->orientation() << (axis == m_graph->axisZ());
 }
 
+void GraphModifier::handleFpsChange(qreal fps)
+{
+    qDebug() << "FPS:" << fps;
+}
+
 void GraphModifier::resetArrayAndSliders(QSurfaceDataArray *array, float minZ, float maxZ, float minX, float maxX)
 {
     m_axisMinSliderX->setValue(minX);
@@ -1131,6 +1138,146 @@ void GraphModifier::resetArrayEmpty()
 #endif
 }
 
+void GraphModifier::massiveDataTest()
+{
+    static int testPhase = 0;
+    static const int cacheSize = 1000;
+    const int columns = 200;
+    const int rows = 200000;
+    const int visibleRows = 200;
+    const float yRangeMin = 0.0f;
+    const float yRangeMax = 1.0f;
+    const float yRangeMargin = 0.05f;
+    static QTimer *massiveTestTimer = 0;
+
+    // To speed up massive array creation, we generate a smaller cache array
+    // and copy rows from that to our main array
+    if (!m_massiveTestCacheArray.size()) {
+        m_massiveTestCacheArray.reserve(cacheSize);
+        float minY = yRangeMin + yRangeMargin;
+        float maxY = yRangeMax - yRangeMargin;
+        float rowBase = minY;
+        float direction = 1.0f;
+        for (int i = 0; i < cacheSize; i++) {
+            m_massiveTestCacheArray.append(new QSurfaceDataRow);
+            m_massiveTestCacheArray[i]->resize(columns);
+            rowBase += direction * (float(rand() % 3) / 100.0f);
+            if (rowBase > maxY) {
+                rowBase = maxY;
+                direction = -1.0f;
+            } else if (rowBase < minY) {
+                rowBase = minY;
+                direction = 1.0f;
+            }
+            for (int j = 0; j < columns; j++) {
+                float randFactor = float(rand() % 100) / (100 / yRangeMargin);
+                (*m_massiveTestCacheArray.at(i))[j].setX(float(j));
+                (*m_massiveTestCacheArray.at(i))[j].setY(rowBase + randFactor);
+                // Z value is irrelevant, we replace it anyway when we take row to use
+            }
+        }
+        massiveTestTimer = new QTimer;
+    }
+
+    switch (testPhase) {
+    case 0: {
+        qDebug() << __FUNCTION__ << testPhase << ": Setting the graph up...";
+        QValue3DAxis *xAxis = new QValue3DAxis();
+        QValue3DAxis *yAxis = new QValue3DAxis();
+        QValue3DAxis *zAxis = new QValue3DAxis();
+        xAxis->setRange(0.0f, float(columns));
+        yAxis->setRange(yRangeMin, yRangeMax);
+        zAxis->setRange(0.0f, float(visibleRows));
+        xAxis->setSegmentCount(1);
+        yAxis->setSegmentCount(1);
+        zAxis->setSegmentCount(1);
+        m_graph->setMeasureFps(true);
+        m_graph->setAxisX(xAxis);
+        m_graph->setAxisY(yAxis);
+        m_graph->setAxisZ(zAxis);
+        m_graph->scene()->activeCamera()->setCameraPreset(Q3DCamera::CameraPresetRight);
+        m_graph->setShadowQuality(QAbstract3DGraph::ShadowQualityNone);
+        foreach (QAbstract3DSeries *series, m_graph->seriesList())
+            m_graph->removeSeries(static_cast<QSurface3DSeries *>(series));
+
+        qDebug() << __FUNCTION__ << testPhase << ": Creating massive array..."
+                 << rows << "x" << columns;
+        QSurfaceDataArray *massiveArray = new QSurfaceDataArray;
+        massiveArray->reserve(rows);
+
+        for (int i = 0; i < rows; i++) {
+            QSurfaceDataRow *newRow = new QSurfaceDataRow(*m_massiveTestCacheArray.at(i % cacheSize));
+            for (int j = 0; j < columns; j++)
+                (*newRow)[j].setZ(float(i));
+            massiveArray->append(newRow);
+        }
+        qDebug() << __FUNCTION__ << testPhase << ": Massive array creation finished!";
+
+        QSurface3DSeries *series =  new QSurface3DSeries;
+        series->dataProxy()->resetArray(massiveArray);
+        m_graph->addSeries(series);
+        break;
+    }
+    case 1: {
+        qDebug() << __FUNCTION__ << testPhase << ": Scroll";
+        QObject::disconnect(massiveTestTimer, 0, this, 0);
+        QObject::connect(massiveTestTimer, &QTimer::timeout, this,
+                         &GraphModifier::massiveTestScroll);
+        massiveTestTimer->start(16);
+        break;
+    }
+    case 2: {
+        qDebug() << __FUNCTION__ << testPhase << ": Append and scroll";
+        massiveTestTimer->stop();
+        QObject::disconnect(massiveTestTimer, 0, this, 0);
+        QObject::connect(massiveTestTimer, &QTimer::timeout, this,
+                         &GraphModifier::massiveTestAppendAndScroll);
+        m_graph->axisZ()->setRange(rows - visibleRows, rows);
+        massiveTestTimer->start(16);
+        break;
+    }
+    default:
+        QObject::disconnect(massiveTestTimer, 0, this, 0);
+        massiveTestTimer->stop();
+        qDebug() << __FUNCTION__ << testPhase << ": Resetting the test";
+        testPhase = -1;
+    }
+    testPhase++;
+}
+
+void GraphModifier::massiveTestScroll()
+{
+    const int scrollAmount = 20;
+    int maxRows = m_graph->seriesList().at(0)->dataProxy()->rowCount();
+    int min = m_graph->axisZ()->min() + scrollAmount;
+    int max = m_graph->axisZ()->max() + scrollAmount;
+    if (max >= maxRows) {
+        max = max - min;
+        min = 0;
+    }
+    m_graph->axisZ()->setRange(min, max);
+}
+
+void GraphModifier::massiveTestAppendAndScroll()
+{
+    const int addedRows = 50;
+    int maxRows = m_graph->seriesList().at(0)->dataProxy()->rowCount();
+    int columns = m_graph->seriesList().at(0)->dataProxy()->columnCount();
+
+    QSurfaceDataArray appendArray;
+    appendArray.reserve(addedRows);
+    for (int i = 0; i < addedRows; i++) {
+        QSurfaceDataRow *newRow = new QSurfaceDataRow(*m_massiveTestCacheArray.at((i + maxRows) % 1000));
+        for (int j = 0; j < columns; j++)
+            (*newRow)[j].setZ(float(maxRows + i));
+        appendArray.append(newRow);
+    }
+    m_graph->seriesList().at(0)->dataProxy()->addRows(appendArray);
+    int min = m_graph->axisZ()->min() + addedRows;
+    int max = m_graph->axisZ()->max() + addedRows;
+    m_graph->axisZ()->setRange(min, max);
+}
+
 void GraphModifier::changeMesh()
 {
     static int model = 0;
diff --git a/tests/surfacetest/graphmodifier.h b/tests/surfacetest/graphmodifier.h
index 5c4ed033..f79055df 100644
--- a/tests/surfacetest/graphmodifier.h
+++ b/tests/surfacetest/graphmodifier.h
@@ -107,6 +107,9 @@ public:
     void removeRow();
     void resetArray();
     void resetArrayEmpty();
+    void massiveDataTest();
+    void massiveTestScroll();
+    void massiveTestAppendAndScroll();
 
 public slots:
     void changeShadowQuality(int quality);
@@ -118,6 +121,7 @@ public slots:
     void handleAxisXChanged(QValue3DAxis *axis);
     void handleAxisYChanged(QValue3DAxis *axis);
     void handleAxisZChanged(QValue3DAxis *axis);
+    void handleFpsChange(qreal fps);
 
 private:
     void fillSeries();
@@ -168,6 +172,7 @@ private:
     float m_offset;
     float m_multiSampleOffsetX[4];
     float m_multiSampleOffsetZ[4];
+    QSurfaceDataArray m_massiveTestCacheArray;
 };
 
 #endif
diff --git a/tests/surfacetest/main.cpp b/tests/surfacetest/main.cpp
index bddb2d11..aa300207 100644
--- a/tests/surfacetest/main.cpp
+++ b/tests/surfacetest/main.cpp
@@ -344,6 +344,9 @@ int main(int argc, char *argv[])
     QPushButton *resetArrayEmptyButton = new QPushButton(widget);
     resetArrayEmptyButton->setText(QStringLiteral("Reset Series Array to empty"));
 
+    QPushButton *massiveDataTestButton = new QPushButton(widget);
+    massiveDataTestButton->setText(QStringLiteral("Massive data test"));
+
     QFrame* line = new QFrame();
     line->setFrameShape(QFrame::HLine);
     line->setFrameShadow(QFrame::Sunken);
@@ -431,6 +434,7 @@ int main(int argc, char *argv[])
     vLayout2->addWidget(removeRowButton);
     vLayout2->addWidget(resetArrayButton);
     vLayout2->addWidget(resetArrayEmptyButton);
+    vLayout2->addWidget(massiveDataTestButton);
 
     widget->show();
 
@@ -586,6 +590,8 @@ int main(int argc, char *argv[])
                      modifier, &GraphModifier::resetArray);
     QObject::connect(resetArrayEmptyButton,&QPushButton::clicked,
                      modifier, &GraphModifier::resetArrayEmpty);
+    QObject::connect(massiveDataTestButton,&QPushButton::clicked,
+                     modifier, &GraphModifier::massiveDataTest);
 
 #ifdef MULTI_SERIES
     modifier->setSeries1CB(series1CB);