customitemdatamodifier.cpp

Enable keyboard shortcuts

// Copyright (C) 2025 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

//

#include "customitemdatamodifier.h"

#include "scatterdatamodifier.h"

#include <QtGraphs/qscatterdataproxy.h>

#include <QtGraphs/qvalue3daxis.h>

#include <QtGraphs/q3dscene.h>

#include <QtGraphs/qscatter3dseries.h>

#include <QtGraphs/QCustom3DItem>

#include <QtGui/qquaternion.h>

#include <QtCore/qmath.h>

#include <algorithm>

#include <cstdlib>

CustomItemDataModifier::CustomItemDataModifier(Q3DScatterWidgetItem *scatter)

    : m_graph(scatter),

      m_arrow(new QCustom3DItem),

      m_sphere(new QCustom3DItem),

      m_radius(7.0f)

    m_graph->setShadowQuality(QtGraphs3D::ShadowQuality::None);

    m_graph->setCameraPreset(QtGraphs3D::CameraPreset::Front);

    m_sphere->setParent(m_graph);

    m_sphere->setMeshFile(QStringLiteral(":/mesh/largesphere.mesh"));

    QImage sphereTex = QImage(2, 2, QImage::Format_RGB32);

    sphereTex.fill(QColor(0xff, 0xbb, 0x00));

    m_sphere->setTextureImage(sphereTex);

    m_sphere->setScaling(QVector3D(0.01f, 0.01f, 0.01f));

    m_arrow->setParent(m_graph);

    m_arrow->setMeshFile(QStringLiteral(":/mesh/narrowarrow.mesh"));

    QImage arrowTex = QImage(2, 2, QImage::Format_RGB32);

    arrowTex.fill(QColor(0x00, 0xbb, 0xff));

    m_arrow->setTextureImage(arrowTex);

    m_arrow->setScaling(QVector3D(0.1f, 0.1f, 0.1f));

    m_arrow->setPosition({0,0,0});

    m_graph->addCustomItem(m_arrow);

    m_graph->addCustomItem(m_sphere);

    m_graph->axisX()->setRange(-10, 10);

    m_graph->axisX()->setTitle("X");

    m_graph->axisX()->setTitleVisible(true);

    m_graph->axisY()->setRange(-10, 10);

    m_graph->axisY()->setTitle("Y");

    m_graph->axisY()->setTitleVisible(true);

    m_graph->axisZ()->setRange(-10, 10);

    m_graph->axisZ()->setTitle("Z");

    m_graph->axisZ()->setTitleVisible(true);

    // m_graph->setAspectRatio(1.0);

    m_axisHelpers.reserve(3);

    QCustom3DItem *xAxisHelper = new QCustom3DItem();

    xAxisHelper->setParent(m_graph);

    xAxisHelper->setMeshFile(QStringLiteral(":/mesh/narrowarrow.mesh"));

    xAxisHelper->setScaling({0.1f, 0.1f, 0.1f});

    xAxisHelper->setPosition({2.2f, -1.0f, 2.0f});

    xAxisHelper->setPositionAbsolute(true);

    xAxisHelper->setRotation({0.707f, .0f, 0.f , -0.707f});

    QImage xTex = QImage(2, 2, QImage::Format_RGB32);

    xTex.fill(QColor(0xff, 0x00, 0x00));

    xAxisHelper->setTextureImage(xTex);

    m_graph->addCustomItem(xAxisHelper);

    m_axisHelpers.append(xAxisHelper);

    m_axisHelpers.reserve(3);

    QCustom3DItem *yAxisHelper = new QCustom3DItem();

    yAxisHelper->setParent(m_graph);

    yAxisHelper->setMeshFile(QStringLiteral(":/mesh/narrowarrow.mesh"));

    yAxisHelper->setScaling({0.1f, 0.1f, 0.1f});

    yAxisHelper->setPosition({2.0f, -0.8f, 2.0f});

    yAxisHelper->setPositionAbsolute(true);

    QImage yTex = QImage(2, 2, QImage::Format_RGB32);

    yTex.fill(QColor(0x00, 0xff, 0x00));

    yAxisHelper->setTextureImage(yTex);

    m_graph->addCustomItem(yAxisHelper);

    m_axisHelpers.append(yAxisHelper);

    QCustom3DItem *zAxisHelper = new QCustom3DItem();

    zAxisHelper->setParent(m_graph);

    zAxisHelper->setMeshFile(QStringLiteral(":/mesh/narrowarrow.mesh"));

    zAxisHelper->setScaling({0.1f, 0.1f, 0.1f});

    zAxisHelper->setPosition({2.0f, -1.0f, 2.2f});

    //note: z axis is reversed by default in qt graphs

    zAxisHelper->setRotation({0.707f, 0.707f, .0f, .0f});

    zAxisHelper->setPositionAbsolute(true);

    QImage zTex = QImage(2, 2, QImage::Format_RGB32);

    zTex.fill(QColor(0x00, 0x00, 0xff));

    zAxisHelper->setTextureImage(zTex);

    m_graph->addCustomItem(zAxisHelper);

    m_axisHelpers.append(zAxisHelper);

    //create axis helper

    m_absoluteScaling = m_sphere->isScalingAbsolute();

    m_arrow->setRotationAbsolute(m_absoluteScaling);

    toggleAbsolute(0);

    updatePositions();

    toggleTimer();

    QObject::connect(&m_rotationTimer, &QTimer::timeout, this,

                     &CustomItemDataModifier::updatePositions);

CustomItemDataModifier::~CustomItemDataModifier()

    delete m_graph;

void CustomItemDataModifier::toggleAbsolute(int absolute)

    m_absoluteScaling = bool(absolute);

    qDebug() << absolute;

    m_sphere->setScalingAbsolute(m_absoluteScaling);

    m_arrow->setScalingAbsolute(m_absoluteScaling);

    m_sphere->setPositionAbsolute(m_absoluteScaling);

    m_arrow->setPositionAbsolute(m_absoluteScaling);

    m_arrow->setRotationAbsolute(m_absoluteScaling);

    if (m_absoluteScaling) {

        m_sphere->setScaling(QVector3D(0.01f, 0.01f, 0.01f));

        m_arrow->setScaling(QVector3D(0.1f, 0.1f, 0.1f));

        m_radius = 1.0;

    } else {

        m_sphere->setScaling(QVector3D(0.1f, 0.1f, 0.1f));

        m_arrow->setScaling(QVector3D(2.0f, 2.0f, 2.0f));

        m_radius = 7.0;

void CustomItemDataModifier::toggleTimer()

    if (m_rotationTimer.isActive())

        m_rotationTimer.stop();

    else

        m_rotationTimer.start(16.7);

void CustomItemDataModifier::setXAxisReversed(int reversed)

    m_graph->axisX()->setReversed(bool(reversed));

    if (!m_rotationTimer.isActive())

        updatePositions();

void CustomItemDataModifier::setYAxisReversed(int reversed)

    m_graph->axisY()->setReversed(bool(reversed));

    if (!m_rotationTimer.isActive())

        updatePositions();

void CustomItemDataModifier::setZAxisReversed(int reversed)

    m_graph->axisZ()->setReversed(bool(reversed));

    if (!m_rotationTimer.isActive())

        updatePositions();

void CustomItemDataModifier::setCustomX(int value)

    m_customEulerAngles.setX(float(value));

    updatePositions();

void CustomItemDataModifier::setCustomY(int value)

    m_customEulerAngles.setY(float(value));

    updatePositions();

void CustomItemDataModifier::setCustomZ(int value)

    m_customEulerAngles.setZ(float(value));

    updatePositions();

void CustomItemDataModifier::setCustomRotation(int enabled)

    m_customRotationEnabled = bool(enabled);

    m_sphere->setVisible(!m_customRotationEnabled);

    m_rotationTimer.stop();

void CustomItemDataModifier::updatePositions()

    static int increment = 0;

    constexpr float n = 3;

    const float maxFps = 60 * n;

    float time = float(increment) * M_PI * 2 / maxFps;

    const float r = m_radius;

    const float x =  r * cos(time) * cos(n * time);

    const float y =  r * sin(time) * cos(n * time);

    const float z =  r * sin(n * time);

    QVector3D spherePos(x,y,z);

    m_sphere->setPosition(spherePos);

    if (m_customRotationEnabled) {

        m_arrow->setRotation(QQuaternion::fromEulerAngles(m_customEulerAngles));

        return;

    //look at algorithm

    QVector3D forwardDirection(0, 1, 0);

    QVector3D upDirection(0, 1, 0);

    if (m_graph->axisY()->reversed() && !m_arrow->isRotationAbsolute()) {

        upDirection = QVector3D(0, -1, 0);

        forwardDirection = QVector3D(0, -1, 0);

    QVector3D targetDirection = spherePos.normalized();

    QVector3D rotationAxis = QVector3D::crossProduct(forwardDirection, targetDirection);

    QVector3D normalizedAxis = rotationAxis.normalized();

    if (qFuzzyIsNull(normalizedAxis.lengthSquared()))

        rotationAxis = upDirection;

    float dot = QVector3D::dotProduct(forwardDirection, targetDirection);

    float rotationAngle = qRadiansToDegrees(qAcos(dot));

    QQuaternion lookAtRot = QQuaternion::fromAxisAndAngle(rotationAxis, rotationAngle);

    m_arrow->setRotation(lookAtRot);

    increment = (increment + 1) % int(maxFps);