Multiseries support for surface

Task-number: QTRD-2767

Change-Id: Ifa7ca07f2afdb27974ad20819f0a4646293764b0
Reviewed-by: Miikka Heikkinen <miikka.heikkinen@digia.com>

1 files changed, 323 insertions, 10 deletions

diff --git a/tests/surfacetest/graphmodifier.cpp b/tests/surfacetest/graphmodifier.cpp
index 528a803b..c6247bb5 100644
--- a/tests/surfacetest/graphmodifier.cpp
+++ b/tests/surfacetest/graphmodifier.cpp
@@ -34,14 +34,18 @@ using namespace QtDataVisualization;
 
 GraphModifier::GraphModifier(Q3DSurface *graph)
     : m_graph(graph),
+      m_series1(new QSurface3DSeries),
+      m_series2(new QSurface3DSeries),
+      m_series3(new QSurface3DSeries),
+      m_series4(new QSurface3DSeries),
       m_gridSliderX(0),
       m_gridSliderZ(0),
       m_axisRangeSliderX(0),
       m_axisRangeSliderZ(0),
       m_axisMinSliderX(0),
       m_axisMinSliderZ(0),
-      m_xCount(50),
-      m_zCount(50),
+      m_xCount(24),
+      m_zCount(24),
       m_activeSample(0),
       m_fontSize(40),
       m_rangeX(16.0),
@@ -53,15 +57,32 @@ GraphModifier::GraphModifier(Q3DSurface *graph)
       m_insertTestIndexPos(1),
       m_planeArray(0),
       m_theSeries(new QSurface3DSeries),
-      m_drawMode(QSurface3DSeries::DrawSurfaceAndWireframe)
+      m_drawMode(QSurface3DSeries::DrawSurfaceAndWireframe),
+      m_drawMode2(QSurface3DSeries::DrawSurfaceAndWireframe),
+      m_drawMode3(QSurface3DSeries::DrawSurfaceAndWireframe),
+      m_drawMode4(QSurface3DSeries::DrawSurfaceAndWireframe)
 {
     m_graph->setAxisX(new QValue3DAxis);
     m_graph->setAxisY(new QValue3DAxis);
     m_graph->setAxisZ(new QValue3DAxis);
+#ifdef MULTI_SERIES
+    m_limitX = float(m_xCount) / 2.0f;
+    m_limitZ = float(m_zCount) / 2.0f;
+    m_graph->axisX()->setRange(-m_limitX, m_limitX);
+    m_graph->axisY()->setRange(-1.0f, 4.5f);
+    m_graph->axisZ()->setRange(-m_limitZ, m_limitZ);
+#else
     m_graph->axisX()->setRange(m_minX, m_minX + m_rangeX);
     m_graph->axisZ()->setRange(m_minZ, m_minZ + m_rangeZ);
     m_graph->addSeries(m_theSeries);
+#endif
+
+    for (int i = 0; i < 4; i++) {
+        m_multiseries[i] = new QSurface3DSeries;
+        m_multiseries[i]->setItemLabelFormat(QStringLiteral("@seriesName: (@xLabel, @zLabel): @yLabel"));
+    }
 
+    fillSeries();
     changeStyle();
 
     m_theSeries->setItemLabelFormat(QStringLiteral("@seriesName: (@xLabel, @zLabel): @yLabel"));
@@ -82,10 +103,100 @@ GraphModifier::~GraphModifier()
     delete m_graph;
 }
 
+void GraphModifier::fillSeries()
+{
+    int full = m_limitX * m_limitZ;
+
+    QSurfaceDataArray *dataArray1 = new QSurfaceDataArray;
+    dataArray1->reserve(m_zCount);
+    QSurfaceDataArray *dataArray2 = new QSurfaceDataArray;
+    dataArray2->reserve(m_zCount);
+    QSurfaceDataArray *dataArray3 = new QSurfaceDataArray;
+    dataArray3->reserve(m_zCount);
+    QSurfaceDataArray *dataArray4 = new QSurfaceDataArray;
+    dataArray4->reserve(m_zCount);
+
+    for (int i = 0; i < m_zCount; i++) {
+        QSurfaceDataRow *newRow1 = new QSurfaceDataRow(m_xCount);
+        QSurfaceDataRow *newRow2 = new QSurfaceDataRow(m_xCount);
+        QSurfaceDataRow *newRow3 = new QSurfaceDataRow(m_xCount);
+        QSurfaceDataRow *newRow4 = new QSurfaceDataRow(m_xCount);
+
+        for (int j = 0; j < m_xCount; j++) {
+            float x = float(j) - m_limitX + 0.5f;
+            float z = float(i) - m_limitZ + 0.5f;
+            float angle = (z * x) / float(full) * 1.57f;
+            (*newRow1)[j].setPosition(QVector3D(x, qSin(angle), z));
+            angle *= 1.3f;
+            (*newRow2)[j].setPosition(QVector3D(x, qSin(angle) + 1.1f, z));
+            angle *= 1.3f;
+            (*newRow3)[j].setPosition(QVector3D(x, qSin(angle) + 2.2f, z));
+            angle *= 1.3f;
+            (*newRow4)[j].setPosition(QVector3D(x, qSin(angle) + 3.3f, z));
+        }
+        *dataArray1 << newRow1;
+        *dataArray2 << newRow2;
+        *dataArray3 << newRow3;
+        *dataArray4 << newRow4;
+    }
+
+    m_multiseries[0]->dataProxy()->resetArray(dataArray1);
+    m_multiseries[1]->dataProxy()->resetArray(dataArray2);
+    m_multiseries[2]->dataProxy()->resetArray(dataArray3);
+    m_multiseries[3]->dataProxy()->resetArray(dataArray4);
+}
+
+void GraphModifier::toggleSeries1(bool enabled)
+{
+    qDebug() << __FUNCTION__ << " enabled = " << enabled;
+
+    if (enabled) {
+        m_graph->addSeries(m_multiseries[0]);
+    } else {
+        m_graph->removeSeries(m_multiseries[0]);
+    }
+}
+
+void GraphModifier::toggleSeries2(bool enabled)
+{
+    qDebug() << __FUNCTION__ << " enabled = " << enabled;
+
+    if (enabled) {
+        m_graph->addSeries(m_multiseries[1]);
+    } else {
+        m_graph->removeSeries(m_multiseries[1]);
+    }
+}
+
+void GraphModifier::toggleSeries3(bool enabled)
+{
+    qDebug() << __FUNCTION__ << " enabled = " << enabled;
+
+    if (enabled) {
+        m_graph->addSeries(m_multiseries[2]);
+    } else {
+        m_graph->removeSeries(m_multiseries[2]);
+    }
+}
+
+void GraphModifier::toggleSeries4(bool enabled)
+{
+    qDebug() << __FUNCTION__ << " enabled = " << enabled;
+
+    if (enabled) {
+        m_graph->addSeries(m_multiseries[3]);
+    } else {
+        m_graph->removeSeries(m_multiseries[3]);
+    }
+}
+
 void GraphModifier::toggleSmooth(bool enabled)
 {
     qDebug() << "GraphModifier::toggleSmooth " << enabled;
     m_theSeries->setFlatShadingEnabled(enabled);
+#ifdef MULTI_SERIES
+    m_multiseries[0]->setFlatShadingEnabled(enabled);
+#endif
 }
 
 void GraphModifier::toggleSurfaceGrid(bool enable)
@@ -97,6 +208,9 @@ void GraphModifier::toggleSurfaceGrid(bool enable)
         m_drawMode &= ~QSurface3DSeries::DrawWireframe;
 
     m_theSeries->setDrawMode(m_drawMode);
+#ifdef MULTI_SERIES
+    m_multiseries[0]->setDrawMode(m_drawMode);
+#endif
 }
 
 void GraphModifier::toggleSurface(bool enable)
@@ -108,11 +222,119 @@ void GraphModifier::toggleSurface(bool enable)
         m_drawMode &= ~QSurface3DSeries::DrawSurface;
 
     m_theSeries->setDrawMode(m_drawMode);
+#ifdef MULTI_SERIES
+    m_multiseries[0]->setDrawMode(m_drawMode);
+#endif
 }
 
 void GraphModifier::toggleSeriesVisible(bool enable)
 {
     m_theSeries->setVisible(enable);
+#ifdef MULTI_SERIES
+    m_multiseries[0]->setVisible(enable);
+#endif
+}
+
+void GraphModifier::toggleSmoothS2(bool enabled)
+{
+    qDebug() << __FUNCTION__ << enabled;
+    m_multiseries[1]->setFlatShadingEnabled(enabled);
+}
+
+void GraphModifier::toggleSurfaceGridS2(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    if (enable)
+        m_drawMode2 |= QSurface3DSeries::DrawWireframe;
+    else
+        m_drawMode2 &= ~QSurface3DSeries::DrawWireframe;
+
+    m_multiseries[1]->setDrawMode(m_drawMode2);
+}
+
+void GraphModifier::toggleSurfaceS2(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    if (enable)
+        m_drawMode2 |= QSurface3DSeries::DrawSurface;
+    else
+        m_drawMode2 &= ~QSurface3DSeries::DrawSurface;
+
+    m_multiseries[1]->setDrawMode(m_drawMode2);
+}
+
+void GraphModifier::toggleSeries2Visible(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    m_multiseries[1]->setVisible(enable);
+}
+
+void GraphModifier::toggleSmoothS3(bool enabled)
+{
+    qDebug() << __FUNCTION__ << enabled;
+    m_multiseries[2]->setFlatShadingEnabled(enabled);
+}
+
+void GraphModifier::toggleSurfaceGridS3(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    if (enable)
+        m_drawMode3 |= QSurface3DSeries::DrawWireframe;
+    else
+        m_drawMode3 &= ~QSurface3DSeries::DrawWireframe;
+
+    m_multiseries[2]->setDrawMode(m_drawMode3);
+}
+
+void GraphModifier::toggleSurfaceS3(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    if (enable)
+        m_drawMode3 |= QSurface3DSeries::DrawSurface;
+    else
+        m_drawMode3 &= ~QSurface3DSeries::DrawSurface;
+
+    m_multiseries[2]->setDrawMode(m_drawMode3);
+}
+
+void GraphModifier::toggleSeries3Visible(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    m_multiseries[2]->setVisible(enable);
+}
+
+void GraphModifier::toggleSmoothS4(bool enabled)
+{
+    qDebug() << __FUNCTION__ << enabled;
+    m_multiseries[3]->setFlatShadingEnabled(enabled);
+}
+
+void GraphModifier::toggleSurfaceGridS4(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    if (enable)
+        m_drawMode4 |= QSurface3DSeries::DrawWireframe;
+    else
+        m_drawMode4 &= ~QSurface3DSeries::DrawWireframe;
+
+    m_multiseries[3]->setDrawMode(m_drawMode4);
+}
+
+void GraphModifier::toggleSurfaceS4(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    if (enable)
+        m_drawMode4 |= QSurface3DSeries::DrawSurface;
+    else
+        m_drawMode4 &= ~QSurface3DSeries::DrawSurface;
+
+    m_multiseries[3]->setDrawMode(m_drawMode4);
+}
+
+void GraphModifier::toggleSeries4Visible(bool enable)
+{
+    qDebug() << __FUNCTION__ << enable;
+    m_multiseries[3]->setVisible(enable);
 }
 
 void GraphModifier::toggleSqrtSin(bool enable)
@@ -347,9 +569,14 @@ void GraphModifier::gradientPressed()
     gradient.setColorAt(0.33, Qt::blue);
     gradient.setColorAt(0.67, Qt::red);
     gradient.setColorAt(1.0, Qt::yellow);
-    m_graph->seriesList().at(0)->setBaseGradient(gradient);
-    m_graph->seriesList().at(0)->setSingleHighlightColor(Qt::red);
-    m_graph->seriesList().at(0)->setColorStyle(Q3DTheme::ColorStyleRangeGradient);
+//    m_graph->seriesList().at(0)->setBaseGradient(gradient);
+//    m_graph->seriesList().at(0)->setSingleHighlightColor(Qt::red);
+//    m_graph->seriesList().at(0)->setColorStyle(Q3DTheme::ColorStyleRangeGradient);
+
+    QList<QLinearGradient> gradients;
+    gradients << gradient;
+    m_graph->activeTheme()->setBaseGradients(gradients);
+    m_graph->activeTheme()->setColorStyle(Q3DTheme::ColorStyleRangeGradient);
 }
 
 void GraphModifier::changeFont(const QFont &font)
@@ -572,7 +799,23 @@ void GraphModifier::addRow()
 
         m_theSeries->dataProxy()->addRow(newRow);
     } else {
-        qDebug() << "Change row function active only for SqrtSin";
+#ifdef MULTI_SERIES
+        qDebug() << "Adding a row into series 3";
+        int full = m_limitX * m_limitZ;
+
+        QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
+        for (int j = 0; j < m_xCount; j++) {
+            float angle = float((float(m_addRowCounter) - m_limitZ + 0.5f) * (float(j) - m_limitX + 0.5f)) / float(full) * 1.57f;
+            (*newRow)[j].setPosition(QVector3D(float(j) - m_limitX + 0.5f,
+                                               qSin(angle * 1.3f * 1.3f) + 2.2f,
+                                               float(m_addRowCounter) - m_limitZ + 0.5f));
+        }
+        m_addRowCounter++;
+
+        m_multiseries[2]->dataProxy()->addRow(newRow);
+#else
+            qDebug() << "Add row function active only for SqrtSin";
+#endif
     }
 }
 
@@ -605,7 +848,27 @@ void GraphModifier::addRows()
 
         m_theSeries->dataProxy()->addRows(dataArray);
     } else {
-        qDebug() << "Change row function active only for SqrtSin";
+#ifdef MULTI_SERIES
+    qDebug() << "Adding 3 rows into series 3";
+    int full = m_limitX * m_limitZ;
+
+    QSurfaceDataArray dataArray;
+    for (int i = 0; i < 3; i++) {
+        QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
+        for (int j = 0; j < m_xCount; j++) {
+            float angle = float((float(m_addRowCounter) - m_limitZ + 0.5f) * (float(j) - m_limitX + 0.5f)) / float(full) * 1.57f;
+            (*newRow)[j].setPosition(QVector3D(float(j) - m_limitX + 0.5f,
+                                               qSin(angle * 1.3f * 1.3f) + 2.2f,
+                                               float(m_addRowCounter) - m_limitZ + 0.5f));
+        }
+        dataArray.append(newRow);
+        m_addRowCounter++;
+    }
+
+    m_multiseries[2]->dataProxy()->addRows(dataArray);
+#else
+        qDebug() << "Add rows function active only for SqrtSin";
+#endif
     }
 }
 
@@ -633,7 +896,25 @@ void GraphModifier::insertRow()
         m_theSeries->dataProxy()->insertRow(m_insertTestIndexPos, newRow);
         m_insertTestIndexPos += 2;
     } else {
-        qDebug() << "Change row function active only for SqrtSin";
+#ifdef MULTI_SERIES
+    qDebug() << "Inserting a row into series 3";
+    int full = m_limitX * m_limitZ;
+
+    QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
+    for (int j = 0; j < m_xCount; j++) {
+        float angle = float((float(m_insertTestZPos) - m_limitZ) * (float(j) - m_limitX)) / float(full) * 1.57f;
+        (*newRow)[j].setPosition(QVector3D(float(j) - m_limitX + 0.5f,
+                                           qSin(angle) + 2.4f,
+                                           float(m_insertTestZPos) - m_limitZ + 1.0f));
+    }
+
+    m_insertTestZPos++;
+
+    m_multiseries[2]->dataProxy()->insertRow(m_insertTestIndexPos, newRow);
+    m_insertTestIndexPos += 2;
+#else
+        qDebug() << "Insert row function active only for SqrtSin";
+#endif
     }
 }
 
@@ -665,15 +946,47 @@ void GraphModifier::insertRows()
         m_theSeries->dataProxy()->insertRows(m_insertTestIndexPos, dataArray);
         m_insertTestIndexPos += 4;
     } else {
-        qDebug() << "Change row function active only for SqrtSin";
+#ifdef MULTI_SERIES
+    qDebug() << "Inserting 3 rows into series 3";
+    int full = m_limitX * m_limitZ;
+    QSurfaceDataArray dataArray;
+    float zAdd = 0.25f;
+    for (int i = 0; i < 3; i++) {
+        QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
+        for (int j = 0; j < m_xCount; j++) {
+            float angle = float((float(m_insertTestZPos) - m_limitZ) * (float(j) - m_limitX)) / float(full) * 1.57f;
+            (*newRow)[j].setPosition(QVector3D(float(j) - m_limitX + 0.5f,
+                                               qSin(angle) + 2.4f,
+                                               float(m_insertTestZPos) - m_limitZ + 0.5f + zAdd));
+        }
+        zAdd += 0.25f;
+        dataArray.append(newRow);
+    }
+
+    m_insertTestZPos++;
+
+    m_multiseries[2]->dataProxy()->insertRows(m_insertTestIndexPos, dataArray);
+    m_insertTestIndexPos += 4;
+#else
+        qDebug() << "Insert rows function active only for SqrtSin";
+#endif
     }
 }
 
 void GraphModifier::removeRow()
 {
     qDebug() << "Remove an arbitrary row";
+    if (m_zCount < 1)
+        return;
+
     int row = rand() % m_zCount;
+
+#ifdef MULTI_SERIES
+    int series = rand() % 4;
+    m_multiseries[series]->dataProxy()->removeRows(row, 1);
+#else
     m_theSeries->dataProxy()->removeRows(row, 1);
+#endif
     m_zCount--;
 }