Galería de gráficos
Galería de gráficos de barras, de puntos y de superficies.
La Galería de gráficos muestra los tres tipos de gráficos y algunas de sus características especiales. Los gráficos tienen sus propias pestañas en la aplicación.

Ejecución del ejemplo
Puedes ejecutar el ejemplo desde:
- Qt Creator
Abre el modo « Welcome » y selecciona el ejemplo en « Examples ». Para obtener más información, consulta Qt Creator: Tutorial: Compilar y ejecutar.
- Qt Extension for Visual Studio Code
Ejecute el comando « Qt: Open Qt examples » desde Command Palette y seleccione el ejemplo de la lista. Para obtener más información, consulte Qt Extension for Visual Studio Code: Tutorial: Compilar y ejecutar.
Gráfico de barras
En la pestaña « Bar Graph », crea un gráfico de barras en 3D utilizando Q3DBars y combina el uso de widgets para ajustar diversas propiedades del gráfico. El ejemplo muestra cómo:
- Crear una aplicación con Q3DBars y algunos widgets
- Utilizar QBar3DSeries y QBarDataProxy para establecer los datos del gráfico
- Ajustar algunas propiedades del gráfico y de las series mediante los controles de los widgets
- Seleccionar una fila o una columna haciendo clic en la etiqueta de un eje
- Crear un proxy personalizado para utilizarlo con Q3DBars
Para obtener información sobre cómo interactuar con el gráfico, consulta esta página.
Creación de la aplicación
En primer lugar, en ` bargraph.cpp`, instancie `Q3DBars`:
m_barsGraph = new Q3DBars();A continuación, crea el widget y los diseños horizontal y vertical.
El gráfico se incrusta en un contenedor de ventana mediante QWidget::createWindowContainer(). Esto es necesario porque todas las clases de gráficos de visualización de datos (Q3DBars, Q3DScatter, Q3DSurface) heredan de QWindow. Esta es la única forma de utilizar una clase que herede de QWindow como widget.
Añade el gráfico y el diseño vertical al diseño horizontal:
m_barsWidget = new QWidget;
auto *hLayout = new QHBoxLayout(m_barsWidget);
m_container = QWidget::createWindowContainer(m_barsGraph, m_barsWidget);
m_barsGraph->resize(minimumGraphSize);
m_container->setMinimumSize(minimumGraphSize);
m_container->setMaximumSize(maximumGraphSize);
m_container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
m_container->setFocusPolicy(Qt::StrongFocus);
hLayout->addWidget(m_container, 1);
auto *vLayout = new QVBoxLayout();
hLayout->addLayout(vLayout);A continuación, crea otra clase para gestionar la incorporación de datos y otras interacciones con el gráfico:
auto *modifier = new GraphModifier(m_barsGraph, this);Configuración del gráfico de barras
Configura el gráfico en el constructor de la clase ` GraphModifier `:
GraphModifier::GraphModifier(Q3DBars *bargraph, QObject *parent) :
QObject(parent),
m_graph(bargraph),En primer lugar, crea los ejes y las series como variables de miembro para poder modificarlos fácilmente:
m_temperatureAxis(new QValue3DAxis),
m_yearAxis(new QCategory3DAxis),
m_monthAxis(new QCategory3DAxis),
m_primarySeries(new QBar3DSeries),
m_secondarySeries(new QBar3DSeries),
m_celsiusString(u"°C"_s)A continuación, establece algunas propiedades visuales para el gráfico:
m_graph->setShadowQuality(QAbstract3DGraph::ShadowQualitySoftMedium);
m_graph->activeTheme()->setBackgroundEnabled(false);
m_graph->activeTheme()->setFont(QFont("Times New Roman", m_fontSize));
m_graph->activeTheme()->setLabelBackgroundEnabled(true);
m_graph->setMultiSeriesUniform(true);Configura los ejes y haz que sean los ejes activos del gráfico:
m_temperatureAxis->setTitle("Average temperature");
m_temperatureAxis->setSegmentCount(m_segments);
m_temperatureAxis->setSubSegmentCount(m_subSegments);
m_temperatureAxis->setRange(m_minval, m_maxval);
m_temperatureAxis->setLabelFormat(u"%.1f "_s + m_celsiusString);
m_temperatureAxis->setLabelAutoRotation(30.0f);
m_temperatureAxis->setTitleVisible(true);
m_yearAxis->setTitle("Year");
m_yearAxis->setLabelAutoRotation(30.0f);
m_yearAxis->setTitleVisible(true);
m_monthAxis->setTitle("Month");
m_monthAxis->setLabelAutoRotation(30.0f);
m_monthAxis->setTitleVisible(true);
m_graph->setValueAxis(m_temperatureAxis);
m_graph->setRowAxis(m_yearAxis);
m_graph->setColumnAxis(m_monthAxis);Aplica a las etiquetas de los ejes un pequeño ángulo de rotación automática con setLabelAutoRotation() para que se orienten ligeramente hacia la cámara. Esto mejora la legibilidad de las etiquetas de los ejes en ángulos extremos de la cámara.
A continuación, inicializa las propiedades visuales de las series. Ten en cuenta que la segunda serie no es visible inicialmente:
m_primarySeries->setItemLabelFormat(u"Oulu - @colLabel @rowLabel: @valueLabel"_s);
m_primarySeries->setMesh(QAbstract3DSeries::MeshBevelBar);
m_primarySeries->setMeshSmooth(false);
m_secondarySeries->setItemLabelFormat(u"Helsinki - @colLabel @rowLabel: @valueLabel"_s);
m_secondarySeries->setMesh(QAbstract3DSeries::MeshBevelBar);
m_secondarySeries->setMeshSmooth(false);
m_secondarySeries->setVisible(false);Añade las series al gráfico:
m_graph->addSeries(m_primarySeries);
m_graph->addSeries(m_secondarySeries);Por último, configura el ángulo de la cámara llamando al mismo método que utiliza el botón de cambio de ángulo de la cámara en la interfaz de usuario para alternar entre los distintos ángulos de la cámara:
changePresetCamera();La cámara se controla a través del objeto de escena del gráfico:
static int preset = Q3DCamera::CameraPresetFront;
m_graph->scene()->activeCamera()->setCameraPreset((Q3DCamera::CameraPreset)preset);
if (++preset > Q3DCamera::CameraPresetDirectlyBelow)
preset = Q3DCamera::CameraPresetFrontLow;Para obtener más información sobre el uso de escenas y cámaras, consulta Q3DScene y Q3DCamera.
Añadir datos al gráfico
Al final del constructor, llama a un método que configure los datos:
resetTemperatureData();Este método añade datos a los proxies de las dos series:
// Set up data
static const float tempOulu[8][12] = {
{-7.4f, -2.4f, 0.0f, 3.0f, 8.2f, 11.6f, 14.7f, 15.4f, 11.4f, 4.2f, 2.1f, -2.3f}, // 2015
{-13.4f, -3.9f, -1.8f, 3.1f, 10.6f, 13.7f, 17.8f, 13.6f, 10.7f, 3.5f, -3.1f, -4.2f}, // 2016
...
auto *dataSet = new QBarDataArray;
auto *dataSet2 = new QBarDataArray;
dataSet->reserve(m_years.size());
for (qsizetype year = 0; year < m_years.size(); ++year) {
// Create a data row
auto *dataRow = new QBarDataRow(m_months.size());
auto *dataRow2 = new QBarDataRow(m_months.size());
for (qsizetype month = 0; month < m_months.size(); ++month) {
// Add data to the row
(*dataRow)[month].setValue(tempOulu[year][month]);
(*dataRow2)[month].setValue(tempHelsinki[year][month]);
}
// Add the row to the set
dataSet->append(dataRow);
dataSet2->append(dataRow2);
}
// Add data to the data proxy (the data proxy assumes ownership of it)
m_primarySeries->dataProxy()->resetArray(dataSet, m_years, m_months);
m_secondarySeries->dataProxy()->resetArray(dataSet2, m_years, m_months);Uso de widgets para controlar el gráfico
Continúa añadiendo algunos widgets en bargraph.cpp. Añade un control deslizante:
auto *rotationSliderX = new QSlider(Qt::Horizontal, m_barsWidget);
rotationSliderX->setTickInterval(30);
rotationSliderX->setTickPosition(QSlider::TicksBelow);
rotationSliderX->setMinimum(-180);
rotationSliderX->setValue(0);
rotationSliderX->setMaximum(180);Utiliza el control deslizante para girar el gráfico en lugar de usar solo el ratón o la pantalla táctil. Añádelo al diseño vertical:
vLayout->addWidget(new QLabel(u"Rotate horizontally"_s));
vLayout->addWidget(rotationSliderX, 0, Qt::AlignTop);A continuación, conéctalo a un método en GraphModifier:
Crea una ranura en GraphModifier para la conexión de la señal. La cámara se controla a través del objeto de escena. Esta vez, especifica la posición real de la cámara a lo largo de la órbita alrededor del punto central, en lugar de especificar un ángulo de cámara preestablecido:
void GraphModifier::rotateX(int rotation)
{
m_xRotation = rotation;
m_graph->scene()->activeCamera()->setCameraPosition(m_xRotation, m_yRotation);
}Ahora puedes utilizar el control deslizante para girar el gráfico.
Añade más widgets al diseño vertical para controlar:
- La rotación del gráfico
- Estilo de etiqueta
- Preajuste de la cámara
- Visibilidad del fondo
- La visibilidad de la cuadrícula
- Suavidad del sombreado de las barras
- Visibilidad de la segunda serie de barras
- Dirección del eje de valores
- Visibilidad y rotación del título del eje
- Rango de datos que se va a mostrar
- Estilo de las barras
- Modo de selección
- Tema
- Calidad de la sombra
- Fuente
- Tamaño de la fuente
- Rotación de las etiquetas de los ejes
- Modo de datos
Algunos controles del widget se desactivan intencionadamente cuando se está en el modo de datos « Custom Proxy Data ».
Selección de una fila o columna haciendo clic en una etiqueta de eje
La selección mediante la etiqueta del eje es la funcionalidad predeterminada para los gráficos de barras. A modo de ejemplo, puedes seleccionar filas haciendo clic en una etiqueta de eje de la siguiente manera:
- Cambia el modo de selección a
SelectionRow - Haz clic en una etiqueta de año
- Se selecciona la fila con el año en el que se ha hecho clic
El mismo método funciona con las opciones « SelectionSlice » y « SelectionItem », siempre que también se haya establecido « SelectionRow » o « SelectionColumn ».
Acercamiento a la selección
Como ejemplo de ajuste del objetivo de la cámara, implementa una animación de zoom sobre la selección al pulsar un botón. Las inicializaciones de la animación se realizan en el constructor:
Q3DCamera *camera = m_graph->scene()->activeCamera();
m_defaultAngleX = camera->xRotation();
m_defaultAngleY = camera->yRotation();
m_defaultZoom = camera->zoomLevel();
m_defaultTarget = camera->target();
m_animationCameraX.setTargetObject(camera);
m_animationCameraY.setTargetObject(camera);
m_animationCameraZoom.setTargetObject(camera);
m_animationCameraTarget.setTargetObject(camera);
m_animationCameraX.setPropertyName("xRotation");
m_animationCameraY.setPropertyName("yRotation");
m_animationCameraZoom.setPropertyName("zoomLevel");
m_animationCameraTarget.setPropertyName("target");
int duration = 1700;
m_animationCameraX.setDuration(duration);
m_animationCameraY.setDuration(duration);
m_animationCameraZoom.setDuration(duration);
m_animationCameraTarget.setDuration(duration);
// The zoom always first zooms out above the graph and then zooms in
qreal zoomOutFraction = 0.3;
m_animationCameraX.setKeyValueAt(zoomOutFraction, QVariant::fromValue(0.0f));
m_animationCameraY.setKeyValueAt(zoomOutFraction, QVariant::fromValue(90.0f));
m_animationCameraZoom.setKeyValueAt(zoomOutFraction, QVariant::fromValue(50.0f));
m_animationCameraTarget.setKeyValueAt(zoomOutFraction,
QVariant::fromValue(QVector3D(0.0f, 0.0f, 0.0f)));La función GraphModifier::zoomToSelectedBar() contiene la funcionalidad de zoom. QPropertyAnimation m_animationCameraTarget apunta a la propiedad Q3DCamera::target, que toma un valor normalizado al intervalo (-1, 1).
Calcula dónde se encuentra la barra seleccionada con respecto a los ejes y utiliza ese valor como valor final para ` m_animationCameraTarget`:
QVector3D endTarget;
float xMin = m_graph->columnAxis()->min();
float xRange = m_graph->columnAxis()->max() - xMin;
float zMin = m_graph->rowAxis()->min();
float zRange = m_graph->rowAxis()->max() - zMin;
endTarget.setX((selectedBar.y() - xMin) / xRange * 2.0f - 1.0f);
endTarget.setZ((selectedBar.x() - zMin) / zRange * 2.0f - 1.0f);
...
m_animationCameraTarget.setEndValue(QVariant::fromValue(endTarget));A continuación, gira la cámara de modo que siempre apunte aproximadamente al centro del gráfico al final de la animación:
qreal endAngleX = 90.0 - qRadiansToDegrees(qAtan(qreal(endTarget.z() / endTarget.x())));
if (endTarget.x() > 0.0f)
endAngleX -= 180.0f;
float barValue = m_graph->selectedSeries()->dataProxy()->itemAt(selectedBar.x(),
selectedBar.y())->value();
float endAngleY = barValue >= 0.0f ? 30.0f : -30.0f;
if (m_graph->valueAxis()->reversed())
endAngleY *= -1.0f;Proxy personalizado para datos
Al activar el modo de datos « Custom Proxy Data », se utilizan un conjunto de datos personalizado y el proxy correspondiente.
Define un conjunto de datos sencillo y flexible, ` VariantDataSet`, en el que cada elemento de datos es una lista de variantes. Cada elemento puede tener varios valores, identificados por su índice en la lista. En este caso, el conjunto de datos almacena datos de precipitaciones mensuales, donde el valor del índice cero es el año, el del índice uno es el mes y el del índice dos es la cantidad de precipitaciones de ese mes.
El proxy personalizado es similar a los proxies basados en «itemmodel» que ofrece Qt Data Visualization, y requiere una asignación para interpretar los datos.
VariantDataSet
Define los elementos de datos como objetos de QVariantList. Añade funcionalidad para borrar el conjunto de datos y consultar una referencia a los datos contenidos en el conjunto. Además, añade señales que se emitan cuando se añadan datos o se borre el conjunto:
using VariantDataItem = QVariantList;
using VariantDataItemList = QList<VariantDataItem *>;
...
void clear();
int addItem(VariantDataItem *item);
int addItems(VariantDataItemList *itemList);
const VariantDataItemList &itemList() const;
Q_SIGNALS:
void itemsAdded(int index, int count);
void dataCleared();VariantBarDataProxy
Crea una subclase de ` VariantBarDataProxy ` a partir de `QBarDataProxy` y proporciona una API sencilla con métodos getter y setter para el conjunto de datos y la asignación:
class VariantBarDataProxy : public QBarDataProxy
...
// Doesn't gain ownership of the dataset, but does connect to it to listen for data changes.
void setDataSet(VariantDataSet *newSet);
VariantDataSet *dataSet();
// Map key (row, column, value) to value index in data item (VariantItem).
// Doesn't gain ownership of mapping, but does connect to it to listen for mapping changes.
// Modifying mapping that is set to proxy will trigger dataset re-resolving.
void setMapping(VariantBarDataMapping *mapping);
VariantBarDataMapping *mapping();El proxy supervisa los cambios en el conjunto de datos y la asignación, y vuelve a resolver el conjunto de datos si se detecta algún cambio. No se trata de una implementación especialmente eficiente, ya que cualquier cambio provocará que se vuelva a resolver todo el conjunto de datos, pero eso no supone un problema para este ejemplo.
En el método ` resolveDataSet() `, ordena los valores de datos de la variante en filas y columnas según la asignación. Esto es muy similar a cómo gestiona la asignación `QItemModelBarDataProxy`, salvo que aquí se utilizan índices de lista en lugar de roles del modelo de elemento. Una vez ordenados los valores, genera un ` QBarDataArray ` a partir de ellos y llama al método ` resetArray() ` de la clase padre:
void VariantBarDataProxy::resolveDataSet()
{
// If we have no data or mapping, or the categories are not defined, simply clear the array
if (m_dataSet.isNull() || m_mapping.isNull() || !m_mapping->rowCategories().size()
|| !m_mapping->columnCategories().size()) {
resetArray(nullptr);
return;
}
const VariantDataItemList &itemList = m_dataSet->itemList();
int rowIndex = m_mapping->rowIndex();
int columnIndex = m_mapping->columnIndex();
int valueIndex = m_mapping->valueIndex();
const QStringList &rowList = m_mapping->rowCategories();
const QStringList &columnList = m_mapping->columnCategories();
// Sort values into rows and columns
using ColumnValueMap = QHash<QString, float>;
QHash <QString, ColumnValueMap> itemValueMap;
for (const VariantDataItem *item : itemList) {
itemValueMap[item->at(rowIndex).toString()][item->at(columnIndex).toString()]
= item->at(valueIndex).toReal();
}
// Create a new data array in format the parent class understands
auto *newProxyArray = new QBarDataArray;
for (const QString &rowKey : rowList) {
auto *newProxyRow = new QBarDataRow(columnList.size());
for (qsizetype i = 0; i < columnList.size(); ++i)
(*newProxyRow)[i].setValue(itemValueMap[rowKey][columnList.at(i)]);
newProxyArray->append(newProxyRow);
}
// Finally, reset the data array in the parent class
resetArray(newProxyArray);
}VariantBarDataMapping
Almacena la información de asignación entre los índices de los elementos de datos de ` VariantDataSet ` y las filas, columnas y valores de ` QBarDataArray ` en ` VariantBarDataMapping`. Contiene las listas de filas y columnas que deben incluirse en los datos resueltos:
Q_PROPERTY(int rowIndex READ rowIndex WRITE setRowIndex NOTIFY rowIndexChanged)
Q_PROPERTY(int columnIndex READ columnIndex WRITE setColumnIndex NOTIFY columnIndexChanged)
Q_PROPERTY(int valueIndex READ valueIndex WRITE setValueIndex NOTIFY valueIndexChanged)
Q_PROPERTY(QStringList rowCategories READ rowCategories WRITE setRowCategories NOTIFY rowCategoriesChanged)
Q_PROPERTY(QStringList columnCategories READ columnCategories WRITE setColumnCategories NOTIFY columnCategoriesChanged)
...
explicit VariantBarDataMapping(int rowIndex, int columnIndex, int valueIndex,
const QStringList &rowCategories,
const QStringList &columnCategories);
...
void remap(int rowIndex, int columnIndex, int valueIndex,
const QStringList &rowCategories,
const QStringList &columnCategories);
...
void mappingChanged();La forma principal de utilizar un objeto ` VariantBarDataMapping ` es proporcionar las correspondencias en el constructor, aunque se puede utilizar el método ` remap() ` para establecerlas posteriormente, ya sea de forma individual o todas juntas. Emite una señal si cambia la correspondencia. El resultado es una versión simplificada de la funcionalidad de correspondencia de `QItemModelBarDataProxy`, adaptada para funcionar con listas de variantes en lugar de modelos de elementos.
RainfallData
Gestiona la configuración de `QBar3DSeries` con el proxy personalizado en la clase ` RainfallData `:
m_proxy = new VariantBarDataProxy;
m_series = new QBar3DSeries(m_proxy);Rellena el conjunto de datos de la variante en el método ` addDataSet() `:
void RainfallData::addDataSet()
{
// Crea un nuevo conjunto de datos de variantes y una lista de elementos de datos
m_dataSet = new VariantDataSet;
auto *itemList = new VariantDataItemList;
// Lee los datos de un archivo de datos y los añade a la lista de elementos de datos
QFile dataFile(":/data/raindata.txt");
if (dataFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
QTextStream stream(&dataFile);
while (!stream.atEnd()) {
QString line = stream.readLine();
if (line.startsWith('#')) // Ignorar comentarios
continue;
const auto strList = QStringView{line}.split(',', Qt::SkipEmptyParts);
// Cada línea contiene tres datos: año, mes y valor de precipitación
if (strList.size() < 3) {
qWarning() << "Invalid row read from data:" << line;
continuar;
}
// Almacenar el año y el mes como cadenas, y el valor de las precipitaciones como número de tipo double
// en un elemento de datos de tipo «Variant» y añadir dicho elemento a la lista de elementos.
auto *newItem = new VariantDataItem;
for (int i = 0; i < 2;++i)
newItem->append(strList.at(i).trimmed().toString());
newItem->append(strList.at(2).trimmed().toDouble());
itemList->append(newItem);
}
} else {
qWarning() << "Unable to open data file:" << dataFile.fileName();
}
...Añade el conjunto de datos al proxy personalizado y configura la asignación:
// Add items to the data set and set it to the proxy
m_dataSet->addItems(itemList);
m_proxy->setDataSet(m_dataSet);
// Create new mapping for the data and set it to the proxy
m_mapping = new VariantBarDataMapping(0, 1, 2, m_years, m_numericMonths);
m_proxy->setMapping(m_mapping);Por último, añade una función para obtener la serie creada y mostrarla:
QBar3DSeries *customSeries() { return m_series; }Gráfico de puntos
En la pestaña « Scatter Graph », crea un gráfico de dispersión en 3D utilizando Q3DScatter. El ejemplo muestra cómo:
- Configurar el gráfico Q3DScatter
- Utilizar QScatterDataProxy para establecer los datos del gráfico
- Crear un controlador de entrada personalizado extendiendo Q3DInputHandler
Para la creación de aplicaciones básicas, consulta «Gráfico de barras».
Configuración del gráfico de dispersión
En primer lugar, configura algunas propiedades visuales del gráfico en el constructor de ` ScatterDataModifier`:
m_graph->activeTheme()->setType(Q3DTheme::ThemeStoneMoss);
m_graph->setShadowQuality(QAbstract3DGraph::ShadowQualitySoftHigh);
m_graph->scene()->activeCamera()->setCameraPreset(Q3DCamera::CameraPresetFront);
m_graph->scene()->activeCamera()->setZoomLevel(80.f);Ninguna de estas opciones es obligatoria, pero sirven para anular los valores predeterminados del gráfico. Puedes comprobar cómo queda con los valores predeterminados comentando el bloque anterior.
A continuación, crea un `QScatterDataProxy` y la `QScatter3DSeries` asociada. Establece un formato de etiqueta personalizado y el suavizado de malla para la serie, y añádela al gráfico:
auto *proxy = new QScatterDataProxy;
auto *series = new QScatter3DSeries(proxy);
series->setItemLabelFormat(u"@xTitle: @xLabel @yTitle: @yLabel @zTitle: @zLabel"_s);
series->setMeshSmooth(m_smooth);
m_graph->addSeries(series);Añadir datos de dispersión
Lo último que hay que hacer en el constructor de ` ScatterDataModifier ` es añadir datos al gráfico:
addData();La adición de datos propiamente dicha se realiza en el método ` addData() `. En primer lugar, configura los ejes:
m_graph->axisX()->setTitle("X");
m_graph->axisY()->setTitle("Y");
m_graph->axisZ()->setTitle("Z");Esto también se podría hacer en el constructor de ` ScatterDataModifier`. Al hacerlo aquí, el constructor resulta más sencillo y la configuración de los ejes queda cerca de los datos.
A continuación, crea una matriz de datos y rellénala:
auto *dataArray = new QScatterDataArray;
dataArray->reserve(m_itemCount);
...
const float limit = qSqrt(m_itemCount) / 2.0f;
for (int i = -limit; i < limit; ++i) {
for (int j = -limit; j < limit; ++j) {
const float x = float(i) + 0.5f;
const float y = qCos(qDegreesToRadians(float(i * j) / m_curveDivider));
const float z = float(j) + 0.5f;
dataArray->append(QScatterDataItem({x, y, z}));
}
}Por último, indica al proxy que empiece a utilizar los datos que le hemos proporcionado:
m_graph->seriesList().at(0)->dataProxy()->resetArray(dataArray);Ahora, el gráfico contiene los datos y está listo para su uso. Para obtener información sobre cómo añadir widgets para controlar el gráfico, consulta «Uso de widgets para controlar el gráfico».
Sustitución del manejo de entradas predeterminado
Inicialice ` m_inputHandler ` en el constructor con un puntero a la instancia del gráfico de dispersión:
m_inputHandler(new AxesInputHandler(scatter))Sustituya el mecanismo de gestión de entradas predeterminado estableciendo el gestor de entradas activo de `Q3DScatter` como ` AxesInputHandler`, que implementa el comportamiento personalizado:
// Give ownership of the handler to the graph and make it the active handler
m_graph->setActiveInputHandler(m_inputHandler);El gestor de entradas necesita acceder a los ejes del gráfico, así que pásaselos:
// Give our axes to the input handler
m_inputHandler->setAxes(m_graph->axisX(), m_graph->axisZ(), m_graph->axisY());Ampliación del manejo de eventos del ratón
En primer lugar, haz que el controlador de entrada personalizado herede de `Q3DInputHandler` en lugar de `QAbstract3DInputHandler` para conservar toda la funcionalidad del manejo de entradas predeterminado y añadir la funcionalidad personalizada sobre ella:
class AxesInputHandler : public Q3DInputHandlerEmpieza a ampliar la funcionalidad predeterminada reimplementando algunos de los eventos del ratón. En primer lugar, amplía ` mousePressEvent`. Añádele un indicador ` m_mousePressed ` para el botón izquierdo del ratón y conserva el resto de la funcionalidad predeterminada:
void AxesInputHandler::mousePressEvent(QMouseEvent *event, const QPoint &mousePos)
{
Q3DInputHandler::mousePressEvent(event, mousePos);
if (Qt::LeftButton == event->button())
m_mousePressed = true;
}A continuación, modifica mouseReleaseEvent para borrar el indicador y restablecer el estado interno:
void AxesInputHandler::mouseReleaseEvent(QMouseEvent *event, const QPoint &mousePos)
{
Q3DInputHandler::mouseReleaseEvent(event, mousePos);
m_mousePressed = false;
m_state = StateNormal;
}A continuación, modifica mouseMoveEvent. Comprueba si el indicador « m_mousePressed » está en « true » y si el estado interno es distinto de « StateNormal ». Si es así, establece las posiciones de entrada para los cálculos de la distancia de movimiento del ratón y llama a la función de arrastre de ejes (consulta «Implementación del arrastre de ejes » para obtener más detalles):
void AxesInputHandler::mouseMoveEvent(QMouseEvent *event, const QPoint &mousePos)
{
// Check if we're trying to drag axis label
if (m_mousePressed && m_state != StateNormal) {
setPreviousInputPos(inputPosition());
setInputPosition(mousePos);
handleAxisDragging();
} else {
Q3DInputHandler::mouseMoveEvent(event, mousePos);
}
}Implementación del arrastre de ejes
En primer lugar, empieza a escuchar la señal de selección procedente del gráfico. Hazlo en el constructor y conéctala al método « handleElementSelected »:
// Connect to the item selection signal from graph
connect(graph, &QAbstract3DGraph::selectedElementChanged, this,
&AxesInputHandler::handleElementSelected);En handleElementSelected, comprueba el tipo de selección y establece el estado interno en función de ello:
switch (type) {
case QAbstract3DGraph::ElementAxisXLabel:
m_state = StateDraggingX;
break;
case QAbstract3DGraph::ElementAxisYLabel:
m_state = StateDraggingY;
break;
case QAbstract3DGraph::ElementAxisZLabel:
m_state = StateDraggingZ;
break;
default:
m_state = StateNormal;
break;
}La lógica de arrastre propiamente dicha se implementa en el método ` handleAxisDragging `, al que se llama desde ` mouseMoveEvent` si se cumplen las condiciones necesarias:
// Check if we're trying to drag axis label
if (m_mousePressed && m_state != StateNormal) {En handleAxisDragging, primero se obtiene la orientación de la escena a partir de la cámara activa:
// Get scene orientation from active camera
float xRotation = scene()->activeCamera()->xRotation();
float yRotation = scene()->activeCamera()->yRotation();A continuación, calcula los modificadores para la dirección del movimiento del ratón en función de la orientación:
// Calculate directional drag multipliers based on rotation
float xMulX = qCos(qDegreesToRadians(xRotation));
float xMulY = qSin(qDegreesToRadians(xRotation));
float zMulX = qSin(qDegreesToRadians(xRotation));
float zMulY = qCos(qDegreesToRadians(xRotation));A continuación, calcula el movimiento del ratón y modifícalo en función de la rotación en el eje y de la cámara:
// Get the drag amount
QPoint move = inputPosition() - previousInputPos();
// Flip the effect of y movement if we're viewing from below
float yMove = (yRotation < 0) ? -move.y() : move.y();A continuación, aplica la distancia recorrida al eje correcto:
// Adjust axes
switch (m_state) {
case StateDraggingX:
distance = (move.x() * xMulX - yMove * xMulY) / m_speedModifier;
m_axisX->setRange(m_axisX->min() - distance, m_axisX->max() - distance);
break;
case StateDraggingZ:
distance = (move.x() * zMulX + yMove * zMulY) / m_speedModifier;
m_axisZ->setRange(m_axisZ->min() + distance, m_axisZ->max() + distance);
break;
case StateDraggingY:
distance = move.y() / m_speedModifier; // No need to use adjusted y move here
m_axisY->setRange(m_axisY->min() + distance, m_axisY->max() + distance);
break;
default:
break;
}Por último, añade una función para configurar la velocidad de arrastre:
inline void setDragSpeedModifier(float modifier) { m_speedModifier = modifier; }Esto es necesario, ya que la distancia de movimiento del ratón es absoluta en coordenadas de pantalla, y hay que ajustarla al rango del eje. Cuanto mayor sea el valor, más lento será el arrastre. Ten en cuenta que, en este ejemplo, el nivel de zoom de la escena no se tiene en cuenta a la hora de determinar la velocidad de arrastre, por lo que notarás cambios en el ajuste del rango a medida que modifiques el nivel de zoom.
También podrías ajustar el modificador automáticamente en función del rango del eje y del nivel de zoom de la cámara.
Gráfico de superficie
En la pestaña « Surface Graph », crea un gráfico de superficie en 3D utilizando Q3DSurface. El ejemplo muestra cómo:
- Configurar un QSurfaceDataProxy básico y establecer los datos correspondientes.
- Utilizar QHeightMapSurfaceDataProxy para mostrar mapas de altura en 3D.
- Utilizar datos topográficos para crear mapas de altura en 3D.
- Utilizar tres modos de selección diferentes para estudiar el gráfico.
- Utiliza rangos de ejes para mostrar partes seleccionadas del gráfico.
- Establece un degradado de superficie personalizado.
- Añade elementos y etiquetas personalizados con QCustom3DItem y QCustom3DLabel.
- Utiliza un controlador de entrada personalizado para habilitar el zoom y el desplazamiento.
- Resalta un área de la superficie.
Para la creación de aplicaciones básicas, consulta «Gráfico de barras».
Superficie sencilla con datos generados
En primer lugar, instancie un nuevo QSurfaceDataProxy y asócielo a un nuevo QSurface3DSeries:
m_sqrtSinProxy = new QSurfaceDataProxy();
m_sqrtSinSeries = new QSurface3DSeries(m_sqrtSinProxy);A continuación, rellena el proxy con datos sencillos de raíces cuadradas y ondas sinusoidales. Crea una nueva instancia de ` QSurfaceDataArray ` y añádele elementos ` QSurfaceDataRow `. Establece el ` QSurfaceDataArray ` creado como matriz de datos para el `QSurfaceDataProxy` llamando a ` resetArray()`.
auto *dataArray = new QSurfaceDataArray;
dataArray->reserve(sampleCountZ);
for (int i = 0 ; i < sampleCountZ ; ++i) {
auto *newRow = new QSurfaceDataRow;
newRow->reserve(sampleCountX);
// Keep values within range bounds, since just adding step can cause minor drift due
// to the rounding errors.
float z = qMin(sampleMax, (i * stepZ + sampleMin));
for (int j = 0; j < sampleCountX; ++j) {
float x = qMin(sampleMax, (j * stepX + sampleMin));
float R = qSqrt(z * z + x * x) + 0.01f;
float y = (qSin(R) / R + 0.24f) * 1.61f;
newRow->append(QSurfaceDataItem({x, y, z}));
}
dataArray->append(newRow);
}
m_sqrtSinProxy->resetArray(dataArray);Datos de mapas de altura de varias series
Crea el mapa de altitud instanciando un `QHeightMapSurfaceDataProxy` con un ` QImage ` que contenga los datos de altitud. Utiliza ` QHeightMapSurfaceDataProxy::setValueRanges()` para definir el rango de valores del mapa. En el ejemplo, el mapa corresponde a una posición imaginaria comprendida entre 34,0° N y 40,0° N, y entre 18,0° E y 24,0° E. Estos valores se utilizan para situar el mapa en los ejes.
// Create the first surface layer
QImage heightMapImageOne(":/data/layer_1.png");
m_heightMapProxyOne = new QHeightMapSurfaceDataProxy(heightMapImageOne);
m_heightMapSeriesOne = new QSurface3DSeries(m_heightMapProxyOne);
m_heightMapSeriesOne->setItemLabelFormat(u"(@xLabel, @zLabel): @yLabel"_s);
m_heightMapProxyOne->setValueRanges(34.f, 40.f, 18.f, 24.f);Añade las demás capas de superficie de la misma manera, creando un proxy y una serie para ellas a partir de imágenes de mapas de altitud.
Datos del mapa topográfico
Los datos topográficos se obtienen del Servicio Nacional de Catastro de Finlandia. Este organismo ofrece un producto denominado « Elevation Model 2 m », que resulta adecuado para este ejemplo. Los datos topográficos corresponden a la cordillera de Levi. La precisión de los datos supera con creces las necesidades, por lo que se comprimen y se codifican en un archivo PNG. El valor de altura de los datos ASCII originales se codifica en formato RGB utilizando un multiplicador, como verás más adelante en un fragmento de código. El multiplicador se calcula dividiendo el valor máximo de 24 bits por la altura del punto más alto de Finlandia.
QHeightMapSurfaceDataProxy solo convierte valores de un byte. Para aprovechar la mayor precisión de los datos del Servicio Nacional de Catastro de Finlandia, lee los datos del archivo PNG y descódalos en QSurface3DSeries.
En primer lugar, define el multiplicador de codificación:
// Value used to encode height data as RGB value on PNG file
const float packingFactor = 11983.f;A continuación, realiza la decodificación propiamente dicha:
QImage heightMapImage(file);
uchar *bits = heightMapImage.bits();
int imageHeight = heightMapImage.height();
int imageWidth = heightMapImage.width();
int widthBits = imageWidth * 4;
float stepX = width / float(imageWidth);
float stepZ = height / float(imageHeight);
auto *dataArray = new QSurfaceDataArray;
dataArray->reserve(imageHeight);
for (int i = 0; i < imageHeight; ++i) {
int p = i * widthBits;
float z = height - float(i) * stepZ;
auto *newRow = new QSurfaceDataRow;
newRow->reserve(imageWidth);
for (int j = 0; j < imageWidth; ++j) {
uchar aa = bits[p + 0];
uchar rr = bits[p + 1];
uchar gg = bits[p + 2];
uint color = uint((gg << 16) + (rr << 8) + aa);
float y = float(color) / packingFactor;
newRow->append(QSurfaceDataItem({float(j) * stepX, y, z}));
p += 4;
}
dataArray->append(newRow);
}
dataProxy()->resetArray(dataArray);Ahora, el proxy puede utilizar los datos.
Selección del conjunto de datos
Para mostrar diferentes proxies, Surface Graph dispone de tres botones de opción que permiten cambiar entre las series.
Con « Sqrt & Sin », se activa la serie generada de forma sencilla. En primer lugar, configura los elementos decorativos, como habilitar la cuadrícula para la superficie y seleccionar el modo de sombreado plano. A continuación, define el formato de las etiquetas de los ejes y los rangos de valores. Activa la rotación automática de las etiquetas para mejorar su legibilidad en ángulos de cámara bajos. Por último, asegúrate de que se añade la serie correcta al gráfico y de que las demás no aparecen:
m_sqrtSinSeries->setDrawMode(QSurface3DSeries::DrawSurfaceAndWireframe);
m_sqrtSinSeries->setFlatShadingEnabled(true);
m_graph->axisX()->setLabelFormat("%.2f");
m_graph->axisZ()->setLabelFormat("%.2f");
m_graph->axisX()->setRange(sampleMin, sampleMax);
m_graph->axisY()->setRange(0.f, 2.f);
m_graph->axisZ()->setRange(sampleMin, sampleMax);
m_graph->axisX()->setLabelAutoRotation(30.f);
m_graph->axisY()->setLabelAutoRotation(90.f);
m_graph->axisZ()->setLabelAutoRotation(30.f);
m_graph->removeSeries(m_heightMapSeriesOne);
m_graph->removeSeries(m_heightMapSeriesTwo);
m_graph->removeSeries(m_heightMapSeriesThree);
m_graph->removeSeries(m_topography);
m_graph->removeSeries(m_highlight);
m_graph->addSeries(m_sqrtSinSeries);Con « Multiseries Height Map », se activan las series del mapa de altitud y se desactivan las demás. El ajuste automático del rango del eje Y funciona bien para la superficie del mapa de altitud, así que asegúrate de que esté configurado.
m_graph->axisY()->setAutoAdjustRange(true);Con Textured Topography, la serie topográfica está activada y las demás, desactivadas. Activa un controlador de entrada personalizado para esta serie, a fin de poder resaltar áreas en ella:
m_graph->setActiveInputHandler(m_customInputHandler);Consulte «Utilizar un controlador de entrada personalizado para habilitar el zoom y el desplazamiento» para obtener información sobre el controlador de entrada personalizado para este conjunto de datos.
Modos de selección
Los tres modos de selección compatibles con Q3DSurface se pueden utilizar con botones de opción. Para activar el modo seleccionado o desactivarlo, añade los siguientes métodos en línea:
void toggleModeNone() { m_graph->setSelectionMode(QAbstract3DGraph::SelectionNone); }
void toggleModeItem() { m_graph->setSelectionMode(QAbstract3DGraph::SelectionItem); }
void toggleModeSliceRow() { m_graph->setSelectionMode(QAbstract3DGraph::SelectionItemAndRow
| QAbstract3DGraph::SelectionSlice
| QAbstract3DGraph::SelectionMultiSeries); }
void toggleModeSliceColumn() { m_graph->setSelectionMode(QAbstract3DGraph::SelectionItemAndColumn
| QAbstract3DGraph::SelectionSlice
| QAbstract3DGraph::SelectionMultiSeries); }Añade los indicadores « QAbstract3DGraph::SelectionSlice » y « QAbstract3DGraph::SelectionMultiSeries » para los modos de selección de filas y columnas, con el fin de permitir la selección de un corte en todas las series visibles del gráfico simultáneamente.
Rangos de los ejes para analizar el gráfico
El ejemplo cuenta con cuatro controles deslizantes para ajustar los valores mínimo y máximo de los ejes X y Z. Al seleccionar el proxy, estos controles deslizantes se ajustan para que coincidan con los rangos de los ejes del conjunto de datos actual:
// Reset range sliders for Sqrt & Sin
m_rangeMinX = sampleMin;
m_rangeMinZ = sampleMin;
m_stepX = (sampleMax - sampleMin) / float(sampleCountX - 1);
m_stepZ = (sampleMax - sampleMin) / float(sampleCountZ - 1);
m_axisMinSliderX->setMinimum(0);
m_axisMinSliderX->setMaximum(sampleCountX - 2);
m_axisMinSliderX->setValue(0);
m_axisMaxSliderX->setMinimum(1);
m_axisMaxSliderX->setMaximum(sampleCountX - 1);
m_axisMaxSliderX->setValue(sampleCountX - 1);
m_axisMinSliderZ->setMinimum(0);
m_axisMinSliderZ->setMaximum(sampleCountZ - 2);
m_axisMinSliderZ->setValue(0);
m_axisMaxSliderZ->setMinimum(1);
m_axisMaxSliderZ->setMaximum(sampleCountZ - 1);
m_axisMaxSliderZ->setValue(sampleCountZ - 1);Añade compatibilidad para configurar el rango del eje X desde los controles del widget en el gráfico:
void SurfaceGraphModifier::setAxisXRange(float min, float max)
{
m_graph->axisX()->setRange(min, max);
}Añadir compatibilidad con el rango del eje Z de la misma manera.
Degradados de superficie personalizados
Con el conjunto de datos « Sqrt & Sin », se pueden utilizar gradientes de superficie personalizados mediante dos botones. Define el gradiente en QLinearGradient, donde se establecen los colores deseados. Además, cambia el estilo de color a Q3DTheme::ColorStyleRangeGradient para utilizar el gradiente.
QLinearGradient gr;
gr.setColorAt(0.f, Qt::black);
gr.setColorAt(0.33f, Qt::blue);
gr.setColorAt(0.67f, Qt::red);
gr.setColorAt(1.f, Qt::yellow);
m_sqrtSinSeries->setBaseGradient(gr);
m_sqrtSinSeries->setColorStyle(Q3DTheme::ColorStyleRangeGradient);Añadir mallas personalizadas a la aplicación
Añade los archivos de malla a CMakeLists.txt para la compilación con CMake:
set(graphgallery_resource_files
...
"data/oilrig.obj"
"data/pipe.obj"
"data/refinery.obj"
...
)
qt6_add_resources(graphgallery "graphgallery"
PREFIX
"/"
FILES
${graphgallery_resource_files}
)Además, añádelos al archivo de recursos qrc para utilizarlos con qmake:
<RCC>
<qresource prefix="/">
...
<file>data/refinery.obj</file>
<file>data/oilrig.obj</file>
<file>data/pipe.obj</file>
...
</qresource>
</RCC>Añadir un elemento personalizado a un gráfico
Con el conjunto de datos « Multiseries Height Map », los elementos personalizados se insertan en el gráfico y se pueden activar o desactivar mediante casillas de selección. También se pueden controlar otras propiedades visuales con otro conjunto de casillas de selección, como la transparencia de las dos capas superiores y el resaltado de la capa inferior.
Empieza creando un pequeño archivo « QImage ». Rellénalo con un único color para utilizarlo como color del objeto personalizado:
A continuación, especifica la posición del elemento en una variable. Esa posición se puede utilizar después para eliminar el elemento correcto del gráfico:
QVector3D positionOne = QVector3D(39.f, 77.f, 19.2f);A continuación, crea un nuevo QCustom3DItem con todos los parámetros:
auto *item = new QCustom3DItem(":/data/oilrig.obj", positionOne,
QVector3D(0.025f, 0.025f, 0.025f),
QQuaternion::fromAxisAndAngle(0.f, 1.f, 0.f, 45.f),
color);Por último, añade el elemento al gráfico:
m_graph->addCustomItem(item);Añadir una etiqueta personalizada a un gráfico
Añadir una etiqueta personalizada es muy similar a añadir un elemento personalizado. Para la etiqueta no se necesita una malla personalizada, sino solo una instancia de QCustom3DLabel:
auto *label = new QCustom3DLabel();
label->setText("Oil Rig One");
label->setPosition(positionOneLabel);
label->setScaling(QVector3D(1.f, 1.f, 1.f));
m_graph->addCustomItem(label);Eliminar un elemento personalizado de un gráfico
Para eliminar un elemento específico del gráfico, llama a ` removeCustomItemAt() ` con la posición del elemento:
m_graph->removeCustomItemAt(positionOne);Nota: Al eliminar un elemento personalizado del gráfico, también se borra el objeto. Si deseas conservar el elemento, utiliza en su lugar el método ` releaseCustomItem() `.
Textura para una serie de superficies
Con el conjunto de datos ` Textured Topography `, crea una textura de mapa para utilizarla con el mapa de altitud topográfico.
Establece una imagen que se utilizará como textura en una superficie con QSurface3DSeries::setTextureFile(). Añade una casilla de selección para controlar si la textura está activada o no, y un controlador para reaccionar al estado de la casilla:
void SurfaceGraphModifier::toggleSurfaceTexture(bool enable)
{
if (enable)
m_topography->setTextureFile(":/data/maptexture.jpg");
else
m_topography->setTextureFile("");
}La imagen de este ejemplo se lee de un archivo JPG. Si se establece un archivo vacío con este método, se borra la textura y la superficie utiliza los degradados o colores del tema.
Utilizar un controlador de entrada personalizado para habilitar el zoom y el desplazamiento
Con el conjunto de datos ` Textured Topography `, crea un controlador de entrada personalizado para resaltar la selección en el gráfico y permitir el desplazamiento por el gráfico.
La implementación del desplazamiento es similar a la que se muestra en «Implementación del arrastre de ejes». La diferencia es que, en este ejemplo, solo se siguen los ejes X y Z y no se permite arrastrar la superficie fuera del gráfico. Para limitar el arrastre, sigue los límites de los ejes y no realices ninguna acción si se sale del gráfico:
case StateDraggingX:
distance = (move.x() * xMulX - move.y() * xMulY) * m_speedModifier;
m_axisXMinValue -= distance;
m_axisXMaxValue -= distance;
if (m_axisXMinValue < m_areaMinValue) {
float dist = m_axisXMaxValue - m_axisXMinValue;
m_axisXMinValue = m_areaMinValue;
m_axisXMaxValue = m_axisXMinValue + dist;
}
if (m_axisXMaxValue > m_areaMaxValue) {
float dist = m_axisXMaxValue - m_axisXMinValue;
m_axisXMaxValue = m_areaMaxValue;
m_axisXMinValue = m_axisXMaxValue - dist;
}
m_axisX->setRange(m_axisXMinValue, m_axisXMaxValue);
break;Para el zoom, captura el evento « wheelEvent » y ajusta los rangos de los ejes X e Y según el valor delta en « QWheelEvent ». Ajusta el eje Y de modo que la relación de aspecto entre el eje Y y el plano XZ se mantenga igual. Esto evita que se obtenga un gráfico en el que la altura resulte exagerada:
void CustomInputHandler::wheelEvent(QWheelEvent *event)
{
float delta = float(event->angleDelta().y());
m_axisXMinValue += delta;
m_axisXMaxValue -= delta;
m_axisZMinValue += delta;
m_axisZMaxValue -= delta;
checkConstraints();
float y = (m_axisXMaxValue - m_axisXMinValue) * m_aspectRatio;
m_axisX->setRange(m_axisXMinValue, m_axisXMaxValue);
m_axisY->setRange(100.f, y);
m_axisZ->setRange(m_axisZMinValue, m_axisZMaxValue);
}A continuación, añade algunos límites al nivel de zoom, para que no se acerque demasiado ni se aleje demasiado de la superficie. Por ejemplo, si el valor del eje X desciende por debajo del límite permitido, es decir, si el zoom se aleja demasiado, el valor se establece en el mínimo permitido. Si el rango va a descender por debajo del mínimo del rango, se ajustan ambos extremos del eje para que el rango se mantenga en el límite:
if (m_axisXMinValue < m_areaMinValue)
m_axisXMinValue = m_areaMinValue;
if (m_axisXMaxValue > m_areaMaxValue)
m_axisXMaxValue = m_areaMaxValue;
// Don't allow too much zoom in
if ((m_axisXMaxValue - m_axisXMinValue) < m_axisXMinRange) {
float adjust = (m_axisXMinRange - (m_axisXMaxValue - m_axisXMinValue)) / 2.f;
m_axisXMinValue -= adjust;
m_axisXMaxValue += adjust;
}Resaltar un área de la superficie
Para implementar un resaltado que se muestre en la superficie, crea una copia de la serie y añade un desplazamiento al valor de y. En este ejemplo, la clase HighlightSeries implementa la creación de la copia en su método handlePositionChange.
En primer lugar, pasa a ` HighlightSeries ` el puntero a la serie original y, a continuación, empieza a escuchar la señal ` QSurface3DSeries::selectedPointChanged `:
void HighlightSeries::setTopographicSeries(TopographicSeries *series)
{
m_topographicSeries = series;
m_srcWidth = m_topographicSeries->dataProxy()->array()->at(0)->size();
m_srcHeight = m_topographicSeries->dataProxy()->array()->size();
QObject::connect(m_topographicSeries, &QSurface3DSeries::selectedPointChanged,
this, &HighlightSeries::handlePositionChange);
}Cuando se active la señal, comprueba que la posición sea válida. A continuación, calcula los rangos del área copiada y comprueba que se mantengan dentro de los límites. Por último, rellena la matriz de datos de la serie de resaltado con el rango de la matriz de datos de la serie de topografía:
void HighlightSeries::handlePositionChange(const QPoint &position)
{
m_position = position;
if (position == invalidSelectionPosition()) {
setVisible(false);
return;
}
int halfWidth = m_width / 2;
int halfHeight = m_height / 2;
int startX = position.y() - halfWidth;
if (startX < 0 )
startX = 0;
int endX = position.y() + halfWidth;
if (endX > (m_srcWidth - 1))
endX = m_srcWidth - 1;
int startZ = position.x() - halfHeight;
if (startZ < 0 )
startZ = 0;
int endZ = position.x() + halfHeight;
if (endZ > (m_srcHeight - 1))
endZ = m_srcHeight - 1;
QSurfaceDataProxy *srcProxy = m_topographicSeries->dataProxy();
const QSurfaceDataArray &srcArray = *srcProxy->array();
auto *dataArray = new QSurfaceDataArray;
dataArray->reserve(endZ - startZ);
for (int i = startZ; i < endZ; ++i) {
auto *newRow = new QSurfaceDataRow;
newRow->reserve(endX - startX);
QSurfaceDataRow *srcRow = srcArray.at(i);
for (int j = startX; j < endX; ++j) {
QVector3D pos = srcRow->at(j).position();
pos.setY(pos.y() + 0.1f);
newRow->append(QSurfaceDataItem(pos));
}
dataArray->append(newRow);
}
dataProxy()->resetArray(dataArray);
setVisible(true);
}Una serie «Gradient to the Highlight»
Dado que la serie « HighlightSeries » es de tipo QSurface3DSeries, están disponibles todos los métodos de decoración que puede tener una serie. En este ejemplo, añade un degradado para resaltar la elevación. Dado que el estilo de degradado adecuado depende del rango del eje Y y que cambiamos dicho rango al hacer zoom, es necesario ajustar las posiciones de color del degradado a medida que cambia el rango. Para ello, define valores proporcionales para las posiciones de color del degradado:
const float darkRedPos = 1.f;
const float redPos = 0.8f;
const float yellowPos = 0.6f;
const float greenPos = 0.4f;
const float darkGreenPos = 0.2f;La modificación del degradado se realiza en el método ` handleGradientChange `, así que conéctalo para que reaccione a los cambios en el eje Y:
QObject::connect(m_graph->axisY(), &QValue3DAxis::maxChanged,
m_highlight, &HighlightSeries::handleGradientChange);Cuando se produzca un cambio en el valor máximo del eje Y, calcula las nuevas posiciones de color del degradado:
void HighlightSeries::handleGradientChange(float value)
{
float ratio = m_minHeight / value;
QLinearGradient gr;
gr.setColorAt(0.f, Qt::black);
gr.setColorAt(darkGreenPos * ratio, Qt::darkGreen);
gr.setColorAt(greenPos * ratio, Qt::green);
gr.setColorAt(yellowPos * ratio, Qt::yellow);
gr.setColorAt(redPos * ratio, Qt::red);
gr.setColorAt(darkRedPos * ratio, Qt::darkRed);
setBaseGradient(gr);
setColorStyle(Q3DTheme::ColorStyleRangeGradient);
}Contenido del ejemplo
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.