Scatter and surface autoadjust ranges to consider all visible series

Task-number: QTRD-2605

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

8 files changed, 301 insertions, 141 deletions

diff --git a/examples/qmlscatter/qml/qmlscatter/data.qml b/examples/qmlscatter/qml/qmlscatter/data.qml
index e5e7d11f..b242270e 100644
--- a/examples/qmlscatter/qml/qmlscatter/data.qml
+++ b/examples/qmlscatter/qml/qmlscatter/data.qml
@@ -1064,16 +1064,16 @@ Item {
         ListElement{ xPos: 8.0; yPos: -2.0; zPos: 4.0 }
         ListElement{ xPos: 7.8; yPos: -2.2; zPos: 5.0 }
         ListElement{ xPos: 7.6; yPos: -2.4; zPos: 4.5 }
-        ListElement{ xPos: 7.4; yPos: -2.6; zPos: 3.8 }
+        ListElement{ xPos: 9.4; yPos: -2.6; zPos: 3.8 }
         ListElement{ xPos: 7.2; yPos: -2.8; zPos: 4.8 }
-        ListElement{ xPos: 7.0; yPos: -2.3; zPos: 4.1 }
+        ListElement{ xPos: 9.0; yPos: -2.3; zPos: 4.1 }
         ListElement{ xPos: 6.9; yPos: -3.3; zPos: 4.9 }
         ListElement{ xPos: 6.7; yPos: -3.5; zPos: 3.5 }
         ListElement{ xPos: 6.5; yPos: -3.7; zPos: 3.3 }
         ListElement{ xPos: 6.3; yPos: -3.4; zPos: 3.7 }
         ListElement{ xPos: 7.9 ; yPos: -3.32 ; zPos: 2.48 }
         ListElement{ xPos: 6.2 ; yPos: -4.04 ; zPos: 3.4 }
-        ListElement{ xPos: 8.06 ; yPos: -4.6 ; zPos: 4.08 }
+        ListElement{ xPos: 9.06 ; yPos: -4.6 ; zPos: 4.08 }
         ListElement{ xPos: 5.98 ; yPos: -2.26 ; zPos: 2.82 }
         ListElement{ xPos: 5.46 ; yPos: -3.9 ; zPos: 3.2 }
         ListElement{ xPos: 8.14 ; yPos: -3.34 ; zPos: 3.42 }
@@ -1084,13 +1084,13 @@ Item {
         ListElement{ xPos: 8.64 ; yPos: -3.04 ; zPos: 2.62 }
         ListElement{ xPos: 7.82 ; yPos: -3.68 ; zPos: 2.96 }
         ListElement{ xPos: 7.1 ; yPos: -3.6 ; zPos: 4.22 }
-        ListElement{ xPos: 7.6 ; yPos: -3.88 ; zPos: 3.9 }
-        ListElement{ xPos: 7.46 ; yPos: -4.2 ; zPos: 3.32 }
+        ListElement{ xPos: 8.6 ; yPos: -3.88 ; zPos: 3.9 }
+        ListElement{ xPos: 8.46 ; yPos: -4.2 ; zPos: 3.32 }
         ListElement{ xPos: 6.98 ; yPos: -3.94 ; zPos: 3.1 }
         ListElement{ xPos: 7.36 ; yPos: -4.24 ; zPos: 1.72 }
-        ListElement{ xPos: 8.42 ; yPos: -4.52 ; zPos: 2.62 }
+        ListElement{ xPos: 9.42 ; yPos: -4.52 ; zPos: 2.62 }
         ListElement{ xPos: 6.04 ; yPos: -4.48 ; zPos: 2.74 }
-        ListElement{ xPos: 8.7 ; yPos: -3.92 ; zPos: 3.82 }
+        ListElement{ xPos: 10.0 ; yPos: -3.92 ; zPos: 3.82 }
         ListElement{ xPos: 6.76 ; yPos: -3.5 ; zPos: 2.92 }
         ListElement{ xPos: 7 ; yPos: -4.42 ; zPos: 2.62 }
         ListElement{ xPos: 5.32 ; yPos: -3.28 ; zPos: 3.34 }
diff --git a/examples/qmlscatter/qml/qmlscatter/main.qml b/examples/qmlscatter/qml/qmlscatter/main.qml
index a03db211..2ada9240 100644
--- a/examples/qmlscatter/qml/qmlscatter/main.qml
+++ b/examples/qmlscatter/qml/qmlscatter/main.qml
@@ -77,13 +77,6 @@ Item {
             axisY.subSegmentCount: 2
             axisY.labelFormat: "%.2f"
             //! [6]
-            // TODO: Remove once QTRD-2605 is fixed
-            axisX.min: -10
-            axisX.max: 10
-            axisY.min: -5
-            axisY.max: 5
-            axisZ.min: -5
-            axisZ.max: 5
             //! [5]
             Scatter3DSeries {
                 id: scatterSeries
diff --git a/src/datavisualization/engine/bars3dcontroller.cpp b/src/datavisualization/engine/bars3dcontroller.cpp
index 88b0730f..5232a566 100644
--- a/src/datavisualization/engine/bars3dcontroller.cpp
+++ b/src/datavisualization/engine/bars3dcontroller.cpp
@@ -385,92 +385,90 @@ void Bars3DController::setSelectedBar(const QPoint &position, QBar3DSeries *seri
 
 void Bars3DController::adjustAxisRanges()
 {
-    int seriesCount = m_seriesList.size();
-    if (seriesCount) {
-        Q3DCategoryAxis *categoryAxisZ = static_cast<Q3DCategoryAxis *>(m_axisZ);
-        Q3DCategoryAxis *categoryAxisX = static_cast<Q3DCategoryAxis *>(m_axisX);
-        Q3DValueAxis *valueAxis = static_cast<Q3DValueAxis *>(m_axisY);
-
-        bool adjustZ = (categoryAxisZ && categoryAxisZ->isAutoAdjustRange());
-        bool adjustX = (categoryAxisX && categoryAxisX->isAutoAdjustRange());
-        bool adjustY = (valueAxis && categoryAxisX && categoryAxisZ && valueAxis->isAutoAdjustRange());
-
-        if (adjustZ || adjustX || adjustY) {
-            int maxRowCount = 1;
-            int maxColumnCount = 1;
-            float minValue = 0.0f;
-            float maxValue = 0.0f;
-
-            // First figure out row and column counts
-            if (adjustZ || adjustX) {
-                for (int series = 0; series < seriesCount; series++) {
-                    const QBar3DSeries *barSeries = static_cast<QBar3DSeries *>(m_seriesList.at(series));
-                    if (barSeries->isVisible()) {
-                        const QBarDataProxy *proxy = barSeries->dataProxy();
-
-                        if (adjustZ && proxy) {
-                            int rowCount = proxy->rowCount();
-                            if (rowCount)
-                                rowCount--;
-
-                            maxRowCount = qMax(maxRowCount, rowCount);
-                        }
+    Q3DCategoryAxis *categoryAxisZ = static_cast<Q3DCategoryAxis *>(m_axisZ);
+    Q3DCategoryAxis *categoryAxisX = static_cast<Q3DCategoryAxis *>(m_axisX);
+    Q3DValueAxis *valueAxis = static_cast<Q3DValueAxis *>(m_axisY);
+
+    bool adjustZ = (categoryAxisZ && categoryAxisZ->isAutoAdjustRange());
+    bool adjustX = (categoryAxisX && categoryAxisX->isAutoAdjustRange());
+    bool adjustY = (valueAxis && categoryAxisX && categoryAxisZ && valueAxis->isAutoAdjustRange());
+
+    if (adjustZ || adjustX || adjustY) {
+        int maxRowCount = 1;
+        int maxColumnCount = 1;
+        float minValue = 0.0f;
+        float maxValue = 0.0f;
+
+        // First figure out row and column counts
+        int seriesCount = m_seriesList.size();
+        if (adjustZ || adjustX) {
+            for (int series = 0; series < seriesCount; series++) {
+                const QBar3DSeries *barSeries = static_cast<QBar3DSeries *>(m_seriesList.at(series));
+                if (barSeries->isVisible()) {
+                    const QBarDataProxy *proxy = barSeries->dataProxy();
+
+                    if (adjustZ && proxy) {
+                        int rowCount = proxy->rowCount();
+                        if (rowCount)
+                            rowCount--;
+
+                        maxRowCount = qMax(maxRowCount, rowCount);
+                    }
 
-                        if (adjustX && proxy) {
-                            const QBarDataArray *array = proxy->array();
-                            int columnCount = 0;
-                            for (int i = 0; i < array->size(); i++) {
-                                if (columnCount < array->at(i)->size())
-                                    columnCount = array->at(i)->size();
-                            }
-                            if (columnCount)
-                                columnCount--;
-
-                            maxColumnCount = qMax(maxColumnCount, columnCount);
+                    if (adjustX && proxy) {
+                        const QBarDataArray *array = proxy->array();
+                        int columnCount = 0;
+                        for (int i = 0; i < array->size(); i++) {
+                            if (columnCount < array->at(i)->size())
+                                columnCount = array->at(i)->size();
                         }
+                        if (columnCount)
+                            columnCount--;
+
+                        maxColumnCount = qMax(maxColumnCount, columnCount);
                     }
                 }
-                // Call private implementations of setRange to avoid unsetting auto adjust flag
-                if (adjustZ)
-                    categoryAxisZ->dptr()->setRange(0.0f, float(maxRowCount));
-                if (adjustX)
-                    categoryAxisX->dptr()->setRange(0.0f, float(maxColumnCount));
             }
+            // Call private implementations of setRange to avoid unsetting auto adjust flag
+            if (adjustZ)
+                categoryAxisZ->dptr()->setRange(0.0f, float(maxRowCount));
+            if (adjustX)
+                categoryAxisX->dptr()->setRange(0.0f, float(maxColumnCount));
+        }
 
-            // Now that we know the row and column ranges, figure out the value axis range
-            if (adjustY) {
-                for (int series = 0; series < seriesCount; series++) {
-                    const QBar3DSeries *barSeries = static_cast<QBar3DSeries *>(m_seriesList.at(series));
-                    if (barSeries->isVisible()) {
-                        const QBarDataProxy *proxy = barSeries->dataProxy();
-                        if (adjustY && proxy) {
-                            QPair<GLfloat, GLfloat> limits = proxy->dptrc()->limitValues(categoryAxisZ->min(),
-                                                                                         categoryAxisZ->max(),
-                                                                                         categoryAxisX->min(),
-                                                                                         categoryAxisX->max());
-                            if (!series) {
-                                // First series initializes the values
-                                minValue = limits.first;
-                                maxValue = limits.second;
-                            } else {
-                                minValue = qMin(minValue, limits.first);
-                                maxValue = qMax(maxValue, limits.second);
-                            }
+        // Now that we know the row and column ranges, figure out the value axis range
+        if (adjustY) {
+            for (int series = 0; series < seriesCount; series++) {
+                const QBar3DSeries *barSeries = static_cast<QBar3DSeries *>(m_seriesList.at(series));
+                if (barSeries->isVisible()) {
+                    const QBarDataProxy *proxy = barSeries->dataProxy();
+                    if (adjustY && proxy) {
+                        QPair<GLfloat, GLfloat> limits = proxy->dptrc()->limitValues(categoryAxisZ->min(),
+                                                                                     categoryAxisZ->max(),
+                                                                                     categoryAxisX->min(),
+                                                                                     categoryAxisX->max());
+                        if (!series) {
+                            // First series initializes the values
+                            minValue = limits.first;
+                            maxValue = limits.second;
+                        } else {
+                            minValue = qMin(minValue, limits.first);
+                            maxValue = qMax(maxValue, limits.second);
                         }
                     }
                 }
+            }
 
-                if (maxValue < 0.0f)
-                    maxValue = 0.0f;
-                if (minValue > 0.0f)
-                    minValue = 0.0f;
-                if (minValue == 0.0f && maxValue == 0.0f) {
-                    // Only zero value values in data set, set range to something.
-                    minValue = 0.0f;
-                    maxValue = 1.0f;
-                }
-                valueAxis->dptr()->setRange(minValue, maxValue);
+            if (maxValue < 0.0f)
+                maxValue = 0.0f;
+            if (minValue > 0.0f)
+                minValue = 0.0f;
+            if (minValue == 0.0f && maxValue == 0.0f) {
+                // Only zero value values in data set, set range to something.
+                minValue = 0.0f;
+                maxValue = 1.0f;
             }
+            valueAxis->dptr()->setRange(minValue, maxValue);
         }
     }
 }
diff --git a/src/datavisualization/engine/scatter3dcontroller.cpp b/src/datavisualization/engine/scatter3dcontroller.cpp
index 6923f26e..0a506f19 100644
--- a/src/datavisualization/engine/scatter3dcontroller.cpp
+++ b/src/datavisualization/engine/scatter3dcontroller.cpp
@@ -239,33 +239,110 @@ void Scatter3DController::setSelectedItem(int index, QScatter3DSeries *series)
 
 void Scatter3DController::adjustValueAxisRange()
 {
-    QVector3D minLimits;
-    QVector3D maxLimits;
-    if (m_seriesList.size()) {
-        const QScatterDataProxy *proxy = static_cast<QScatter3DSeries *>(m_seriesList.at(0))->dataProxy();
-        proxy->dptrc()->limitValues(minLimits, maxLimits);
-        Q3DValueAxis *valueAxis = static_cast<Q3DValueAxis *>(m_axisX);
-        if (valueAxis && valueAxis->isAutoAdjustRange()) {
-            if (minLimits.x() != maxLimits.x())
-                valueAxis->dptr()->setRange(minLimits.x(), maxLimits.x());
-            else
-                valueAxis->dptr()->setRange(minLimits.x() - 1.0f, minLimits.x() + 1.0f); // Default to a valid range
+    Q3DValueAxis *valueAxisX = static_cast<Q3DValueAxis *>(m_axisX);
+    Q3DValueAxis *valueAxisY = static_cast<Q3DValueAxis *>(m_axisY);
+    Q3DValueAxis *valueAxisZ = static_cast<Q3DValueAxis *>(m_axisZ);
+    bool adjustX = (valueAxisX && valueAxisX->isAutoAdjustRange());
+    bool adjustY = (valueAxisY && valueAxisY->isAutoAdjustRange());
+    bool adjustZ = (valueAxisZ && valueAxisZ->isAutoAdjustRange());
+
+    if (adjustX || adjustY || adjustZ) {
+        float minValueX = 0.0f;
+        float maxValueX = 0.0f;
+        float minValueY = 0.0f;
+        float maxValueY = 0.0f;
+        float minValueZ = 0.0f;
+        float maxValueZ = 0.0f;
+        int seriesCount = m_seriesList.size();
+        for (int series = 0; series < seriesCount; series++) {
+            const QScatter3DSeries *scatterSeries =
+                    static_cast<QScatter3DSeries *>(m_seriesList.at(series));
+            const QScatterDataProxy *proxy = scatterSeries->dataProxy();
+            if (scatterSeries->isVisible() && proxy) {
+                QVector3D minLimits;
+                QVector3D maxLimits;
+                proxy->dptrc()->limitValues(minLimits, maxLimits);
+                if (adjustX) {
+                    if (!series) {
+                        // First series initializes the values
+                        minValueX = minLimits.x();
+                        maxValueX = maxLimits.x();
+                    } else {
+                        minValueX = qMin(minValueX, minLimits.x());
+                        maxValueX = qMax(maxValueX, maxLimits.x());
+                    }
+                }
+                if (adjustY) {
+                    if (!series) {
+                        // First series initializes the values
+                        minValueY = minLimits.y();
+                        maxValueY = maxLimits.y();
+                    } else {
+                        minValueY = qMin(minValueY, minLimits.y());
+                        maxValueY = qMax(maxValueY, maxLimits.y());
+                    }
+                }
+                if (adjustZ) {
+                    if (!series) {
+                        // First series initializes the values
+                        minValueZ = minLimits.z();
+                        maxValueZ = maxLimits.z();
+                    } else {
+                        minValueZ = qMin(minValueZ, minLimits.z());
+                        maxValueZ = qMax(maxValueZ, maxLimits.z());
+                    }
+                }
+            }
         }
 
-        valueAxis = static_cast<Q3DValueAxis *>(m_axisY);
-        if (valueAxis && valueAxis->isAutoAdjustRange()) {
-            if (minLimits.y() != maxLimits.y())
-                valueAxis->dptr()->setRange(minLimits.y(), maxLimits.y());
-            else
-                valueAxis->dptr()->setRange(minLimits.y() - 1.0f, minLimits.y() + 1.0f); // Default to a valid range
+        static const float adjustmentRatio = 20.0f;
+        static const float defaultAdjustment = 1.0f;
+
+        if (adjustX) {
+            // If all points at same coordinate, need to default to some valid range
+            float adjustment = 0.0f;
+            if (minValueX == maxValueX) {
+                if (adjustZ) {
+                    // X and Z are linked to have similar unit size, so choose the valid range based on it
+                    if (minValueZ == maxValueZ)
+                        adjustment = defaultAdjustment;
+                    else
+                        adjustment = qAbs(maxValueZ - minValueZ) / adjustmentRatio;
+                } else {
+                    if (valueAxisZ)
+                        adjustment = qAbs(valueAxisZ->max() - valueAxisZ->min()) / adjustmentRatio;
+                    else
+                        adjustment = defaultAdjustment;
+                }
+            }
+            valueAxisX->dptr()->setRange(minValueX - adjustment, maxValueX + adjustment);
         }
-
-        valueAxis = static_cast<Q3DValueAxis *>(m_axisZ);
-        if (valueAxis && valueAxis->isAutoAdjustRange()) {
-            if (minLimits.z() != maxLimits.z())
-                valueAxis->dptr()->setRange(minLimits.z(), maxLimits.z());
-            else
-                valueAxis->dptr()->setRange(minLimits.z() - 1.0f, minLimits.z() + 1.0f); // Default to a valid range
+        if (adjustY) {
+            // If all points at same coordinate, need to default to some valid range
+            // Y-axis unit is not dependent on other axes, so simply adjust +-1.0f
+            float adjustment = 0.0f;
+            if (minValueY == maxValueY)
+                adjustment = defaultAdjustment;
+            valueAxisY->dptr()->setRange(minValueY - adjustment, maxValueY + adjustment);
+        }
+        if (adjustZ) {
+            // If all points at same coordinate, need to default to some valid range
+            float adjustment = 0.0f;
+            if (minValueZ == maxValueZ) {
+                if (adjustX) {
+                    // X and Z are linked to have similar unit size, so choose the valid range based on it
+                    if (minValueX == maxValueX)
+                        adjustment = defaultAdjustment;
+                    else
+                        adjustment = qAbs(maxValueX - minValueX) / adjustmentRatio;
+                } else {
+                    if (valueAxisX)
+                        adjustment = qAbs(valueAxisX->max() - valueAxisX->min()) / adjustmentRatio;
+                    else
+                        adjustment = defaultAdjustment;
+                }
+            }
+            valueAxisZ->dptr()->setRange(minValueZ - adjustment, maxValueZ + adjustment);
         }
     }
 }
diff --git a/src/datavisualization/engine/surface3dcontroller.cpp b/src/datavisualization/engine/surface3dcontroller.cpp
index 1ceb75e2..3cec72d1 100644
--- a/src/datavisualization/engine/surface3dcontroller.cpp
+++ b/src/datavisualization/engine/surface3dcontroller.cpp
@@ -383,34 +383,110 @@ void Surface3DController::handleRowsRemoved(int startIndex, int count)
 
 void Surface3DController::adjustValueAxisRange()
 {
-    if (m_seriesList.size()) {
-        QVector3D minLimits;
-        QVector3D maxLimits;
-        QSurface3DSeries *series = static_cast<QSurface3DSeries *>(m_seriesList.at(0));
-        static_cast<QSurfaceDataProxy *>(series->dataProxy())->dptrc()->limitValues(minLimits,
-                                                                                    maxLimits);
-        Q3DValueAxis *valueAxis = static_cast<Q3DValueAxis *>(m_axisX);
-        if (valueAxis && valueAxis->isAutoAdjustRange()) {
-            if (minLimits.x() != maxLimits.x())
-                valueAxis->dptr()->setRange(minLimits.x(), maxLimits.x());
-            else
-                valueAxis->dptr()->setRange(minLimits.x() - 1.0f, minLimits.x() + 1.0f); // Default to some valid range
+    Q3DValueAxis *valueAxisX = static_cast<Q3DValueAxis *>(m_axisX);
+    Q3DValueAxis *valueAxisY = static_cast<Q3DValueAxis *>(m_axisY);
+    Q3DValueAxis *valueAxisZ = static_cast<Q3DValueAxis *>(m_axisZ);
+    bool adjustX = (valueAxisX && valueAxisX->isAutoAdjustRange());
+    bool adjustY = (valueAxisY && valueAxisY->isAutoAdjustRange());
+    bool adjustZ = (valueAxisZ && valueAxisZ->isAutoAdjustRange());
+
+    if (adjustX || adjustY || adjustZ) {
+        float minValueX = 0.0f;
+        float maxValueX = 0.0f;
+        float minValueY = 0.0f;
+        float maxValueY = 0.0f;
+        float minValueZ = 0.0f;
+        float maxValueZ = 0.0f;
+        int seriesCount = m_seriesList.size();
+        for (int series = 0; series < seriesCount; series++) {
+            const QSurface3DSeries *surfaceSeries =
+                    static_cast<QSurface3DSeries *>(m_seriesList.at(series));
+            const QSurfaceDataProxy *proxy = surfaceSeries->dataProxy();
+            if (surfaceSeries->isVisible() && proxy) {
+                QVector3D minLimits;
+                QVector3D maxLimits;
+                proxy->dptrc()->limitValues(minLimits, maxLimits);
+                if (adjustX) {
+                    if (!series) {
+                        // First series initializes the values
+                        minValueX = minLimits.x();
+                        maxValueX = maxLimits.x();
+                    } else {
+                        minValueX = qMin(minValueX, minLimits.x());
+                        maxValueX = qMax(maxValueX, maxLimits.x());
+                    }
+                }
+                if (adjustY) {
+                    if (!series) {
+                        // First series initializes the values
+                        minValueY = minLimits.y();
+                        maxValueY = maxLimits.y();
+                    } else {
+                        minValueY = qMin(minValueY, minLimits.y());
+                        maxValueY = qMax(maxValueY, maxLimits.y());
+                    }
+                }
+                if (adjustZ) {
+                    if (!series) {
+                        // First series initializes the values
+                        minValueZ = minLimits.z();
+                        maxValueZ = maxLimits.z();
+                    } else {
+                        minValueZ = qMin(minValueZ, minLimits.z());
+                        maxValueZ = qMax(maxValueZ, maxLimits.z());
+                    }
+                }
+            }
         }
 
-        valueAxis = static_cast<Q3DValueAxis *>(m_axisY);
-        if (valueAxis && valueAxis->isAutoAdjustRange()) {
-            if (minLimits.y() != maxLimits.y())
-                valueAxis->dptr()->setRange(minLimits.y(), maxLimits.y());
-            else
-                valueAxis->dptr()->setRange(minLimits.y() - 1.0f, minLimits.y() + 1.0f); // Default to some valid range
+        static const float adjustmentRatio = 20.0f;
+        static const float defaultAdjustment = 1.0f;
+
+        if (adjustX) {
+            // If all points at same coordinate, need to default to some valid range
+            float adjustment = 0.0f;
+            if (minValueX == maxValueX) {
+                if (adjustZ) {
+                    // X and Z are linked to have similar unit size, so choose the valid range based on it
+                    if (minValueZ == maxValueZ)
+                        adjustment = defaultAdjustment;
+                    else
+                        adjustment = qAbs(maxValueZ - minValueZ) / adjustmentRatio;
+                } else {
+                    if (valueAxisZ)
+                        adjustment = qAbs(valueAxisZ->max() - valueAxisZ->min()) / adjustmentRatio;
+                    else
+                        adjustment = defaultAdjustment;
+                }
+            }
+            valueAxisX->dptr()->setRange(minValueX - adjustment, maxValueX + adjustment);
         }
-
-        valueAxis = static_cast<Q3DValueAxis *>(m_axisZ);
-        if (valueAxis && valueAxis->isAutoAdjustRange()) {
-            if (minLimits.z() != maxLimits.z())
-                valueAxis->dptr()->setRange(minLimits.z(), maxLimits.z());
-            else
-                valueAxis->dptr()->setRange(minLimits.z() - 1.0f, minLimits.z() + 1.0f); // Default to some valid range
+        if (adjustY) {
+            // If all points at same coordinate, need to default to some valid range
+            // Y-axis unit is not dependent on other axes, so simply adjust +-1.0f
+            float adjustment = 0.0f;
+            if (minValueY == maxValueY)
+                adjustment = defaultAdjustment;
+            valueAxisY->dptr()->setRange(minValueY - adjustment, maxValueY + adjustment);
+        }
+        if (adjustZ) {
+            // If all points at same coordinate, need to default to some valid range
+            float adjustment = 0.0f;
+            if (minValueZ == maxValueZ) {
+                if (adjustX) {
+                    // X and Z are linked to have similar unit size, so choose the valid range based on it
+                    if (minValueX == maxValueX)
+                        adjustment = defaultAdjustment;
+                    else
+                        adjustment = qAbs(maxValueX - minValueX) / adjustmentRatio;
+                } else {
+                    if (valueAxisX)
+                        adjustment = qAbs(valueAxisX->max() - valueAxisX->min()) / adjustmentRatio;
+                    else
+                        adjustment = defaultAdjustment;
+                }
+            }
+            valueAxisZ->dptr()->setRange(minValueZ - adjustment, maxValueZ + adjustment);
         }
     }
 }
diff --git a/tests/scattertest/main.cpp b/tests/scattertest/main.cpp
index e9cb58b1..26f30beb 100644
--- a/tests/scattertest/main.cpp
+++ b/tests/scattertest/main.cpp
@@ -149,6 +149,12 @@ int main(int argc, char **argv)
     fontSizeSlider->setValue(30);
     fontSizeSlider->setMaximum(200);
 
+    QSlider *pointSizeSlider = new QSlider(Qt::Horizontal, widget);
+    pointSizeSlider->setTickInterval(1);
+    pointSizeSlider->setMinimum(1);
+    pointSizeSlider->setValue(30);
+    pointSizeSlider->setMaximum(100);
+
     vLayout->addWidget(themeButton, 0, Qt::AlignTop);
     vLayout->addWidget(labelButton, 0, Qt::AlignTop);
     vLayout->addWidget(styleButton, 0, Qt::AlignTop);
@@ -176,6 +182,8 @@ int main(int argc, char **argv)
     vLayout->addWidget(fontList);
     vLayout->addWidget(new QLabel(QStringLiteral("Adjust font size")));
     vLayout->addWidget(fontSizeSlider, 1, Qt::AlignTop);
+    vLayout->addWidget(new QLabel(QStringLiteral("Adjust point size")));
+    vLayout->addWidget(pointSizeSlider, 1, Qt::AlignTop);
 
     widget->show();
 
@@ -183,6 +191,8 @@ int main(int argc, char **argv)
 
     QObject::connect(fontSizeSlider, &QSlider::valueChanged, modifier,
                      &ScatterDataModifier::changeFontSize);
+    QObject::connect(pointSizeSlider, &QSlider::valueChanged, modifier,
+                     &ScatterDataModifier::changePointSize);
 
     QObject::connect(styleButton, &QPushButton::clicked, modifier,
                      &ScatterDataModifier::changeStyle);
diff --git a/tests/scattertest/scatterchart.cpp b/tests/scattertest/scatterchart.cpp
index 5f4f6f01..b1df526a 100644
--- a/tests/scattertest/scatterchart.cpp
+++ b/tests/scattertest/scatterchart.cpp
@@ -179,14 +179,19 @@ void ScatterDataModifier::changeFont(const QFont &font)
     m_chart->theme()->setFont(newFont);
 }
 
-void ScatterDataModifier::changeFontSize(int fontsize)
+void ScatterDataModifier::changeFontSize(int fontSize)
 {
-    m_fontSize = fontsize;
+    m_fontSize = fontSize;
     QFont font = m_chart->theme()->font();
     font.setPointSize(m_fontSize);
     m_chart->theme()->setFont(font);
 }
 
+void ScatterDataModifier::changePointSize(int pointSize)
+{
+    m_targetSeries->setItemSize(0.01f *  float(pointSize));
+}
+
 void ScatterDataModifier::shadowQualityUpdatedByVisual(QDataVis::ShadowQuality sq)
 {
     int quality = int(sq);
diff --git a/tests/scattertest/scatterchart.h b/tests/scattertest/scatterchart.h
index 539c430d..5524929e 100644
--- a/tests/scattertest/scatterchart.h
+++ b/tests/scattertest/scatterchart.h
@@ -41,7 +41,8 @@ public:
     void changeTheme();
     void changeLabelStyle();
     void changeFont(const QFont &font);
-    void changeFontSize(int fontsize);
+    void changeFontSize(int fontSize);
+    void changePointSize(int pointSize);
     void setBackgroundEnabled(int enabled);
     void setGridEnabled(int enabled);
     void start();