summaryrefslogtreecommitdiffstats
path: root/tests/manual/scattertest
diff options
context:
space:
mode:
Diffstat (limited to 'tests/manual/scattertest')
-rw-r--r--tests/manual/scattertest/main.cpp496
-rw-r--r--tests/manual/scattertest/scatterchart.cpp1172
-rw-r--r--tests/manual/scattertest/scatterchart.h132
-rw-r--r--tests/manual/scattertest/scattertest.pro8
4 files changed, 1808 insertions, 0 deletions
diff --git a/tests/manual/scattertest/main.cpp b/tests/manual/scattertest/main.cpp
new file mode 100644
index 00000000..26a9c776
--- /dev/null
+++ b/tests/manual/scattertest/main.cpp
@@ -0,0 +1,496 @@
+/******************************************************************************
+**
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt Data Visualization module.
+**
+** $QT_BEGIN_LICENSE:COMM$
+**
+** 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 http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** $QT_END_LICENSE$
+**
+******************************************************************************/
+
+#include "scatterchart.h"
+
+#include <QApplication>
+#include <QWidget>
+#include <QHBoxLayout>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QCheckBox>
+#include <QSlider>
+#include <QComboBox>
+#include <QFontComboBox>
+#include <QLabel>
+#include <QScreen>
+#include <QFontDatabase>
+#include <QLinearGradient>
+#include <QPainter>
+
+int main(int argc, char **argv)
+{
+ QApplication app(argc, argv);
+ //QCoreApplication::setAttribute(Qt::AA_UseOpenGLES);
+
+ QWidget *widget = new QWidget;
+ QHBoxLayout *hLayout = new QHBoxLayout(widget);
+ QVBoxLayout *vLayout = new QVBoxLayout();
+ QVBoxLayout *vLayout2 = new QVBoxLayout();
+ QVBoxLayout *vLayout3 = new QVBoxLayout();
+
+ Q3DScatter *chart = new Q3DScatter();
+ QSize screenSize = chart->screen()->size();
+
+ QWidget *container = QWidget::createWindowContainer(chart);
+ container->setMinimumSize(QSize(screenSize.width() / 2, screenSize.height() / 2));
+ container->setMaximumSize(screenSize);
+ container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+ container->setFocusPolicy(Qt::StrongFocus);
+
+ widget->setWindowTitle(QStringLiteral("values of some things in something"));
+
+ hLayout->addWidget(container, 1);
+ hLayout->addLayout(vLayout);
+ hLayout->addLayout(vLayout2);
+ hLayout->addLayout(vLayout3);
+
+ QPushButton *themeButton = new QPushButton(widget);
+ themeButton->setText(QStringLiteral("Change theme"));
+
+ QPushButton *labelButton = new QPushButton(widget);
+ labelButton->setText(QStringLiteral("Change label style"));
+
+ QPushButton *styleButton = new QPushButton(widget);
+ styleButton->setText(QStringLiteral("Change item style"));
+
+ QPushButton *cameraButton = new QPushButton(widget);
+ cameraButton->setText(QStringLiteral("Change camera preset"));
+
+ QPushButton *clearButton = new QPushButton(widget);
+ clearButton->setText(QStringLiteral("Clear chart"));
+
+ QPushButton *resetButton = new QPushButton(widget);
+ resetButton->setText(QStringLiteral("Reset axes"));
+
+ QPushButton *addOneButton = new QPushButton(widget);
+ addOneButton->setText(QStringLiteral("Add item"));
+
+ QPushButton *addBunchButton = new QPushButton(widget);
+ addBunchButton->setText(QStringLiteral("Add bunch of items"));
+
+ QPushButton *insertOneButton = new QPushButton(widget);
+ insertOneButton->setText(QStringLiteral("Insert item"));
+
+ QPushButton *insertBunchButton = new QPushButton(widget);
+ insertBunchButton->setText(QStringLiteral("Insert bunch of items"));
+
+ QPushButton *changeOneButton = new QPushButton(widget);
+ changeOneButton->setText(QStringLiteral("Change selected item"));
+
+ QPushButton *changeBunchButton = new QPushButton(widget);
+ changeBunchButton->setText(QStringLiteral("Change bunch of items"));
+
+ QPushButton *removeOneButton = new QPushButton(widget);
+ removeOneButton->setText(QStringLiteral("Remove selected item"));
+
+ QPushButton *removeBunchButton = new QPushButton(widget);
+ removeBunchButton->setText(QStringLiteral("Remove bunch of items"));
+
+ QPushButton *setSelectedItemButton = new QPushButton(widget);
+ setSelectedItemButton->setText(QStringLiteral("Select/deselect item 3"));
+
+ QPushButton *clearSeriesDataButton = new QPushButton(widget);
+ clearSeriesDataButton->setText(QStringLiteral("Clear series data"));
+
+ QPushButton *addSeriesButton = new QPushButton(widget);
+ addSeriesButton->setText(QStringLiteral("Add Series"));
+
+ QPushButton *removeSeriesButton = new QPushButton(widget);
+ removeSeriesButton->setText(QStringLiteral("Remove Series"));
+
+ QPushButton *toggleSeriesVisibilityButton = new QPushButton(widget);
+ toggleSeriesVisibilityButton->setText(QStringLiteral("Toggle visibility"));
+
+ QPushButton *changeSeriesNameButton = new QPushButton(widget);
+ changeSeriesNameButton->setText(QStringLiteral("Series name"));
+
+ QPushButton *startTimerButton = new QPushButton(widget);
+ startTimerButton->setText(QStringLiteral("Start/stop timer"));
+
+ QPushButton *massiveDataTestButton = new QPushButton(widget);
+ massiveDataTestButton->setText(QStringLiteral("Massive data test"));
+
+ QPushButton *testItemChangesButton = new QPushButton(widget);
+ testItemChangesButton->setText(QStringLiteral("Test Item changing"));
+
+ QPushButton *testReverseButton = new QPushButton(widget);
+ testReverseButton->setText(QStringLiteral("Test Axis Reversing"));
+
+ QPushButton *renderToImageButton = new QPushButton(widget);
+ renderToImageButton->setText(QStringLiteral("Render the graph to an image"));
+
+ QLinearGradient grBtoY(0, 0, 100, 0);
+ grBtoY.setColorAt(1.0, Qt::black);
+ grBtoY.setColorAt(0.67, Qt::blue);
+ grBtoY.setColorAt(0.33, Qt::red);
+ grBtoY.setColorAt(0.0, Qt::yellow);
+ QPixmap pm(100, 24);
+ QPainter pmp(&pm);
+ pmp.setBrush(QBrush(grBtoY));
+ pmp.setPen(Qt::NoPen);
+ pmp.drawRect(0, 0, 100, 24);
+ QPushButton *gradientBtoYPB = new QPushButton(widget);
+ gradientBtoYPB->setIcon(QIcon(pm));
+ gradientBtoYPB->setIconSize(QSize(100, 24));
+
+ QLabel *fpsLabel = new QLabel(QStringLiteral(""));
+
+ QCheckBox *fpsCheckBox = new QCheckBox(widget);
+ fpsCheckBox->setText(QStringLiteral("Measure Fps"));
+ fpsCheckBox->setChecked(false);
+
+ QCheckBox *backgroundCheckBox = new QCheckBox(widget);
+ backgroundCheckBox->setText(QStringLiteral("Show background"));
+ backgroundCheckBox->setChecked(true);
+
+ QCheckBox *gridCheckBox = new QCheckBox(widget);
+ gridCheckBox->setText(QStringLiteral("Show grid"));
+ gridCheckBox->setChecked(true);
+
+ QComboBox *shadowQuality = new QComboBox(widget);
+ shadowQuality->addItem(QStringLiteral("None"));
+ shadowQuality->addItem(QStringLiteral("Low"));
+ shadowQuality->addItem(QStringLiteral("Medium"));
+ shadowQuality->addItem(QStringLiteral("High"));
+ shadowQuality->addItem(QStringLiteral("Low Soft"));
+ shadowQuality->addItem(QStringLiteral("Medium Soft"));
+ shadowQuality->addItem(QStringLiteral("High Soft"));
+ shadowQuality->setCurrentIndex(0);
+
+ QFontComboBox *fontList = new QFontComboBox(widget);
+
+ QSlider *fontSizeSlider = new QSlider(Qt::Horizontal, widget);
+ fontSizeSlider->setTickInterval(15);
+ fontSizeSlider->setTickPosition(QSlider::TicksBelow);
+ fontSizeSlider->setMinimum(1);
+ fontSizeSlider->setValue(30);
+ fontSizeSlider->setMaximum(200);
+
+ QSlider *pointSizeSlider = new QSlider(Qt::Horizontal, widget);
+ pointSizeSlider->setTickInterval(15);
+ pointSizeSlider->setTickPosition(QSlider::TicksBelow);
+ pointSizeSlider->setMinimum(1);
+ pointSizeSlider->setValue(30);
+ pointSizeSlider->setMaximum(100);
+
+ QSlider *minSliderX = new QSlider(Qt::Horizontal, widget);
+ minSliderX->setTickInterval(50);
+ minSliderX->setTickPosition(QSlider::TicksBelow);
+ minSliderX->setMinimum(-100);
+ minSliderX->setValue(-50);
+ minSliderX->setMaximum(100);
+
+ QSlider *minSliderY = new QSlider(Qt::Horizontal, widget);
+ minSliderY->setTickInterval(100);
+ minSliderY->setTickPosition(QSlider::TicksBelow);
+ minSliderY->setMinimum(-200);
+ minSliderY->setValue(-100);
+ minSliderY->setMaximum(200);
+
+ QSlider *minSliderZ = new QSlider(Qt::Horizontal, widget);
+ minSliderZ->setTickInterval(50);
+ minSliderZ->setTickPosition(QSlider::TicksBelow);
+ minSliderZ->setMinimum(-100);
+ minSliderZ->setValue(-50);
+ minSliderZ->setMaximum(100);
+
+ QSlider *maxSliderX = new QSlider(Qt::Horizontal, widget);
+ maxSliderX->setTickInterval(50);
+ maxSliderX->setTickPosition(QSlider::TicksAbove);
+ maxSliderX->setMinimum(-100);
+ maxSliderX->setValue(50);
+ maxSliderX->setMaximum(100);
+
+ QSlider *maxSliderY = new QSlider(Qt::Horizontal, widget);
+ maxSliderY->setTickInterval(100);
+ maxSliderY->setTickPosition(QSlider::TicksAbove);
+ maxSliderY->setMinimum(-200);
+ maxSliderY->setValue(120);
+ maxSliderY->setMaximum(200);
+
+ QSlider *maxSliderZ = new QSlider(Qt::Horizontal, widget);
+ maxSliderZ->setTickInterval(50);
+ maxSliderZ->setTickPosition(QSlider::TicksAbove);
+ maxSliderZ->setMinimum(-100);
+ maxSliderZ->setValue(50);
+ maxSliderZ->setMaximum(100);
+
+ QSlider *aspectRatioSlider = new QSlider(Qt::Horizontal, widget);
+ aspectRatioSlider->setTickInterval(10);
+ aspectRatioSlider->setTickPosition(QSlider::TicksBelow);
+ aspectRatioSlider->setMinimum(1);
+ aspectRatioSlider->setValue(20);
+ aspectRatioSlider->setMaximum(100);
+
+ QSlider *horizontalAspectRatioSlider = new QSlider(Qt::Horizontal, widget);
+ horizontalAspectRatioSlider->setTickInterval(30);
+ horizontalAspectRatioSlider->setTickPosition(QSlider::TicksBelow);
+ horizontalAspectRatioSlider->setMinimum(0);
+ horizontalAspectRatioSlider->setValue(0);
+ horizontalAspectRatioSlider->setMaximum(300);
+
+ QCheckBox *optimizationStaticCB = new QCheckBox(widget);
+ optimizationStaticCB->setText(QStringLiteral("Static optimization"));
+ optimizationStaticCB->setChecked(false);
+
+ QCheckBox *orthoCB = new QCheckBox(widget);
+ orthoCB->setText(QStringLiteral("Orthographic projection"));
+ orthoCB->setChecked(false);
+
+ QCheckBox *polarCB = new QCheckBox(widget);
+ polarCB->setText(QStringLiteral("Polar graph"));
+ polarCB->setChecked(false);
+
+ QCheckBox *axisTitlesVisibleCB = new QCheckBox(widget);
+ axisTitlesVisibleCB->setText(QStringLiteral("Axis titles visible"));
+ axisTitlesVisibleCB->setChecked(false);
+
+ QCheckBox *axisTitlesFixedCB = new QCheckBox(widget);
+ axisTitlesFixedCB->setText(QStringLiteral("Axis titles fixed"));
+ axisTitlesFixedCB->setChecked(true);
+
+ QSlider *axisLabelRotationSlider = new QSlider(Qt::Horizontal, widget);
+ axisLabelRotationSlider->setTickInterval(10);
+ axisLabelRotationSlider->setTickPosition(QSlider::TicksBelow);
+ axisLabelRotationSlider->setMinimum(0);
+ axisLabelRotationSlider->setValue(0);
+ axisLabelRotationSlider->setMaximum(90);
+
+ QSlider *radialLabelSlider = new QSlider(Qt::Horizontal, widget);
+ radialLabelSlider->setTickInterval(10);
+ radialLabelSlider->setTickPosition(QSlider::TicksBelow);
+ radialLabelSlider->setMinimum(0);
+ radialLabelSlider->setValue(100);
+ radialLabelSlider->setMaximum(150);
+
+ QSlider *cameraTargetSliderX = new QSlider(Qt::Horizontal, widget);
+ cameraTargetSliderX->setTickInterval(1);
+ cameraTargetSliderX->setMinimum(-100);
+ cameraTargetSliderX->setValue(0);
+ cameraTargetSliderX->setMaximum(100);
+ QSlider *cameraTargetSliderY = new QSlider(Qt::Horizontal, widget);
+ cameraTargetSliderY->setTickInterval(1);
+ cameraTargetSliderY->setMinimum(-100);
+ cameraTargetSliderY->setValue(0);
+ cameraTargetSliderY->setMaximum(100);
+ QSlider *cameraTargetSliderZ = new QSlider(Qt::Horizontal, widget);
+ cameraTargetSliderZ->setTickInterval(1);
+ cameraTargetSliderZ->setMinimum(-100);
+ cameraTargetSliderZ->setValue(0);
+ cameraTargetSliderZ->setMaximum(100);
+
+ QSlider *marginSlider = new QSlider(Qt::Horizontal, widget);
+ marginSlider->setMinimum(-1);
+ marginSlider->setValue(-1);
+ marginSlider->setMaximum(100);
+
+ vLayout->addWidget(themeButton, 0, Qt::AlignTop);
+ vLayout->addWidget(labelButton, 0, Qt::AlignTop);
+ vLayout->addWidget(styleButton, 0, Qt::AlignTop);
+ vLayout->addWidget(cameraButton, 0, Qt::AlignTop);
+ vLayout->addWidget(clearButton, 0, Qt::AlignTop);
+ vLayout->addWidget(resetButton, 0, Qt::AlignTop);
+ vLayout->addWidget(addOneButton, 0, Qt::AlignTop);
+ vLayout->addWidget(addBunchButton, 0, Qt::AlignTop);
+ vLayout->addWidget(insertOneButton, 0, Qt::AlignTop);
+ vLayout->addWidget(insertBunchButton, 0, Qt::AlignTop);
+ vLayout->addWidget(changeOneButton, 0, Qt::AlignTop);
+ vLayout->addWidget(changeBunchButton, 0, Qt::AlignTop);
+ vLayout->addWidget(removeOneButton, 0, Qt::AlignTop);
+ vLayout->addWidget(removeBunchButton, 0, Qt::AlignTop);
+ vLayout->addWidget(setSelectedItemButton, 0, Qt::AlignTop);
+ vLayout->addWidget(clearSeriesDataButton, 0, Qt::AlignTop);
+ vLayout->addWidget(addSeriesButton, 0, Qt::AlignTop);
+ vLayout->addWidget(removeSeriesButton, 0, Qt::AlignTop);
+ vLayout->addWidget(toggleSeriesVisibilityButton, 0, Qt::AlignTop);
+ vLayout->addWidget(changeSeriesNameButton, 0, Qt::AlignTop);
+ vLayout->addWidget(startTimerButton, 0, Qt::AlignTop);
+ vLayout->addWidget(massiveDataTestButton, 0, Qt::AlignTop);
+ vLayout->addWidget(testItemChangesButton, 0, Qt::AlignTop);
+ vLayout->addWidget(testReverseButton, 0, Qt::AlignTop);
+ vLayout->addWidget(renderToImageButton, 1, Qt::AlignTop);
+
+ vLayout2->addWidget(gradientBtoYPB, 0, Qt::AlignTop);
+ vLayout2->addWidget(fpsLabel, 0, Qt::AlignTop);
+ vLayout2->addWidget(fpsCheckBox, 0, Qt::AlignTop);
+ vLayout2->addWidget(backgroundCheckBox);
+ vLayout2->addWidget(gridCheckBox);
+ vLayout2->addWidget(new QLabel(QStringLiteral("Adjust shadow quality")));
+ vLayout2->addWidget(shadowQuality, 0, Qt::AlignTop);
+ vLayout2->addWidget(new QLabel(QStringLiteral("Adjust point size")));
+ vLayout2->addWidget(pointSizeSlider, 0, Qt::AlignTop);
+ vLayout2->addWidget(new QLabel(QStringLiteral("Adjust data window")));
+ vLayout2->addWidget(minSliderX, 0, Qt::AlignTop);
+ vLayout2->addWidget(maxSliderX, 0, Qt::AlignTop);
+ vLayout2->addWidget(minSliderY, 0, Qt::AlignTop);
+ vLayout2->addWidget(maxSliderY, 0, Qt::AlignTop);
+ vLayout2->addWidget(minSliderZ, 0, Qt::AlignTop);
+ vLayout2->addWidget(maxSliderZ, 0, Qt::AlignTop);
+ vLayout2->addWidget(new QLabel(QStringLiteral("Change font")));
+ vLayout2->addWidget(fontList);
+ vLayout2->addWidget(new QLabel(QStringLiteral("Adjust font size")));
+ vLayout2->addWidget(fontSizeSlider);
+ vLayout2->addWidget(new QLabel(QStringLiteral("Adjust vertical aspect ratio")));
+ vLayout2->addWidget(aspectRatioSlider);
+ vLayout2->addWidget(new QLabel(QStringLiteral("Adjust horizontal aspect ratio")));
+ vLayout2->addWidget(horizontalAspectRatioSlider, 1, Qt::AlignTop);
+
+ vLayout3->addWidget(optimizationStaticCB);
+ vLayout3->addWidget(orthoCB);
+ vLayout3->addWidget(polarCB);
+ vLayout3->addWidget(axisTitlesVisibleCB);
+ vLayout3->addWidget(axisTitlesFixedCB);
+ vLayout3->addWidget(new QLabel(QStringLiteral("Axis label rotation")));
+ vLayout3->addWidget(axisLabelRotationSlider);
+ vLayout3->addWidget(new QLabel(QStringLiteral("Radial label offset")));
+ vLayout3->addWidget(radialLabelSlider, 0, Qt::AlignTop);
+ vLayout3->addWidget(new QLabel(QStringLiteral("Camera target")), 0, Qt::AlignTop);
+ vLayout3->addWidget(cameraTargetSliderX, 0, Qt::AlignTop);
+ vLayout3->addWidget(cameraTargetSliderY, 0, Qt::AlignTop);
+ vLayout3->addWidget(cameraTargetSliderZ, 0, Qt::AlignTop);
+ vLayout3->addWidget(new QLabel(QStringLiteral("Adjust margin")), 0, Qt::AlignTop);
+ vLayout3->addWidget(marginSlider, 1, Qt::AlignTop);
+
+ ScatterDataModifier *modifier = new ScatterDataModifier(chart);
+
+ QObject::connect(fontSizeSlider, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::changeFontSize);
+ QObject::connect(pointSizeSlider, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::changePointSize);
+
+ QObject::connect(styleButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::changeStyle);
+ QObject::connect(cameraButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::changePresetCamera);
+ QObject::connect(clearButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::clear);
+ QObject::connect(resetButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::resetAxes);
+ QObject::connect(addOneButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::addOne);
+ QObject::connect(addBunchButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::addBunch);
+ QObject::connect(insertOneButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::insertOne);
+ QObject::connect(insertBunchButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::insertBunch);
+ QObject::connect(changeOneButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::changeOne);
+ QObject::connect(changeBunchButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::changeBunch);
+ QObject::connect(removeOneButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::removeOne);
+ QObject::connect(removeBunchButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::removeBunch);
+ QObject::connect(setSelectedItemButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::selectItem);
+ QObject::connect(clearSeriesDataButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::clearSeriesData);
+ QObject::connect(addSeriesButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::addSeries);
+ QObject::connect(removeSeriesButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::removeSeries);
+ QObject::connect(toggleSeriesVisibilityButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::toggleSeriesVisibility);
+ QObject::connect(changeSeriesNameButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::changeSeriesName);
+ QObject::connect(startTimerButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::startStopTimer);
+ QObject::connect(massiveDataTestButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::massiveDataTest);
+ QObject::connect(testItemChangesButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::testItemChanges);
+ QObject::connect(testReverseButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::testAxisReverse);
+ QObject::connect(renderToImageButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::renderToImage);
+ QObject::connect(gradientBtoYPB, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::setGradient);
+ QObject::connect(themeButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::changeTheme);
+ QObject::connect(labelButton, &QPushButton::clicked, modifier,
+ &ScatterDataModifier::changeLabelStyle);
+
+ QObject::connect(shadowQuality, SIGNAL(currentIndexChanged(int)), modifier,
+ SLOT(changeShadowQuality(int)));
+ QObject::connect(modifier, &ScatterDataModifier::shadowQualityChanged, shadowQuality,
+ &QComboBox::setCurrentIndex);
+ QObject::connect(fontList, &QFontComboBox::currentFontChanged, modifier,
+ &ScatterDataModifier::changeFont);
+
+ QObject::connect(fpsCheckBox, &QCheckBox::stateChanged, modifier,
+ &ScatterDataModifier::setFpsMeasurement);
+ QObject::connect(backgroundCheckBox, &QCheckBox::stateChanged, modifier,
+ &ScatterDataModifier::setBackgroundEnabled);
+ QObject::connect(gridCheckBox, &QCheckBox::stateChanged, modifier,
+ &ScatterDataModifier::setGridEnabled);
+
+ QObject::connect(minSliderX, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::setMinX);
+ QObject::connect(minSliderY, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::setMinY);
+ QObject::connect(minSliderZ, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::setMinZ);
+ QObject::connect(maxSliderX, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::setMaxX);
+ QObject::connect(maxSliderY, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::setMaxY);
+ QObject::connect(maxSliderZ, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::setMaxZ);
+ QObject::connect(optimizationStaticCB, &QCheckBox::stateChanged, modifier,
+ &ScatterDataModifier::toggleStatic);
+ QObject::connect(orthoCB, &QCheckBox::stateChanged, modifier,
+ &ScatterDataModifier::toggleOrtho);
+ QObject::connect(polarCB, &QCheckBox::stateChanged, modifier,
+ &ScatterDataModifier::togglePolar);
+ QObject::connect(axisTitlesVisibleCB, &QCheckBox::stateChanged, modifier,
+ &ScatterDataModifier::toggleAxisTitleVisibility);
+ QObject::connect(axisTitlesFixedCB, &QCheckBox::stateChanged, modifier,
+ &ScatterDataModifier::toggleAxisTitleFixed);
+ QObject::connect(axisLabelRotationSlider, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::changeLabelRotation);
+ QObject::connect(aspectRatioSlider, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::setAspectRatio);
+ QObject::connect(horizontalAspectRatioSlider, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::setHorizontalAspectRatio);
+ QObject::connect(radialLabelSlider, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::changeRadialLabelOffset);
+ QObject::connect(cameraTargetSliderX, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::setCameraTargetX);
+ QObject::connect(cameraTargetSliderY, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::setCameraTargetY);
+ QObject::connect(cameraTargetSliderZ, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::setCameraTargetZ);
+ QObject::connect(marginSlider, &QSlider::valueChanged, modifier,
+ &ScatterDataModifier::setGraphMargin);
+
+ modifier->setFpsLabel(fpsLabel);
+
+ chart->setGeometry(QRect(0, 0, 800, 800));
+
+ modifier->start();
+ //modifier->renderToImage(); // Initial hidden render
+
+ widget->show();
+
+ return app.exec();
+}
diff --git a/tests/manual/scattertest/scatterchart.cpp b/tests/manual/scattertest/scatterchart.cpp
new file mode 100644
index 00000000..c2e27c9b
--- /dev/null
+++ b/tests/manual/scattertest/scatterchart.cpp
@@ -0,0 +1,1172 @@
+/******************************************************************************
+**
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt Data Visualization module.
+**
+** $QT_BEGIN_LICENSE:COMM$
+**
+** 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 http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** $QT_END_LICENSE$
+**
+******************************************************************************/
+
+#include "scatterchart.h"
+#include <QtDataVisualization/qscatterdataproxy.h>
+#include <QtDataVisualization/qscatter3dseries.h>
+#include <QtDataVisualization/qvalue3daxis.h>
+#include <QtDataVisualization/q3dscene.h>
+#include <QtDataVisualization/q3dcamera.h>
+#include <QtDataVisualization/q3dtheme.h>
+#include <QtDataVisualization/Q3DInputHandler>
+#include <qmath.h>
+using namespace QtDataVisualization;
+
+//#define RANDOM_SCATTER
+
+const int numberOfItems = 10000;
+
+ScatterDataModifier::ScatterDataModifier(Q3DScatter *scatter)
+ : m_chart(scatter),
+ m_fontSize(30.0f),
+ m_loopCounter(0),
+ m_selectedItem(-1),
+ m_targetSeries(0)
+{
+ m_chart->activeTheme()->setType(Q3DTheme::ThemeStoneMoss);
+ QFont font = m_chart->activeTheme()->font();
+ font.setPointSize(m_fontSize);
+ m_chart->activeTheme()->setFont(font);
+ m_chart->setShadowQuality(QAbstract3DGraph::ShadowQualityNone);
+ m_chart->scene()->activeCamera()->setCameraPreset(Q3DCamera::CameraPresetFront);
+ m_chart->setAxisX(new QValue3DAxis);
+ m_chart->setAxisY(new QValue3DAxis);
+ m_chart->setAxisZ(new QValue3DAxis);
+ m_chart->axisY()->setLabelFormat(QStringLiteral("%.7f"));
+ static_cast<Q3DInputHandler *>(m_chart->activeInputHandler())->setZoomAtTargetEnabled(true);
+
+ createAndAddSeries();
+ createAndAddSeries();
+
+ m_chart->setSelectionMode(QAbstract3DGraph::SelectionItem);
+
+ QObject::connect(&m_timer, &QTimer::timeout, this, &ScatterDataModifier::timeout);
+ QObject::connect(m_chart, &Q3DScatter::shadowQualityChanged, this,
+ &ScatterDataModifier::shadowQualityUpdatedByVisual);
+
+ QObject::connect(m_chart, &Q3DScatter::axisXChanged, this,
+ &ScatterDataModifier::handleAxisXChanged);
+ QObject::connect(m_chart, &Q3DScatter::axisYChanged, this,
+ &ScatterDataModifier::handleAxisYChanged);
+ QObject::connect(m_chart, &Q3DScatter::axisZChanged, this,
+ &ScatterDataModifier::handleAxisZChanged);
+ QObject::connect(m_chart, &QAbstract3DGraph::currentFpsChanged, this,
+ &ScatterDataModifier::handleFpsChange);
+}
+
+ScatterDataModifier::~ScatterDataModifier()
+{
+ delete m_chart;
+}
+
+void ScatterDataModifier::start()
+{
+ addData();
+}
+
+static const int itemsPerUnit = 100; // "unit" is one unit range along Z-axis
+
+void ScatterDataModifier::massiveDataTest()
+{
+ static int testPhase = 0;
+ static QTimer *massiveTestTimer = 0;
+
+ if (!massiveTestTimer)
+ massiveTestTimer = new QTimer;
+
+ int items = 1000000;
+ int visibleRange = 200;
+ int unitCount = items / itemsPerUnit;
+ int cacheSize = visibleRange * itemsPerUnit * 5;
+
+ switch (testPhase) {
+ case 0: {
+ float yRangeMin = 0.0f;
+ float yRangeMax = 1.0f;
+ float yRangeMargin = 0.05f;
+ float minY = yRangeMin + yRangeMargin;
+ float maxY = yRangeMax - yRangeMargin;
+ float unitBase = minY;
+ float direction = 1.0f;
+
+ if (!m_massiveTestCacheArray.size()) {
+ m_massiveTestCacheArray.resize(cacheSize);
+ int totalIndex = 0;
+ for (int i = 0; i < unitCount && totalIndex < cacheSize; i++) {
+ unitBase += direction * (float(rand() % 3) / 100.0f);
+ if (unitBase > maxY) {
+ unitBase = maxY;
+ direction = -1.0f;
+ } else if (unitBase < minY) {
+ unitBase = minY;
+ direction = 1.0f;
+ }
+ for (int j = 0; j < itemsPerUnit && totalIndex < cacheSize; j++) {
+ float randFactor = float(rand() % 100) / (100 / yRangeMargin);
+ m_massiveTestCacheArray[totalIndex].setPosition(
+ QVector3D(float(qrand() % itemsPerUnit),
+ unitBase + randFactor, 0.0f));
+ // Z value is irrelevant, we replace it anyway when we take item to use
+ totalIndex++;
+ }
+ }
+ }
+
+ qDebug() << __FUNCTION__ << testPhase << ": Setting the graph up...";
+ QValue3DAxis *xAxis = new QValue3DAxis();
+ QValue3DAxis *yAxis = new QValue3DAxis();
+ QValue3DAxis *zAxis = new QValue3DAxis();
+ xAxis->setRange(0.0f, float(itemsPerUnit - 1));
+ yAxis->setRange(yRangeMin, yRangeMax);
+ zAxis->setRange(0.0f, float(visibleRange - 1));
+ xAxis->setSegmentCount(1);
+ yAxis->setSegmentCount(1);
+ zAxis->setSegmentCount(1);
+ m_chart->setAxisX(xAxis);
+ m_chart->setAxisY(yAxis);
+ m_chart->setAxisZ(zAxis);
+ m_chart->scene()->activeCamera()->setCameraPreset(Q3DCamera::CameraPresetRight);
+ m_chart->setShadowQuality(QAbstract3DGraph::ShadowQualityNone);
+ foreach (QAbstract3DSeries *series, m_chart->seriesList())
+ m_chart->removeSeries(static_cast<QScatter3DSeries *>(series));
+
+ qDebug() << __FUNCTION__ << testPhase << ": Creating massive array..." << items;
+ QScatterDataArray *massiveArray = new QScatterDataArray;
+ massiveArray->resize(items);
+
+ int cacheIndex = 0;
+ for (int i = 0; i < items; i++) {
+ // Use qreals for precicion as the numbers can overflow int
+ float currentZ = float(qreal(i) * qreal(unitCount) / qreal(items));
+ (*massiveArray)[i] = m_massiveTestCacheArray.at(cacheIndex++);
+ (*massiveArray)[i].setZ(currentZ);
+ if (cacheIndex >= cacheSize)
+ cacheIndex = 0;
+ }
+ qDebug() << __FUNCTION__ << testPhase << ": Massive array creation finished!";
+
+ QScatter3DSeries *series = new QScatter3DSeries;
+ series->dataProxy()->resetArray(massiveArray);
+ series->setMesh(QAbstract3DSeries::MeshPoint);
+ m_chart->addSeries(series);
+ break;
+ }
+ case 1: {
+ qDebug() << __FUNCTION__ << testPhase << ": Scroll";
+ QObject::disconnect(massiveTestTimer, 0, this, 0);
+ QObject::connect(massiveTestTimer, &QTimer::timeout, this,
+ &ScatterDataModifier::massiveTestScroll);
+ massiveTestTimer->start(16);
+ break;
+ }
+ case 2: {
+ qDebug() << __FUNCTION__ << testPhase << ": Append and scroll";
+ massiveTestTimer->stop();
+ QObject::disconnect(massiveTestTimer, 0, this, 0);
+ QObject::connect(massiveTestTimer, &QTimer::timeout, this,
+ &ScatterDataModifier::massiveTestAppendAndScroll);
+ m_chart->axisZ()->setRange(unitCount - visibleRange, unitCount);
+ massiveTestTimer->start(16);
+ break;
+ }
+ default:
+ QObject::disconnect(massiveTestTimer, 0, this, 0);
+ massiveTestTimer->stop();
+ qDebug() << __FUNCTION__ << testPhase << ": Resetting the test";
+ testPhase = -1;
+ }
+ testPhase++;
+}
+
+void ScatterDataModifier::massiveTestScroll()
+{
+ const int scrollAmount = 20;
+ int itemCount = m_chart->seriesList().at(0)->dataProxy()->itemCount();
+ int min = m_chart->axisZ()->min() + scrollAmount;
+ int max = m_chart->axisZ()->max() + scrollAmount;
+ if (max >= itemCount / itemsPerUnit) {
+ max = max - min - 1;
+ min = 0;
+ }
+ m_chart->axisZ()->setRange(min, max);
+}
+
+void ScatterDataModifier::massiveTestAppendAndScroll()
+{
+ const int addedUnits = 50;
+ const int addedItems = itemsPerUnit * addedUnits;
+ int cacheSize = m_massiveTestCacheArray.size();
+ int itemCount = m_chart->seriesList().at(0)->dataProxy()->itemCount();
+ static int cacheIndex = 0;
+
+ // Copy items from cache
+ QScatterDataArray appendArray;
+ appendArray.resize(addedItems);
+
+ float zOffset = m_chart->seriesList().at(0)->dataProxy()->itemAt(itemCount - 1)->z();
+ for (int i = 0; i < addedItems; i++) {
+ float currentZ = zOffset + float(qreal(i) * qreal(addedUnits) / qreal(addedItems));
+ appendArray[i] = m_massiveTestCacheArray.at(cacheIndex++);
+ appendArray[i].setZ(currentZ);
+ if (cacheIndex >= cacheSize)
+ cacheIndex = 0;
+ }
+
+ m_chart->seriesList().at(0)->dataProxy()->addItems(appendArray);
+ int min = m_chart->axisZ()->min() + addedUnits;
+ int max = m_chart->axisZ()->max() + addedUnits;
+ m_chart->axisZ()->setRange(min, max);
+}
+
+void ScatterDataModifier::setFpsMeasurement(bool enable)
+{
+ m_chart->setMeasureFps(enable);
+}
+
+void ScatterDataModifier::testItemChanges()
+{
+ static int counter = 0;
+ const int rowCount = 12;
+ const int colCount = 10;
+ static QScatter3DSeries *series0 = 0;
+ static QScatter3DSeries *series1 = 0;
+ static QScatter3DSeries *series2 = 0;
+
+ switch (counter) {
+ case 0: {
+ qDebug() << __FUNCTION__ << counter << "Setup test";
+ foreach (QScatter3DSeries *series, m_chart->seriesList())
+ m_chart->removeSeries(series);
+ foreach (QValue3DAxis *axis, m_chart->axes())
+ deleteAxis(axis);
+ delete series0;
+ delete series1;
+ delete series2;
+ series0 = new QScatter3DSeries;
+ series1 = new QScatter3DSeries;
+ series2 = new QScatter3DSeries;
+ populateFlatSeries(series0, rowCount, colCount, 10.0f);
+ populateFlatSeries(series1, rowCount, colCount, 30.0f);
+ populateFlatSeries(series2, rowCount, colCount, 50.0f);
+ m_chart->axisX()->setRange(3.0f, 6.0f);
+ m_chart->axisY()->setRange(0.0f, 100.0f);
+ m_chart->axisZ()->setRange(4.0f, 8.0f);
+ m_chart->addSeries(series0);
+ m_chart->addSeries(series1);
+ m_chart->addSeries(series2);
+ }
+ break;
+ case 1: {
+ qDebug() << __FUNCTION__ << counter << "Change single item, unselected";
+ int itemIndex = 3 * colCount + 5;
+ QScatterDataItem item = *series0->dataProxy()->itemAt(itemIndex);
+ item.setY(75.0f);
+ series0->dataProxy()->setItem(itemIndex, item);
+ }
+ break;
+ case 2: {
+ qDebug() << __FUNCTION__ << counter << "Change single item, selected";
+ int itemIndex = 4 * colCount + 4;
+ series1->setSelectedItem(itemIndex);
+ QScatterDataItem item = *series1->dataProxy()->itemAt(itemIndex);
+ item.setY(75.0f);
+ series1->dataProxy()->setItem(itemIndex, item);
+ }
+ break;
+ case 3: {
+ qDebug() << __FUNCTION__ << counter << "Change item outside visible area";
+ int itemIndex = 2;
+ QScatterDataItem item = *series1->dataProxy()->itemAt(itemIndex);
+ item.setY(75.0f);
+ series1->dataProxy()->setItem(itemIndex, item);
+ }
+ break;
+ case 4: {
+ qDebug() << __FUNCTION__ << counter << "Change single item from two series, unselected";
+ int itemIndex = 4 * colCount + 6;
+ QScatterDataItem item0 = *series0->dataProxy()->itemAt(itemIndex);
+ QScatterDataItem item1 = *series1->dataProxy()->itemAt(itemIndex);
+ item0.setY(65.0f);
+ item1.setY(85.0f);
+ series0->dataProxy()->setItem(itemIndex, item0);
+ series1->dataProxy()->setItem(itemIndex, item1);
+ }
+ break;
+ case 5: {
+ qDebug() << __FUNCTION__ << counter << "Change single item from two series, one selected";
+ int itemIndex0 = 5 * colCount + 5;
+ int itemIndex1 = 4 * colCount + 4;
+ QScatterDataItem item0 = *series0->dataProxy()->itemAt(itemIndex0);
+ QScatterDataItem item1 = *series1->dataProxy()->itemAt(itemIndex1);
+ item0.setY(65.0f);
+ item1.setY(85.0f);
+ series0->dataProxy()->setItem(itemIndex0, item0);
+ series1->dataProxy()->setItem(itemIndex1, item1);
+ }
+ break;
+ case 6: {
+ qDebug() << __FUNCTION__ << counter << "Change single item from two series, one outside range";
+ int itemIndex0 = 6 * colCount + 6;
+ int itemIndex1 = 9 * colCount + 2;
+ QScatterDataItem item0 = *series0->dataProxy()->itemAt(itemIndex0);
+ QScatterDataItem item1 = *series1->dataProxy()->itemAt(itemIndex1);
+ item0.setY(65.0f);
+ item1.setY(85.0f);
+ series0->dataProxy()->setItem(itemIndex0, item0);
+ series1->dataProxy()->setItem(itemIndex1, item1);
+ }
+ break;
+ case 7: {
+ qDebug() << __FUNCTION__ << counter << "Change single item from two series, both outside range";
+ int itemIndex0 = 1 * colCount + 3;
+ int itemIndex1 = 9 * colCount + 2;
+ QScatterDataItem item0 = *series0->dataProxy()->itemAt(itemIndex0);
+ QScatterDataItem item1 = *series1->dataProxy()->itemAt(itemIndex1);
+ item0.setY(65.0f);
+ item1.setY(85.0f);
+ series0->dataProxy()->setItem(itemIndex0, item0);
+ series1->dataProxy()->setItem(itemIndex1, item1);
+ }
+ break;
+ case 8: {
+ qDebug() << __FUNCTION__ << counter << "Change item to same value as previously";
+ int itemIndex0 = 5 * colCount + 7;
+ int itemIndex1 = 4 * colCount + 7;
+ QScatterDataItem item0 = *series0->dataProxy()->itemAt(itemIndex0);
+ QScatterDataItem item1 = *series1->dataProxy()->itemAt(itemIndex1);
+ series0->dataProxy()->setItem(itemIndex0, item0);
+ series1->dataProxy()->setItem(itemIndex1, item1);
+ }
+ break;
+ case 9: {
+ qDebug() << __FUNCTION__ << counter << "Change 3 items on each series";
+ int itemIndex0 = 5 * colCount + 6;
+ int itemIndex1 = 4 * colCount + 6;
+ QScatterDataItem item00 = *series0->dataProxy()->itemAt(itemIndex0);
+ QScatterDataItem item01 = *series0->dataProxy()->itemAt(itemIndex0 + 1);
+ QScatterDataItem item02 = *series0->dataProxy()->itemAt(itemIndex0 + 2);
+ QScatterDataItem item10 = *series1->dataProxy()->itemAt(itemIndex1);
+ QScatterDataItem item11 = *series1->dataProxy()->itemAt(itemIndex1 + 1);
+ QScatterDataItem item12 = *series1->dataProxy()->itemAt(itemIndex1 + 2);
+ item00.setY(65.0f);
+ item01.setY(70.0f);
+ item02.setY(75.0f);
+ item10.setY(80.0f);
+ item11.setY(85.0f);
+ item12.setY(90.0f);
+ series0->dataProxy()->setItem(itemIndex0, item00);
+ series0->dataProxy()->setItem(itemIndex0 + 1, item01);
+ series0->dataProxy()->setItem(itemIndex0 + 2, item02);
+ series1->dataProxy()->setItem(itemIndex1, item10);
+ series1->dataProxy()->setItem(itemIndex1 + 1, item11);
+ series1->dataProxy()->setItem(itemIndex1 + 2, item12);
+ }
+ break;
+ case 10: {
+ qDebug() << __FUNCTION__ << counter << "Level the field single item at a time";
+ QScatterDataItem item;
+ for (int i = 0; i < rowCount; i++) {
+ for (int j = 0; j < colCount; j++) {
+ int itemIndex = i * colCount + j;
+ QScatterDataItem item0 = *series0->dataProxy()->itemAt(itemIndex);
+ QScatterDataItem item1 = *series1->dataProxy()->itemAt(itemIndex);
+ QScatterDataItem item2 = *series2->dataProxy()->itemAt(itemIndex);
+ item0.setY(10.0f);
+ item1.setY(15.0f);
+ item2.setY(20.0f);
+ series0->dataProxy()->setItem(itemIndex, item0);
+ series1->dataProxy()->setItem(itemIndex, item1);
+ series2->dataProxy()->setItem(itemIndex, item2);
+ }
+ }
+ }
+ break;
+ case 11: {
+ qDebug() << __FUNCTION__ << counter << "Change same items multiple times";
+ int itemIndex0 = 6 * colCount + 6;
+ QScatterDataItem item0 = *series0->dataProxy()->itemAt(itemIndex0);
+ item0.setY(90.0f);
+ series0->dataProxy()->setItem(itemIndex0, item0);
+ series0->dataProxy()->setItem(itemIndex0, item0);
+ series0->dataProxy()->setItem(itemIndex0, item0);
+ series0->dataProxy()->setItem(itemIndex0, item0);
+ }
+ break;
+ default:
+ qDebug() << __FUNCTION__ << "Resetting test";
+ counter = -1;
+ }
+ counter++;
+}
+
+void ScatterDataModifier::testAxisReverse()
+{
+ static int counter = 0;
+ const int rowCount = 16;
+ const int colCount = 16;
+ static QScatter3DSeries *series0 = 0;
+ static QScatter3DSeries *series1 = 0;
+
+ switch (counter) {
+ case 0: {
+ qDebug() << __FUNCTION__ << counter << "Setup test";
+ foreach (QScatter3DSeries *series, m_chart->seriesList())
+ m_chart->removeSeries(series);
+ foreach (QValue3DAxis *axis, m_chart->axes())
+ deleteAxis(axis);
+ delete series0;
+ delete series1;
+ series0 = new QScatter3DSeries;
+ series1 = new QScatter3DSeries;
+ populateRisingSeries(series0, rowCount, colCount, 0.0f, 50.0f);
+ populateRisingSeries(series1, rowCount, colCount, -20.0f, 30.0f);
+ m_chart->axisX()->setRange(0.0f, 10.0f);
+ m_chart->axisY()->setRange(-20.0f, 50.0f);
+ m_chart->axisZ()->setRange(5.0f, 15.0f);
+ m_chart->axisX()->setTitle("Axis X");
+ m_chart->axisZ()->setTitle("Axis Z");
+ m_chart->axisX()->setTitleVisible(true);
+ m_chart->axisZ()->setTitleVisible(true);
+ m_chart->addSeries(series0);
+ m_chart->addSeries(series1);
+ }
+ break;
+ case 1: {
+ qDebug() << __FUNCTION__ << counter << "Reverse X axis";
+ m_chart->axisX()->setReversed(true);
+ }
+ break;
+ case 2: {
+ qDebug() << __FUNCTION__ << counter << "Reverse Y axis";
+ m_chart->axisY()->setReversed(true);
+ }
+ break;
+ case 3: {
+ qDebug() << __FUNCTION__ << counter << "Reverse Z axis";
+ m_chart->axisZ()->setReversed(true);
+ }
+ break;
+ case 4: {
+ qDebug() << __FUNCTION__ << counter << "Return all axes to normal";
+ m_chart->axisX()->setReversed(false);
+ m_chart->axisY()->setReversed(false);
+ m_chart->axisZ()->setReversed(false);
+ }
+ break;
+ case 5: {
+ qDebug() << __FUNCTION__ << counter << "Reverse all axes";
+ m_chart->axisX()->setReversed(true);
+ m_chart->axisY()->setReversed(true);
+ m_chart->axisZ()->setReversed(true);
+ }
+ break;
+ default:
+ qDebug() << __FUNCTION__ << "Resetting test";
+ counter = -1;
+ }
+ counter++;
+}
+
+void ScatterDataModifier::addData()
+{
+ // Add labels
+ m_chart->axisX()->setTitle("X - Axis");
+ m_chart->axisY()->setTitle("Y - Axis");
+ m_chart->axisZ()->setTitle("Z - Axis");
+ m_chart->axisX()->setRange(-50.0f, 50.0f);
+ m_chart->axisY()->setRange(-1.0f, 1.2f);
+ m_chart->axisZ()->setRange(-50.0f, 50.0f);
+ m_chart->axisX()->setSegmentCount(5);
+ m_chart->axisY()->setSegmentCount(4);
+ m_chart->axisZ()->setSegmentCount(10);
+ m_chart->axisX()->setSubSegmentCount(2);
+ m_chart->axisY()->setSubSegmentCount(3);
+ m_chart->axisZ()->setSubSegmentCount(1);
+
+ QScatterDataArray *dataArray = new QScatterDataArray;
+ dataArray->resize(numberOfItems);
+ QScatterDataItem *ptrToDataArray = &dataArray->first();
+ QScatterDataArray *dataArray2 = new QScatterDataArray;
+ dataArray2->resize(numberOfItems);
+ QScatterDataItem *ptrToDataArray2 = &dataArray2->first();
+
+#ifdef RANDOM_SCATTER
+ for (int i = 0; i < numberOfItems; i++) {
+ ptrToDataArray->setPosition(randVector());
+ ptrToDataArray++;
+ ptrToDataArray2->setPosition(randVector());
+ ptrToDataArray2++;
+ }
+#else
+ float limit = qSqrt(numberOfItems) / 2.0f;
+ for (float i = -limit; i < limit; i++) {
+ for (float j = -limit; j < limit; j++) {
+ ptrToDataArray->setPosition(QVector3D(i, qCos(qDegreesToRadians((i * j) / 7.5)), j));
+ ptrToDataArray++;
+ ptrToDataArray2->setPosition(QVector3D(i, qCos(qDegreesToRadians((i * j) / 7.5)) + 0.2, j));
+ ptrToDataArray2++;
+ }
+ }
+#endif
+
+ m_chart->seriesList().at(0)->dataProxy()->resetArray(dataArray);
+ m_chart->seriesList().at(1)->dataProxy()->resetArray(dataArray2);
+ m_chart->seriesList().at(0)->setItemSize(0.0f);
+ m_chart->seriesList().at(1)->setItemSize(0.0f);
+}
+
+void ScatterDataModifier::changeStyle()
+{
+ if (!m_targetSeries)
+ createAndAddSeries();
+
+ if (m_targetSeries->isMeshSmooth()) {
+ m_targetSeries->setMeshSmooth(false);
+ switch (m_targetSeries->mesh()) {
+ case QAbstract3DSeries::MeshCube:
+ m_targetSeries->setMesh(QAbstract3DSeries::MeshPyramid);
+ break;
+ case QAbstract3DSeries::MeshPyramid:
+ m_targetSeries->setMesh(QAbstract3DSeries::MeshCone);
+ break;
+ case QAbstract3DSeries::MeshCone:
+ m_targetSeries->setMesh(QAbstract3DSeries::MeshCylinder);
+ break;
+ case QAbstract3DSeries::MeshCylinder:
+ m_targetSeries->setMesh(QAbstract3DSeries::MeshBevelCube);
+ break;
+ case QAbstract3DSeries::MeshBevelCube:
+ m_targetSeries->setMesh(QAbstract3DSeries::MeshSphere);
+ break;
+ case QAbstract3DSeries::MeshSphere:
+ m_targetSeries->setMesh(QAbstract3DSeries::MeshMinimal);
+ break;
+ case QAbstract3DSeries::MeshMinimal:
+ m_targetSeries->setMesh(QAbstract3DSeries::MeshPoint);
+ break;
+ default:
+ m_targetSeries->setMesh(QAbstract3DSeries::MeshCube);
+ break;
+ }
+ } else {
+ m_targetSeries->setMeshSmooth(true);
+ }
+
+ qDebug() << __FUNCTION__ << m_targetSeries->mesh() << m_targetSeries->isMeshSmooth();
+}
+
+void ScatterDataModifier::changePresetCamera()
+{
+ static int preset = Q3DCamera::CameraPresetFrontLow;
+
+ m_chart->scene()->activeCamera()->setCameraPreset((Q3DCamera::CameraPreset)preset);
+
+ if (++preset > Q3DCamera::CameraPresetDirectlyAboveCCW45)
+ preset = Q3DCamera::CameraPresetFrontLow;
+}
+
+void ScatterDataModifier::changeTheme()
+{
+ static int theme = Q3DTheme::ThemeQt;
+
+ m_chart->activeTheme()->setType(Q3DTheme::Theme(theme));
+
+ if (++theme > Q3DTheme::ThemeIsabelle)
+ theme = Q3DTheme::ThemeQt;
+}
+
+void ScatterDataModifier::changeLabelStyle()
+{
+ m_chart->activeTheme()->setLabelBackgroundEnabled(!m_chart->activeTheme()->isLabelBackgroundEnabled());
+}
+
+void ScatterDataModifier::changeFont(const QFont &font)
+{
+ QFont newFont = font;
+ newFont.setPointSizeF(m_fontSize);
+ m_chart->activeTheme()->setFont(newFont);
+}
+
+void ScatterDataModifier::changeFontSize(int fontSize)
+{
+ m_fontSize = fontSize;
+ QFont font = m_chart->activeTheme()->font();
+ font.setPointSize(m_fontSize);
+ m_chart->activeTheme()->setFont(font);
+}
+
+void ScatterDataModifier::changePointSize(int pointSize)
+{
+ m_targetSeries->setItemSize(0.01f * float(pointSize));
+}
+
+void ScatterDataModifier::shadowQualityUpdatedByVisual(QAbstract3DGraph::ShadowQuality sq)
+{
+ int quality = int(sq);
+ // Updates the UI component to show correct shadow quality
+ emit shadowQualityChanged(quality);
+}
+
+void ScatterDataModifier::clear()
+{
+ foreach (QScatter3DSeries *series, m_chart->seriesList()) {
+ m_chart->removeSeries(series);
+ delete series;
+ }
+
+ m_targetSeries = 0;
+
+ qDebug() << m_loopCounter << "Cleared array";
+}
+
+void ScatterDataModifier::deleteAxis(QValue3DAxis *axis)
+{
+ m_chart->releaseAxis(axis);
+ delete axis;
+}
+
+void ScatterDataModifier::resetAxes()
+{
+ deleteAxis(m_chart->axisX());
+ deleteAxis(m_chart->axisY());
+ deleteAxis(m_chart->axisZ());
+
+ m_chart->setAxisX(new QValue3DAxis);
+ m_chart->setAxisY(new QValue3DAxis);
+ m_chart->setAxisZ(new QValue3DAxis);
+ m_chart->axisX()->setSegmentCount(6);
+ m_chart->axisY()->setSegmentCount(4);
+ m_chart->axisZ()->setSegmentCount(9);
+ m_chart->axisX()->setSubSegmentCount(2);
+ m_chart->axisY()->setSubSegmentCount(3);
+ m_chart->axisZ()->setSubSegmentCount(1);
+ m_chart->axisX()->setTitle("X");
+ m_chart->axisY()->setTitle("Y");
+ m_chart->axisZ()->setTitle("Z");
+}
+
+void ScatterDataModifier::addOne()
+{
+ if (!m_targetSeries)
+ createAndAddSeries();
+
+ QScatterDataItem item(randVector());
+ int addIndex = m_targetSeries->dataProxy()->addItem(item);
+ qDebug() << m_loopCounter << "added one to index:" << addIndex << "array size:" << m_targetSeries->dataProxy()->array()->size();
+}
+
+void ScatterDataModifier::addBunch()
+{
+ if (!m_targetSeries)
+ createAndAddSeries();
+
+ QScatterDataArray items(100);
+ for (int i = 0; i < items.size(); i++)
+ items[i].setPosition(randVector());
+ int addIndex = m_targetSeries->dataProxy()->addItems(items);
+ qDebug() << m_loopCounter << "added bunch to index:" << addIndex << "array size:" << m_targetSeries->dataProxy()->array()->size();
+}
+
+void ScatterDataModifier::insertOne()
+{
+ if (!m_targetSeries)
+ createAndAddSeries();
+
+ QScatterDataItem item(randVector());
+ m_targetSeries->dataProxy()->insertItem(0, item);
+ qDebug() << m_loopCounter << "Inserted one, array size:" << m_targetSeries->dataProxy()->array()->size();
+}
+
+void ScatterDataModifier::insertBunch()
+{
+ if (!m_targetSeries)
+ createAndAddSeries();
+
+ QScatterDataArray items(100);
+ for (int i = 0; i < items.size(); i++)
+ items[i].setPosition(randVector());
+ m_targetSeries->dataProxy()->insertItems(0, items);
+ qDebug() << m_loopCounter << "Inserted bunch, array size:" << m_targetSeries->dataProxy()->array()->size();
+}
+
+void ScatterDataModifier::changeOne()
+{
+ if (!m_targetSeries)
+ createAndAddSeries();
+
+ if (m_selectedItem >= 0 && m_selectedItem < m_targetSeries->dataProxy()->itemCount()) {
+ QScatterDataItem item(randVector());
+ m_targetSeries->dataProxy()->setItem(m_selectedItem, item);
+ qDebug() << m_loopCounter << "Changed one, array size:" << m_targetSeries->dataProxy()->array()->size();
+ }
+}
+
+void ScatterDataModifier::changeBunch()
+{
+ if (!m_targetSeries)
+ createAndAddSeries();
+
+ if (m_targetSeries->dataProxy()->array()->size()) {
+ int amount = qMin(m_targetSeries->dataProxy()->array()->size(), 100);
+ QScatterDataArray items(amount);
+ for (int i = 0; i < items.size(); i++) {
+ items[i].setPosition(randVector());
+ // Change the Y-values of first few items to exact gradient boundaries
+ if (i == 0)
+ items[i].setY(0.65f);
+ else if (i == 1)
+ items[i].setY(0.1f);
+ else if (i == 2)
+ items[i].setY(-0.45f);
+ else if (i == 3)
+ items[i].setY(-1.0f);
+ else if (i == 4)
+ items[i].setY(1.2f);
+// else
+// items[i].setY(0.1001f - (0.00001f * float(i)));
+
+ }
+
+ m_targetSeries->dataProxy()->setItems(0, items);
+ qDebug() << m_loopCounter << "Changed bunch, array size:" << m_targetSeries->dataProxy()->array()->size();
+ }
+}
+
+void ScatterDataModifier::removeOne()
+{
+ if (!m_targetSeries)
+ createAndAddSeries();
+
+ if (m_selectedItem >= 0) {
+ m_targetSeries->dataProxy()->removeItems(m_selectedItem, 1);
+ qDebug() << m_loopCounter << "Removed one, array size:" << m_targetSeries->dataProxy()->array()->size();
+ }
+}
+
+void ScatterDataModifier::removeBunch()
+{
+ if (!m_targetSeries)
+ createAndAddSeries();
+
+ m_targetSeries->dataProxy()->removeItems(0, 100);
+ qDebug() << m_loopCounter << "Removed bunch, array size:" << m_targetSeries->dataProxy()->array()->size();
+}
+
+void ScatterDataModifier::timeout()
+{
+ int doWhat = rand() % 10;
+ if (!(rand() % 100))
+ doWhat = -1;
+
+ switch (doWhat) {
+ case 0:
+ addOne();
+ break;
+ case 1:
+ addBunch();
+ break;
+ case 2:
+ insertOne();
+ break;
+ case 3:
+ insertBunch();
+ break;
+ case 4:
+ changeOne();
+ break;
+ case 5:
+ changeBunch();
+ break;
+ case 6:
+ removeOne();
+ break;
+ case 7:
+ removeBunch();
+ break;
+ case 8:
+ addSeries();
+ break;
+ case 9:
+ if (m_chart->seriesList().size())
+ m_targetSeries = m_chart->seriesList().at(rand() % m_chart->seriesList().size());
+ else
+ addSeries();
+ break;
+ default:
+ clear();
+ break;
+ }
+
+ m_loopCounter++;
+}
+
+void ScatterDataModifier::startStopTimer()
+{
+ if (m_timer.isActive()) {
+ m_timer.stop();
+ } else {
+ clear();
+ m_loopCounter = 0;
+ m_timer.start(0);
+ }
+}
+
+void ScatterDataModifier::selectItem()
+{
+ if (!m_targetSeries)
+ createAndAddSeries();
+
+ int targetItem(3);
+ int noSelection(-1);
+ if (m_selectedItem != targetItem || m_targetSeries != m_chart->seriesList().at(0))
+ m_chart->seriesList().at(0)->setSelectedItem(targetItem);
+ else
+ m_chart->seriesList().at(0)->setSelectedItem(noSelection);
+}
+
+void ScatterDataModifier::handleSelectionChange(int index)
+{
+ m_selectedItem = index;
+ m_targetSeries = static_cast<QScatter3DSeries *>(sender());
+ int seriesIndex = 0;
+ foreach (QScatter3DSeries *series, m_chart->seriesList()) {
+ if (series == sender())
+ break;
+ seriesIndex++;
+ }
+
+ qDebug() << "Selected item index:" << index << "series:" << seriesIndex;
+}
+
+void ScatterDataModifier::setGradient()
+{
+ QLinearGradient baseGradient(0, 0, 1, 100);
+ baseGradient.setColorAt(1.0, Qt::lightGray);
+ baseGradient.setColorAt(0.75001, Qt::lightGray);
+ baseGradient.setColorAt(0.75, Qt::blue);
+ baseGradient.setColorAt(0.50001, Qt::blue);
+ baseGradient.setColorAt(0.50, Qt::red);
+ baseGradient.setColorAt(0.25001, Qt::red);
+ baseGradient.setColorAt(0.25, Qt::yellow);
+ baseGradient.setColorAt(0.0, Qt::yellow);
+
+ QLinearGradient singleHighlightGradient(0, 0, 1, 100);
+ singleHighlightGradient.setColorAt(1.0, Qt::lightGray);
+ singleHighlightGradient.setColorAt(0.75, Qt::blue);
+ singleHighlightGradient.setColorAt(0.50, Qt::red);
+ singleHighlightGradient.setColorAt(0.25, Qt::yellow);
+ singleHighlightGradient.setColorAt(0.0, Qt::white);
+
+ if (m_targetSeries) {
+ m_targetSeries->setBaseColor(Qt::green);
+ m_targetSeries->setSingleHighlightColor(Qt::white);
+
+ m_targetSeries->setBaseGradient(baseGradient);
+ m_targetSeries->setSingleHighlightGradient(singleHighlightGradient);
+
+ Q3DTheme::ColorStyle oldStyle = m_targetSeries->colorStyle();
+ if (oldStyle == Q3DTheme::ColorStyleUniform)
+ m_targetSeries->setColorStyle(Q3DTheme::ColorStyleObjectGradient);
+ else if (oldStyle == Q3DTheme::ColorStyleObjectGradient)
+ m_targetSeries->setColorStyle(Q3DTheme::ColorStyleRangeGradient);
+ if (oldStyle == Q3DTheme::ColorStyleRangeGradient)
+ m_targetSeries->setColorStyle(Q3DTheme::ColorStyleUniform);
+ }
+}
+
+void ScatterDataModifier::clearSeriesData()
+{
+ if (m_targetSeries)
+ m_targetSeries->dataProxy()->resetArray(0);
+}
+
+void ScatterDataModifier::addSeries()
+{
+ QScatter3DSeries *series = createAndAddSeries();
+
+ QScatter3DSeries *oldTargetSeries = m_targetSeries;
+ m_targetSeries = series; // adding always adds to target series, so fake it for a bit
+ addOne(); // add one random item to start the new series off
+ m_targetSeries = oldTargetSeries;
+}
+
+void ScatterDataModifier::removeSeries()
+{
+ if (m_targetSeries) {
+ m_chart->removeSeries(m_targetSeries);
+ delete m_targetSeries;
+ if (m_chart->seriesList().size())
+ m_targetSeries = m_chart->seriesList().at(0);
+ else
+ m_targetSeries = 0;
+ }
+}
+
+void ScatterDataModifier::toggleSeriesVisibility()
+{
+ if (m_targetSeries)
+ m_targetSeries->setVisible(!m_targetSeries->isVisible());
+}
+
+void ScatterDataModifier::changeSeriesName()
+{
+ if (m_targetSeries)
+ m_targetSeries->setName(m_targetSeries->name().append("-").append(QString::number(qrand() % 10)));
+}
+
+void ScatterDataModifier::handleAxisXChanged(QValue3DAxis *axis)
+{
+ qDebug() << __FUNCTION__ << axis << axis->orientation() << (axis == m_chart->axisX());
+}
+
+void ScatterDataModifier::handleAxisYChanged(QValue3DAxis *axis)
+{
+ qDebug() << __FUNCTION__ << axis << axis->orientation() << (axis == m_chart->axisY());
+}
+
+void ScatterDataModifier::handleAxisZChanged(QValue3DAxis *axis)
+{
+ qDebug() << __FUNCTION__ << axis << axis->orientation() << (axis == m_chart->axisZ());
+}
+
+void ScatterDataModifier::handleFpsChange(qreal fps)
+{
+ static const QString fpsPrefix(QStringLiteral("FPS: "));
+ m_fpsLabel->setText(fpsPrefix + QString::number(qRound(fps)));
+}
+
+void ScatterDataModifier::changeLabelRotation(int rotation)
+{
+ m_chart->axisX()->setLabelAutoRotation(float(rotation));
+ m_chart->axisY()->setLabelAutoRotation(float(rotation));
+ m_chart->axisZ()->setLabelAutoRotation(float(rotation));
+}
+
+void ScatterDataModifier::changeRadialLabelOffset(int offset)
+{
+ m_chart->setRadialLabelOffset(float(offset) / 100.0f);
+}
+
+void ScatterDataModifier::toggleAxisTitleVisibility(bool enabled)
+{
+ m_chart->axisX()->setTitleVisible(enabled);
+ m_chart->axisY()->setTitleVisible(enabled);
+ m_chart->axisZ()->setTitleVisible(enabled);
+}
+
+void ScatterDataModifier::toggleAxisTitleFixed(bool enabled)
+{
+ m_chart->axisX()->setTitleFixed(enabled);
+ m_chart->axisY()->setTitleFixed(enabled);
+ m_chart->axisZ()->setTitleFixed(enabled);
+}
+
+void ScatterDataModifier::renderToImage()
+{
+ QImage renderedImage8AA = m_chart->renderToImage(8);
+ QImage renderedImageNoAA = m_chart->renderToImage(0);
+ QImage renderedImage8AASmall = m_chart->renderToImage(8, QSize(100, 100));
+ QImage renderedImageNoAASmall = m_chart->renderToImage(0, QSize(100, 100));
+
+ if (m_chart->isVisible()) {
+ renderedImage8AA.save(QStringLiteral("./renderedImage8AA_visible.png"));
+ renderedImageNoAA.save(QStringLiteral("./renderedImageNoAA_visible.png"));
+ renderedImage8AASmall.save(QStringLiteral("./renderedImage8AASmall_visible.png"));
+ renderedImageNoAASmall.save(QStringLiteral("./renderedImageNoAASmall_visible.png"));
+ qDebug() << "Visible images rendered!";
+ } else {
+ renderedImage8AA.save(QStringLiteral("./renderedImage8AA_hidden.png"));
+ renderedImageNoAA.save(QStringLiteral("./renderedImageNoAA_hidden.png"));
+ renderedImage8AASmall.save(QStringLiteral("./renderedImage8AASmall_hidden.png"));
+ renderedImageNoAASmall.save(QStringLiteral("./renderedImageNoAASmall_hidden.png"));
+ qDebug() << "Hidden images rendered!";
+ }
+}
+
+void ScatterDataModifier::togglePolar(bool enable)
+{
+ m_chart->setPolar(enable);
+}
+
+void ScatterDataModifier::toggleStatic(bool enable)
+{
+ if (enable)
+ m_chart->setOptimizationHints(QAbstract3DGraph::OptimizationStatic);
+ else
+ m_chart->setOptimizationHints(QAbstract3DGraph::OptimizationDefault);
+}
+
+void ScatterDataModifier::toggleOrtho(bool enable)
+{
+ m_chart->setOrthoProjection(enable);
+}
+
+void ScatterDataModifier::setCameraTargetX(int value)
+{
+ // Value is (-100, 100), normalize
+ m_cameraTarget.setX(float(value) / 100.0f);
+ m_chart->scene()->activeCamera()->setTarget(m_cameraTarget);
+ qDebug() << "m_cameraTarget:" << m_cameraTarget;
+}
+
+void ScatterDataModifier::setCameraTargetY(int value)
+{
+ // Value is (-100, 100), normalize
+ m_cameraTarget.setY(float(value) / 100.0f);
+ m_chart->scene()->activeCamera()->setTarget(m_cameraTarget);
+ qDebug() << "m_cameraTarget:" << m_cameraTarget;
+}
+
+void ScatterDataModifier::setCameraTargetZ(int value)
+{
+ // Value is (-100, 100), normalize
+ m_cameraTarget.setZ(float(value) / 100.0f);
+ m_chart->scene()->activeCamera()->setTarget(m_cameraTarget);
+ qDebug() << "m_cameraTarget:" << m_cameraTarget;
+}
+
+void ScatterDataModifier::setGraphMargin(int value)
+{
+ m_chart->setMargin(qreal(value) / 100.0);
+ qDebug() << "Setting margin:" << m_chart->margin() << value;
+}
+
+void ScatterDataModifier::changeShadowQuality(int quality)
+{
+ QAbstract3DGraph::ShadowQuality sq = QAbstract3DGraph::ShadowQuality(quality);
+ m_chart->setShadowQuality(sq);
+ emit shadowQualityChanged(quality);
+}
+
+void ScatterDataModifier::setBackgroundEnabled(int enabled)
+{
+ m_chart->activeTheme()->setBackgroundEnabled((bool)enabled);
+}
+
+void ScatterDataModifier::setGridEnabled(int enabled)
+{
+ m_chart->activeTheme()->setGridEnabled((bool)enabled);
+}
+
+void ScatterDataModifier::setMinX(int min)
+{
+ m_chart->axisX()->setMin(min);
+}
+
+void ScatterDataModifier::setMinY(int min)
+{
+ m_chart->axisY()->setMin(float(min) / 100.0f);
+}
+
+void ScatterDataModifier::setMinZ(int min)
+{
+ m_chart->axisZ()->setMin(min);
+}
+
+void ScatterDataModifier::setMaxX(int max)
+{
+ m_chart->axisX()->setMax(max);
+}
+
+void ScatterDataModifier::setMaxY(int max)
+{
+ m_chart->axisY()->setMax(float(max) / 100.0f);
+}
+
+void ScatterDataModifier::setMaxZ(int max)
+{
+ m_chart->axisZ()->setMax(max);
+}
+
+void ScatterDataModifier::setAspectRatio(int ratio)
+{
+ qreal aspectRatio = qreal(ratio) / 10.0;
+ m_chart->setAspectRatio(aspectRatio);
+}
+
+void ScatterDataModifier::setHorizontalAspectRatio(int ratio)
+{
+ qreal aspectRatio = qreal(ratio) / 100.0;
+ m_chart->setHorizontalAspectRatio(aspectRatio);
+}
+
+QVector3D ScatterDataModifier::randVector()
+{
+ QVector3D retvec = QVector3D(
+ (float)(rand() % 100) / 2.0f - (float)(rand() % 100) / 2.0f,
+ (float)(rand() % 100) / 100.0f - (float)(rand() % 100) / 100.0f,
+ (float)(rand() % 100) / 2.0f - (float)(rand() % 100) / 2.0f);
+
+ qDebug() << __FUNCTION__ << retvec;
+
+ return retvec;
+}
+
+QScatter3DSeries *ScatterDataModifier::createAndAddSeries()
+{
+ static int counter = 0;
+
+ QScatter3DSeries *series = new QScatter3DSeries;
+
+ if (!m_targetSeries)
+ m_targetSeries = series;
+
+ m_chart->addSeries(series);
+ series->setName(QString("Series %1").arg(counter++));
+ series->setItemLabelFormat(QStringLiteral("@seriesName: (X:@xLabel / Z:@zLabel) Y:@yLabel"));
+ series->setMesh(QAbstract3DSeries::MeshSphere);
+ series->setMeshSmooth(true);
+ series->setBaseColor(QColor(rand() % 256, rand() % 256, rand() % 256));
+ series->setItemSize(float(rand() % 90 + 10) / 100.0f);
+
+ QObject::connect(series, &QScatter3DSeries::selectedItemChanged, this,
+ &ScatterDataModifier::handleSelectionChange);
+
+ return series;
+}
+
+void ScatterDataModifier::populateFlatSeries(QScatter3DSeries *series, int rows, int columns,
+ float value)
+{
+ QScatterDataArray *dataArray = new QScatterDataArray;
+ dataArray->resize(rows * columns);
+ for (int i = 0; i < rows; i++) {
+ for (int j = 0; j < columns; j++)
+ (*dataArray)[i * columns + j].setPosition(QVector3D(float(i), value, float(j)));
+ }
+ series->dataProxy()->resetArray(dataArray);
+}
+
+void ScatterDataModifier::populateRisingSeries(QScatter3DSeries *series, int rows, int columns,
+ float minValue, float maxValue)
+{
+ QScatterDataArray *dataArray = new QScatterDataArray;
+ int arraySize = rows * columns;
+ dataArray->resize(arraySize);
+ float range = maxValue - minValue;
+ for (int i = 0; i < rows; i++) {
+ for (int j = 0; j < columns; j++) {
+ float yValue = minValue + (range * i * j / arraySize);
+ (*dataArray)[i * columns + j].setPosition(QVector3D(float(i), yValue, float(j)));
+ }
+ }
+ series->dataProxy()->resetArray(dataArray);
+}
diff --git a/tests/manual/scattertest/scatterchart.h b/tests/manual/scattertest/scatterchart.h
new file mode 100644
index 00000000..2def639e
--- /dev/null
+++ b/tests/manual/scattertest/scatterchart.h
@@ -0,0 +1,132 @@
+/******************************************************************************
+**
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the Qt Data Visualization module.
+**
+** $QT_BEGIN_LICENSE:COMM$
+**
+** 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 http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** $QT_END_LICENSE$
+**
+******************************************************************************/
+
+#ifndef SCATTERDATAMODIFIER_H
+#define SCATTERDATAMODIFIER_H
+
+#include <QtDataVisualization/q3dscatter.h>
+#include <QtDataVisualization/qscatter3dseries.h>
+
+#include <QFont>
+#include <QDebug>
+#include <QTimer>
+#include <QLabel>
+
+using namespace QtDataVisualization;
+
+class ScatterDataModifier : public QObject
+{
+ Q_OBJECT
+public:
+ explicit ScatterDataModifier(Q3DScatter *scatter);
+ ~ScatterDataModifier();
+
+ void addData();
+ void changeStyle();
+ void changePresetCamera();
+ void changeTheme();
+ void changeLabelStyle();
+ void changeFont(const QFont &font);
+ void changeFontSize(int fontSize);
+ void changePointSize(int pointSize);
+ void setBackgroundEnabled(int enabled);
+ void setGridEnabled(int enabled);
+ void setMinX(int min);
+ void setMinY(int min);
+ void setMinZ(int min);
+ void setMaxX(int max);
+ void setMaxY(int max);
+ void setMaxZ(int max);
+ void setAspectRatio(int ratio);
+ void setHorizontalAspectRatio(int ratio);
+ void start();
+ void massiveDataTest();
+ void massiveTestScroll();
+ void massiveTestAppendAndScroll();
+ void setFpsMeasurement(bool enable);
+ void setFpsLabel(QLabel *fpsLabel) { m_fpsLabel = fpsLabel; }
+ void testItemChanges();
+ void testAxisReverse();
+
+public Q_SLOTS:
+ void changeShadowQuality(int quality);
+ void shadowQualityUpdatedByVisual(QAbstract3DGraph::ShadowQuality shadowQuality);
+ void clear();
+ void resetAxes();
+ void addOne();
+ void addBunch();
+ void insertOne();
+ void insertBunch();
+ void changeOne();
+ void changeBunch();
+ void removeOne();
+ void removeBunch();
+ void timeout();
+ void startStopTimer();
+ void selectItem();
+ void handleSelectionChange(int index);
+ void setGradient();
+ void clearSeriesData();
+ void addSeries();
+ void removeSeries();
+ void toggleSeriesVisibility();
+ void changeSeriesName();
+ void handleAxisXChanged(QValue3DAxis *axis);
+ void handleAxisYChanged(QValue3DAxis *axis);
+ void handleAxisZChanged(QValue3DAxis *axis);
+ void handleFpsChange(qreal fps);
+ void changeLabelRotation(int rotation);
+ void changeRadialLabelOffset(int offset);
+ void toggleAxisTitleVisibility(bool enabled);
+ void toggleAxisTitleFixed(bool enabled);
+ void renderToImage();
+ void togglePolar(bool enable);
+ void toggleStatic(bool enable);
+ void toggleOrtho(bool enable);
+ void setCameraTargetX(int value);
+ void setCameraTargetY(int value);
+ void setCameraTargetZ(int value);
+ void setGraphMargin(int value);
+
+Q_SIGNALS:
+ void shadowQualityChanged(int quality);
+
+private:
+ QVector3D randVector();
+ QScatter3DSeries *createAndAddSeries();
+ void populateFlatSeries(QScatter3DSeries *series, int rows, int columns, float value);
+ void populateRisingSeries(QScatter3DSeries *series, int rows, int columns, float minValue,
+ float maxValue);
+ void deleteAxis(QValue3DAxis *axis);
+
+ Q3DScatter *m_chart;
+ int m_fontSize;
+ QTimer m_timer;
+ int m_loopCounter;
+ int m_selectedItem;
+ QScatter3DSeries *m_targetSeries;
+ QScatterDataArray m_massiveTestCacheArray;
+ QLabel *m_fpsLabel;
+ QVector3D m_cameraTarget;
+
+};
+
+#endif
diff --git a/tests/manual/scattertest/scattertest.pro b/tests/manual/scattertest/scattertest.pro
new file mode 100644
index 00000000..4fec5b34
--- /dev/null
+++ b/tests/manual/scattertest/scattertest.pro
@@ -0,0 +1,8 @@
+!include( ../tests.pri ) {
+ error( "Couldn't find the tests.pri file!" )
+}
+
+SOURCES += main.cpp scatterchart.cpp
+HEADERS += scatterchart.h
+
+QT += widgets
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-06 14:04:19 +0000