Add: Support for 16-bit heightmap

Added support for 16-bit heightmap in
QHeightmapSurfaceDataProxy. In addition, added a
manual test for testing the heightmap support.

Fixes: QTBUG-74814
Change-Id: Ief028a459600680593e8859c9e7b51fb2e43203c
Reviewed-by: Tomi Korpipää <tomi.korpipaa@qt.io>
Reviewed-by: Miikka Heikkinen <miikka.heikkinen@qt.io>

12 files changed, 539 insertions, 22 deletions

diff --git a/src/datavisualization/data/qheightmapsurfacedataproxy.cpp b/src/datavisualization/data/qheightmapsurfacedataproxy.cpp
index fd4ffcbb..42ca6987 100644
--- a/src/datavisualization/data/qheightmapsurfacedataproxy.cpp
+++ b/src/datavisualization/data/qheightmapsurfacedataproxy.cpp
@@ -127,6 +127,32 @@ const float defaultMaxValue = 10.0f;
  */
 
 /*!
+ * \qmlproperty real HeightMapSurfaceDataProxy::minYValue
+ * \since 6.3
+ *
+ * The minimum Y value for the generated surface points. Defaults to \c{0.0}.
+ * When setting this property the corresponding maximum value is adjusted if necessary,
+ * to ensure that the range remains valid.
+ */
+
+/*!
+ * \qmlproperty real HeightMapSurfaceDataProxy::maxYValue
+ * \since 6.3
+ *
+ * The maximum Y value for the generated surface points. Defaults to \c{10.0}.
+ * When setting this property the corresponding minimum value is adjusted if necessary,
+ * to ensure that the range remains valid.
+ */
+
+/*!
+ * \qmlproperty real HeightMapSurfaceDataProxy::autoScaleY
+ * \since 6.3
+ *
+ * Scale height values to Y-axis. Defaults to \c{false}. When this property is set to \c{true},
+ * the height values are scaled to fit on the Y-axis between \c{minYValue} and \c{maxYValue}.
+ */
+
+/*!
  * Constructs QHeightMapSurfaceDataProxy with the given \a parent.
  */
 QHeightMapSurfaceDataProxy::QHeightMapSurfaceDataProxy(QObject *parent) :
@@ -328,6 +354,75 @@ float QHeightMapSurfaceDataProxy::maxZValue() const
 }
 
 /*!
+ * \property QHeightMapSurfaceDataProxy::minYValue
+ * \since 6.3
+ *
+ * \brief The minimum Y value for the generated surface points.
+ *
+ * Defaults to \c{0.0}.
+ *
+ * When setting this property the corresponding maximum value is adjusted if necessary,
+ * to ensure that the range remains valid.
+ *
+ * \sa autoScaleY
+ */
+void QHeightMapSurfaceDataProxy::setMinYValue(float min)
+{
+    dptr()->setMinYValue(min);
+}
+
+float QHeightMapSurfaceDataProxy::minYValue() const
+{
+    return dptrc()->m_minYValue;
+}
+
+/*!
+ * \property QHeightMapSurfaceDataProxy::maxYValue
+ * \since 6.3
+ *
+ * \brief The maximum Y value for the generated surface points.
+ *
+ * Defaults to \c{10.0}.
+ *
+ * When setting this property the corresponding minimum value is adjusted if necessary,
+ * to ensure that the range remains valid.
+ *
+ * \sa autoScaleY
+ */
+void QHeightMapSurfaceDataProxy::setMaxYValue(float max)
+{
+    dptr()->setMaxYValue(max);
+}
+
+float QHeightMapSurfaceDataProxy::maxYValue() const
+{
+    return dptrc()->m_maxYValue;
+}
+
+/*!
+ * \property QHeightMapSurfaceDataProxy::autoScaleY
+ * \since 6.3
+ *
+ * \brief Scale height values to Y-axis.
+ *
+ * Defaults to \c{false}.
+ *
+ * When this property is set to \c{true},
+ * the height values are scaled to fit on the Y-axis between minYValue and maxYValue.
+ *
+ * \sa minYValue, maxYValue
+ */
+void QHeightMapSurfaceDataProxy::setAutoScaleY(bool enabled)
+{
+    dptr()->setAutoScaleY(enabled);
+}
+
+bool QHeightMapSurfaceDataProxy::autoScaleY() const
+{
+    return dptrc()->m_autoScaleY;
+}
+
+/*!
  * \internal
  */
 QHeightMapSurfaceDataProxyPrivate *QHeightMapSurfaceDataProxy::dptr()
@@ -350,7 +445,10 @@ QHeightMapSurfaceDataProxyPrivate::QHeightMapSurfaceDataProxyPrivate(QHeightMapS
       m_minXValue(defaultMinValue),
       m_maxXValue(defaultMaxValue),
       m_minZValue(defaultMinValue),
-      m_maxZValue(defaultMaxValue)
+      m_maxZValue(defaultMaxValue),
+      m_minYValue(defaultMinValue),
+      m_maxYValue(defaultMaxValue),
+      m_autoScaleY(false)
 {
     m_resolveTimer.setSingleShot(true);
     QObject::connect(&m_resolveTimer, &QTimer::timeout,
@@ -505,20 +603,89 @@ void QHeightMapSurfaceDataProxyPrivate::setMaxZValue(float max)
     }
 }
 
+void QHeightMapSurfaceDataProxyPrivate::setMinYValue(float min)
+{
+    if (m_minYValue != min) {
+        bool maxChanged = false;
+        if (min >= m_maxYValue) {
+            float oldMax = m_maxYValue;
+            m_maxYValue = min + 1.0f;
+            qWarning() << "Warning: Tried to set minimum Y to equal or larger than maximum Y for"
+                          " value range. Maximum automatically adjusted to a valid one:"
+                       << oldMax <<  "-->" << m_maxYValue;
+            maxChanged = true;
+        }
+        m_minYValue = min;
+        emit qptr()->minYValueChanged(m_minYValue);
+        if (maxChanged)
+            emit qptr()->maxYValueChanged(m_maxYValue);
+
+        if (!m_resolveTimer.isActive())
+            m_resolveTimer.start(0);
+    }
+}
+
+void QHeightMapSurfaceDataProxyPrivate::setMaxYValue(float max)
+{
+    if (m_maxYValue != max) {
+        bool minChanged = false;
+        if (max <= m_minYValue) {
+            float oldMin = m_minYValue;
+            m_minYValue = max - 1.0f;
+            qWarning() << "Warning: Tried to set maximum Y to equal or smaller than minimum Y for"
+                          " value range. Minimum automatically adjusted to a valid one:"
+                       << oldMin <<  "-->" << m_minYValue;
+            minChanged = true;
+        }
+        m_maxYValue = max;
+        emit qptr()->maxYValueChanged(m_maxYValue);
+        if (minChanged)
+            emit qptr()->minYValueChanged(m_minYValue);
+
+        if (!m_resolveTimer.isActive())
+            m_resolveTimer.start(0);
+    }
+}
+
+void QHeightMapSurfaceDataProxyPrivate::setAutoScaleY(bool enabled)
+{
+    if (enabled != m_autoScaleY) {
+        m_autoScaleY = enabled;
+        emit qptr()->autoScaleYChanged(m_autoScaleY);
+
+        if (!m_resolveTimer.isActive())
+            m_resolveTimer.start(0);
+    }
+}
+
 void QHeightMapSurfaceDataProxyPrivate::handlePendingResolve()
 {
     QImage heightImage = m_heightMap;
+    int bytesInChannel = 1;
+    float yMul = 1.0f / UINT8_MAX;
+
+    bool is16bit = (heightImage.format() == QImage::Format_RGBX64
+                    || heightImage.format() == QImage::Format_RGBA64
+                    || heightImage.format() == QImage::Format_RGBA64_Premultiplied
+                    || heightImage.format() == QImage::Format_Grayscale16);
 
     // Convert to RGB32 to be sure we're reading the right bytes
-    if (heightImage.format() != QImage::Format_RGB32)
+    if (is16bit) {
+        if (heightImage.format() != QImage::Format_RGBX64)
+            heightImage = heightImage.convertToFormat(QImage::Format_RGBX64);
+
+        bytesInChannel = 2;
+        yMul = 1.0f / UINT16_MAX;
+    } else if (heightImage.format() != QImage::Format_RGB32) {
         heightImage = heightImage.convertToFormat(QImage::Format_RGB32);
+    }
 
     uchar *bits = heightImage.bits();
 
     int imageHeight = heightImage.height();
     int imageWidth = heightImage.width();
-    int bitCount = imageWidth * 4 * (imageHeight - 1);
-    int widthBits = imageWidth * 4;
+    int bitCount = imageWidth * 4 * (imageHeight - 1) * bytesInChannel;
+    int widthBits = imageWidth * 4 * bytesInChannel;
     float height = 0;
 
     // Do not recreate array if dimensions have not changed
@@ -531,7 +698,7 @@ void QHeightMapSurfaceDataProxyPrivate::handlePendingResolve()
             dataArray->append(newProxyRow);
         }
     }
-
+    yMul *= m_maxYValue - m_minYValue;
     float xMul = (m_maxXValue - m_minXValue) / float(imageWidth - 1);
     float zMul = (m_maxZValue - m_minZValue) / float(imageHeight - 1);
 
@@ -541,7 +708,6 @@ void QHeightMapSurfaceDataProxyPrivate::handlePendingResolve()
     // getting rendered.
     int lastRow = imageHeight - 1;
     int lastCol = imageWidth - 1;
-
     if (heightImage.isGrayscale()) {
         // Grayscale, it's enough to read Red byte
         for (int i = 0; i < imageHeight; i++, bitCount -= widthBits) {
@@ -552,13 +718,21 @@ void QHeightMapSurfaceDataProxyPrivate::handlePendingResolve()
             else
                 zVal = (float(i) * zMul) + m_minZValue;
             int j = 0;
-            for (; j < lastCol; j++)
+            float yVal = 0;
+            uchar *pixelptr;
+            for (; j < lastCol; j++) {
+                pixelptr  = (uchar *)(bits + bitCount + (j * 4 * bytesInChannel));
+                if (!m_autoScaleY)
+                    yVal = *pixelptr;
+                else
+                    yVal = float(*pixelptr) * yMul + m_minYValue;
                 newRow[j].setPosition(QVector3D((float(j) * xMul) + m_minXValue,
-                                                float(bits[bitCount + (j * 4)]),
-                                      zVal));
+                                                yVal,
+                                                zVal));
+            }
             newRow[j].setPosition(QVector3D(m_maxXValue,
-                                            float(bits[bitCount + (j * 4)]),
-                                  zVal));
+                                            yVal,
+                                            zVal));
         }
     } else {
         // Not grayscale, we'll need to calculate height from RGB
@@ -570,22 +744,30 @@ void QHeightMapSurfaceDataProxyPrivate::handlePendingResolve()
             else
                 zVal = (float(i) * zMul) + m_minZValue;
             int j = 0;
-            int nextpixel = 0;
+            float yVal = 0;
             for (; j < lastCol; j++) {
-                nextpixel = j * 4;
-                height = (float(bits[bitCount + nextpixel])
-                        + float(bits[1 + bitCount + nextpixel])
-                        + float(bits[2 + bitCount + nextpixel]));
+                int nextpixel = j * 4 * bytesInChannel;
+                uchar *pixelptr = (uchar *)(bits + bitCount + nextpixel);
+                if (is16bit) {
+                    height = float(*((ushort *)pixelptr))
+                        + float(*(((ushort *)pixelptr) + 1))
+                        + float(*(((ushort *)pixelptr) + 2));
+                } else {
+                    height = (float(*pixelptr)
+                            + float(*(pixelptr + 1))
+                            + float(*(pixelptr + 2)));
+                }
+                if (!m_autoScaleY)
+                    yVal = height / 3.0f;
+                else
+                    yVal = (height / 3.0f * yMul) + m_minYValue;
+
                 newRow[j].setPosition(QVector3D((float(j) * xMul) + m_minXValue,
-                                                height / 3.0f,
+                                                yVal,
                                                 zVal));
             }
-            nextpixel = j * 4;
-            height = (float(bits[bitCount + nextpixel])
-                    + float(bits[1 + bitCount + nextpixel])
-                    + float(bits[2 + bitCount + nextpixel]));
             newRow[j].setPosition(QVector3D(m_maxXValue,
-                                            height / 3.0f,
+                                            yVal,
                                             zVal));
         }
     }
diff --git a/src/datavisualization/data/qheightmapsurfacedataproxy.h b/src/datavisualization/data/qheightmapsurfacedataproxy.h
index f9f9a23c..f1eff075 100644
--- a/src/datavisualization/data/qheightmapsurfacedataproxy.h
+++ b/src/datavisualization/data/qheightmapsurfacedataproxy.h
@@ -48,6 +48,9 @@ class QT_DATAVISUALIZATION_EXPORT QHeightMapSurfaceDataProxy : public QSurfaceDa
     Q_PROPERTY(float maxXValue READ maxXValue WRITE setMaxXValue NOTIFY maxXValueChanged)
     Q_PROPERTY(float minZValue READ minZValue WRITE setMinZValue NOTIFY minZValueChanged)
     Q_PROPERTY(float maxZValue READ maxZValue WRITE setMaxZValue NOTIFY maxZValueChanged)
+    Q_PROPERTY(float minYValue READ minYValue WRITE setMinYValue NOTIFY minYValueChanged REVISION(6, 3))
+    Q_PROPERTY(float maxYValue READ maxYValue WRITE setMaxYValue NOTIFY maxYValueChanged REVISION(6, 3))
+    Q_PROPERTY(bool autoScaleY READ autoScaleY WRITE setAutoScaleY NOTIFY autoScaleYChanged REVISION(6, 3))
 
 public:
     explicit QHeightMapSurfaceDataProxy(QObject *parent = nullptr);
@@ -69,6 +72,12 @@ public:
     float minZValue() const;
     void setMaxZValue(float max);
     float maxZValue() const;
+    void setMinYValue(float min);
+    float minYValue() const;
+    void setMaxYValue(float max);
+    float maxYValue() const;
+    void setAutoScaleY(bool enabled);
+    bool autoScaleY() const;
 
 Q_SIGNALS:
     void heightMapChanged(const QImage &image);
@@ -77,6 +86,9 @@ Q_SIGNALS:
     void maxXValueChanged(float value);
     void minZValueChanged(float value);
     void maxZValueChanged(float value);
+    Q_REVISION(6, 3) void minYValueChanged(float value);
+    Q_REVISION(6, 3) void maxYValueChanged(float value);
+    Q_REVISION(6, 3) void autoScaleYChanged(bool enabled);
 
 protected:
     explicit QHeightMapSurfaceDataProxy(QHeightMapSurfaceDataProxyPrivate *d, QObject *parent = nullptr);
diff --git a/src/datavisualization/data/qheightmapsurfacedataproxy_p.h b/src/datavisualization/data/qheightmapsurfacedataproxy_p.h
index 7dc2f41d..091291ed 100644
--- a/src/datavisualization/data/qheightmapsurfacedataproxy_p.h
+++ b/src/datavisualization/data/qheightmapsurfacedataproxy_p.h
@@ -59,6 +59,9 @@ public:
     void setMaxXValue(float max);
     void setMinZValue(float min);
     void setMaxZValue(float max);
+    void setMinYValue(float min);
+    void setMaxYValue(float max);
+    void setAutoScaleY(bool enabled);
 private:
     QHeightMapSurfaceDataProxy *qptr();
     void handlePendingResolve();
@@ -71,6 +74,9 @@ private:
     float m_maxXValue;
     float m_minZValue;
     float m_maxZValue;
+    float m_minYValue;
+    float m_maxYValue;
+    bool m_autoScaleY;
 
     friend class QHeightMapSurfaceDataProxy;
 };
diff --git a/tests/manual/CMakeLists.txt b/tests/manual/CMakeLists.txt
index 36175991..a1ca1dba 100644
--- a/tests/manual/CMakeLists.txt
+++ b/tests/manual/CMakeLists.txt
@@ -4,6 +4,7 @@ if(TARGET Qt::Quick)
     add_subdirectory(qmlvolume)
     add_subdirectory(qmlperf)
     add_subdirectory(qmlgradient)
+    add_subdirectory(qmlheightmap)
 endif()
 if(NOT ANDROID AND NOT IOS AND NOT WINRT)
     add_subdirectory(barstest)
diff --git a/tests/manual/qmlheightmap/CMakeLists.txt b/tests/manual/qmlheightmap/CMakeLists.txt
new file mode 100644
index 00000000..174b7bcf
--- /dev/null
+++ b/tests/manual/qmlheightmap/CMakeLists.txt
@@ -0,0 +1,41 @@
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTORCC ON)
+set(CMAKE_AUTOUIC ON)
+
+qt_internal_add_manual_test(qmlheightmap
+    GUI
+    SOURCES
+        main.cpp
+    )
+target_link_libraries(qmlheightmap PUBLIC
+    Qt::Gui
+    Qt::DataVisualization
+    )
+
+set_source_files_properties("gradientGRAY8.png"
+    PROPERTIES QT_RESOURCE_ALIAS "mapGRAY8"
+    )
+set_source_files_properties("gradientGRAY16.png"
+    PROPERTIES QT_RESOURCE_ALIAS "mapGRAY16"
+    )
+set_source_files_properties("gradientRGB8.png"
+    PROPERTIES QT_RESOURCE_ALIAS "mapRGB8"
+    )
+set_source_files_properties("gradientRGB16.png"
+    PROPERTIES QT_RESOURCE_ALIAS "mapRGB16"
+    )
+
+set(qmlheightmap_resource_files
+    "qml/qmlheightmap/main.qml"
+    "gradientGRAY8.png"
+    "gradientGRAY16.png"
+    "gradientRGB8.png"
+    "gradientRGB16.png"
+    )
+qt_internal_add_resource(qmlheightmap "qmlheightmap"
+    PREFIX
+    "/"
+    FILES
+    ${qmlheightmap_resource_files}
+    )
diff --git a/tests/manual/qmlheightmap/gradientGRAY16.png b/tests/manual/qmlheightmap/gradientGRAY16.png
new file mode 100644
index 00000000..28df3673
--- /dev/null
+++ b/tests/manual/qmlheightmap/gradientGRAY16.png
diff --git a/tests/manual/qmlheightmap/gradientGRAY8.png b/tests/manual/qmlheightmap/gradientGRAY8.png
new file mode 100644
index 00000000..6696e57c
--- /dev/null
+++ b/tests/manual/qmlheightmap/gradientGRAY8.png
diff --git a/tests/manual/qmlheightmap/gradientRGB16.png b/tests/manual/qmlheightmap/gradientRGB16.png
new file mode 100644
index 00000000..b62e510b
--- /dev/null
+++ b/tests/manual/qmlheightmap/gradientRGB16.png
diff --git a/tests/manual/qmlheightmap/gradientRGB8.png b/tests/manual/qmlheightmap/gradientRGB8.png
new file mode 100644
index 00000000..79879f35
--- /dev/null
+++ b/tests/manual/qmlheightmap/gradientRGB8.png
diff --git a/tests/manual/qmlheightmap/main.cpp b/tests/manual/qmlheightmap/main.cpp
new file mode 100644
index 00000000..b54e9fea
--- /dev/null
+++ b/tests/manual/qmlheightmap/main.cpp
@@ -0,0 +1,63 @@
+/****************************************************************************
+**
+** Copyright (C) 2021 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the Qt Data Visualization module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 or (at your option) any later version
+** approved by the KDE Free Qt Foundation. The licenses are as published by
+** the Free Software Foundation and appearing in the file LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtGui/QGuiApplication>
+#include <QtCore/QDir>
+#include <QtQuick/QQuickView>
+#include <QtQml/QQmlEngine>
+
+int main(int argc, char *argv[])
+{
+    qputenv("QSG_RHI_BACKEND", "opengl");
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
+#endif
+
+    QGuiApplication app(argc, argv);
+
+    QQuickView viewer;
+
+    const QUrl url(QStringLiteral("qrc:/qml/qmlheightmap/main.qml"));
+
+    // The following are needed to make examples run without having to install the module
+    // in desktop environments.
+#ifdef Q_OS_WIN
+    QString extraImportPath(QStringLiteral("%1/../../../%2"));
+#else
+    QString extraImportPath(QStringLiteral("%1/../../%2"));
+#endif
+
+    viewer.engine()->addImportPath(extraImportPath.arg(QGuiApplication::applicationDirPath(),
+                                      QString::fromLatin1("qml")));
+    QObject::connect( viewer.engine(), &QQmlEngine::quit, &viewer, &QWindow::close);
+    viewer.setSource(url);
+    viewer.show();
+    viewer.setResizeMode(QQuickView::SizeRootObjectToView);
+    return app.exec();
+}
diff --git a/tests/manual/qmlheightmap/qml.qrc b/tests/manual/qmlheightmap/qml.qrc
new file mode 100644
index 00000000..b1cbc545
--- /dev/null
+++ b/tests/manual/qmlheightmap/qml.qrc
@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/">
+        <file>qml/qmlheightmap/qml/main.qml</file>
+    </qresource>
+</RCC>
diff --git a/tests/manual/qmlheightmap/qml/qmlheightmap/main.qml b/tests/manual/qmlheightmap/qml/qmlheightmap/main.qml
new file mode 100644
index 00000000..d7e29514
--- /dev/null
+++ b/tests/manual/qmlheightmap/qml/qmlheightmap/main.qml
@@ -0,0 +1,207 @@
+/****************************************************************************
+**
+** Copyright (C) 2021 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the Qt Data Visualization module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 or (at your option) any later version
+** approved by the KDE Free Qt Foundation. The licenses are as published by
+** the Free Software Foundation and appearing in the file LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick
+import QtQuick.Window
+import QtQuick.Layouts
+import QtQuick.Controls
+import QtDataVisualization
+import "."
+
+Item {
+    id: mainwindow
+
+    width: 1024
+    height: 768
+    visible: true
+
+    Item {
+        id: surfaceview
+        width: mainwindow.width
+        height: mainwindow.height
+
+        anchors.top: mainwindow.top
+        anchors.left: mainwindow.left
+
+        ColorGradient {
+            id: surfaceGradient
+            ColorGradientStop { position: 0.0; color: "darkslategray" }
+            ColorGradientStop { id: middleGradient; position: 0.50; color: "peru" }
+            ColorGradientStop { position: 1.0; color: "red" }
+        }
+
+        Theme3D {
+            id: mainTheme
+            type: Q3DTheme.ThemeStoneMoss
+            colorStyle: Q3DTheme.ColorStyleRangeGradient
+            baseGradients: [surfaceGradient]
+        }
+
+        Surface3D {
+            id: surfaceGraph
+            width: surfaceview.width
+            height: surfaceview.height
+            theme: mainTheme
+            shadowQuality: AbstractGraph3D.ShadowQualityMedium
+            selectionMode: AbstractGraph3D.SelectionSlice | AbstractGraph3D.SelectionItemAndRow
+            scene.activeCamera.cameraPreset: Camera3D.CameraPresetIsometricLeft
+            axisY.min: 0.0
+            axisY.max: 500.0
+            axisX.segmentCount: 10
+            axisX.subSegmentCount: 2
+            axisX.labelFormat: "%i"
+            axisZ.segmentCount: 10
+            axisZ.subSegmentCount: 2
+            axisZ.labelFormat: "%i"
+            axisY.segmentCount: 5
+            axisY.subSegmentCount: 2
+            axisY.labelFormat: "%i"
+            axisY.title: "Y"
+            axisX.title: "X"
+            axisZ.title: "Z"
+
+            Surface3DSeries {
+                id: heightSeriesRGB8
+                drawMode: Surface3DSeries.DrawSurface
+                visible: true
+                flatShadingEnabled: false
+
+                HeightMapSurfaceDataProxy {
+                    heightMapFile: ":/mapRGB8"
+                    minYValue: surfaceGraph.axisY.min
+                    maxYValue: surfaceGraph.axisY.max
+                }
+            }
+
+            Surface3DSeries {
+                id: heightSeriesRGB16
+                drawMode: Surface3DSeries.DrawSurface
+                visible: false
+                flatShadingEnabled: false
+
+                HeightMapSurfaceDataProxy {
+                    heightMapFile: ":/mapRGB16"
+                    minYValue: surfaceGraph.axisY.min
+                    maxYValue: surfaceGraph.axisY.max
+                }
+            }
+
+            Surface3DSeries {
+                id: heightSeriesGRAY8
+                drawMode: Surface3DSeries.DrawSurface
+                visible: false
+                flatShadingEnabled: false
+
+                HeightMapSurfaceDataProxy {
+                    heightMapFile: ":/mapGRAY8"
+                    minYValue: surfaceGraph.axisY.min
+                    maxYValue: surfaceGraph.axisY.max
+                }
+            }
+
+            Surface3DSeries {
+                id: heightSeriesGRAY16
+                drawMode: Surface3DSeries.DrawSurface
+                visible: false
+                flatShadingEnabled: false
+
+                HeightMapSurfaceDataProxy {
+                    heightMapFile: ":/mapGRAY16"
+                    minYValue: surfaceGraph.axisY.min
+                    maxYValue: surfaceGraph.axisY.max
+                }
+            }
+        }
+
+        RowLayout {
+            id: buttonLayout
+            anchors.top: parent.top
+            anchors.left: parent.left
+            anchors.right: parent.right
+
+            Button {
+                id: toggleHeightSeries
+                Layout.fillWidth: true
+                Layout.fillHeight: true
+
+                text: qsTr("Use 16-bit rgb map")
+                onClicked: {
+                    if (heightSeriesRGB8.visible === true) {
+                        heightSeriesRGB8.visible = false
+                        heightSeriesRGB16.visible = true
+                        heightSeriesGRAY8.visible = false
+                        heightSeriesGRAY16.visible = false
+                        text = "Use 8-bit grayscale map"
+                    } else if (heightSeriesRGB16.visible === true){
+                        heightSeriesRGB8.visible = false
+                        heightSeriesRGB16.visible = false
+                        heightSeriesGRAY8.visible = true
+                        heightSeriesGRAY16.visible = false
+                        text = "Use 16-bit grayscale map"
+                    } else if (heightSeriesGRAY8.visible === true){
+                        heightSeriesRGB8.visible = false
+                        heightSeriesRGB16.visible = false
+                        heightSeriesGRAY8.visible = false
+                        heightSeriesGRAY16.visible = true
+                        text = "Use 8-bit rgb map"
+                    } else if (heightSeriesGRAY16.visible === true){
+                        heightSeriesRGB8.visible = true
+                        heightSeriesRGB16.visible = false
+                        heightSeriesGRAY8.visible = false
+                        heightSeriesGRAY16.visible = false
+                        text = "Use 16-bit rgb map"
+                    }
+                }
+            }
+
+            Button {
+                id: toggleAutoScaleY
+                Layout.fillWidth: true
+                Layout.fillHeight: true
+
+                text: qsTr("Enable autoScaleY")
+                onClicked: {
+                    if (text === "Enable autoScaleY") {
+                        heightSeriesRGB8.dataProxy.autoScaleY = true
+                        heightSeriesRGB16.dataProxy.autoScaleY = true
+                        heightSeriesGRAY8.dataProxy.autoScaleY = true
+                        heightSeriesGRAY16.dataProxy.autoScaleY = true
+                        text = "Disable autoScaleY"
+                    } else {
+                        heightSeriesRGB8.dataProxy.autoScaleY = false
+                        heightSeriesRGB16.dataProxy.autoScaleY = false
+                        heightSeriesGRAY8.dataProxy.autoScaleY = false
+                        heightSeriesGRAY16.dataProxy.autoScaleY = false
+                        text = "Enable autoScaleY"
+                    }
+                }
+            }
+        }
+    }
+}