mirror of https://github.com/qt/qtgraphs.git
1247 lines
41 KiB
C++
1247 lines
41 KiB
C++
// Copyright (C) 2023 The Qt Company Ltd.
|
|
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
|
|
|
|
#include "scatterchart.h"
|
|
#include <QtGraphs/qscatterdataproxy.h>
|
|
#include <QtGraphs/qscatter3dseries.h>
|
|
#include <QtGraphs/qvalue3daxis.h>
|
|
#include <QtGraphs/q3dscene.h>
|
|
#include <QtGraphs/qgraphstheme.h>
|
|
#include <qmath.h>
|
|
#include <qrandom.h>
|
|
|
|
//#define RANDOM_SCATTER
|
|
|
|
const int numberOfItems = 10000;
|
|
|
|
ScatterDataModifier::ScatterDataModifier(Q3DScatterWidgetItem *scatter)
|
|
: m_chart(scatter),
|
|
m_fontSize(30.0f),
|
|
m_loopCounter(0),
|
|
m_selectedItem(-1),
|
|
m_targetSeries(0)
|
|
{
|
|
m_chart->activeTheme()->setTheme(QGraphsTheme::Theme::QtGreen);
|
|
QFont font = m_chart->activeTheme()->labelFont();
|
|
font.setPointSize(m_fontSize);
|
|
m_chart->activeTheme()->setLabelFont(font);
|
|
m_chart->setShadowQuality(QtGraphs3D::ShadowQuality::None);
|
|
m_chart->setCameraPreset(QtGraphs3D::CameraPreset::Front);
|
|
m_chart->setAxisX(new QValue3DAxis);
|
|
m_chart->setAxisY(new QValue3DAxis);
|
|
m_chart->setAxisZ(new QValue3DAxis);
|
|
m_chart->axisY()->setLabelFormat(QStringLiteral("%.7f"));
|
|
m_chart->setZoomAtTargetEnabled(true);
|
|
|
|
createAndAddSeries();
|
|
createAndAddSeries();
|
|
|
|
m_chart->setSelectionMode(QtGraphs3D::SelectionFlag::Item);
|
|
|
|
QObject::connect(&m_timer, &QTimer::timeout, this, &ScatterDataModifier::timeout);
|
|
QObject::connect(m_chart, &Q3DScatterWidgetItem::shadowQualityChanged, this,
|
|
&ScatterDataModifier::shadowQualityUpdatedByVisual);
|
|
|
|
QObject::connect(m_chart, &Q3DScatterWidgetItem::axisXChanged, this,
|
|
&ScatterDataModifier::handleAxisXChanged);
|
|
QObject::connect(m_chart, &Q3DScatterWidgetItem::axisYChanged, this,
|
|
&ScatterDataModifier::handleAxisYChanged);
|
|
QObject::connect(m_chart, &Q3DScatterWidgetItem::axisZChanged, this,
|
|
&ScatterDataModifier::handleAxisZChanged);
|
|
QObject::connect(m_chart,
|
|
&Q3DGraphsWidgetItem::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 * (QRandomGenerator::global()->bounded(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(QRandomGenerator::global()->bounded(100)) / (100 / yRangeMargin);
|
|
m_massiveTestCacheArray[totalIndex].setPosition(
|
|
QVector3D(float(QRandomGenerator::global()->bounded(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->setCameraPreset(QtGraphs3D::CameraPreset::Right);
|
|
m_chart->setShadowQuality(QtGraphs3D::ShadowQuality::None);
|
|
const auto scatteriesList = m_chart->seriesList();
|
|
for (const auto &series : scatteriesList)
|
|
m_chart->removeSeries(static_cast<QScatter3DSeries *>(series));
|
|
|
|
qDebug() << __FUNCTION__ << testPhase << ": Creating massive array..." << items;
|
|
QScatterDataArray massiveArray;
|
|
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::Mesh::Point);
|
|
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(int enable)
|
|
{
|
|
m_chart->setMeasureFps(enable != 0);
|
|
}
|
|
|
|
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";
|
|
const auto scatterSeriesList = m_chart->seriesList();
|
|
for (const auto &series : scatterSeriesList)
|
|
m_chart->removeSeries(series);
|
|
const auto &axes = m_chart->axes();
|
|
for (const auto &axis : 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";
|
|
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";
|
|
const auto scatterSeriesList = m_chart->seriesList();
|
|
for (const auto &series : scatterSeriesList)
|
|
m_chart->removeSeries(series);
|
|
const auto &axes = m_chart->axes();
|
|
for (const auto &axis : 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::testNanSeries()
|
|
{
|
|
static bool initialized = false;
|
|
const int rowCount = 16;
|
|
const int colCount = 16;
|
|
static QScatter3DSeries *series = 0;
|
|
|
|
if (!initialized) {
|
|
series = new QScatter3DSeries;
|
|
populateNanSeries(series, rowCount, colCount, 10.0f);
|
|
m_chart->addSeries(series);
|
|
initialized = true;
|
|
} else {
|
|
m_chart->removeSeries(series);
|
|
delete series;
|
|
initialized = false;
|
|
}
|
|
}
|
|
|
|
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;
|
|
dataArray.resize(numberOfItems);
|
|
QScatterDataItem *ptrToDataArray = &dataArray.first();
|
|
QScatterDataArray dataArray2;
|
|
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::Mesh::Cube:
|
|
m_targetSeries->setMesh(QAbstract3DSeries::Mesh::Pyramid);
|
|
break;
|
|
case QAbstract3DSeries::Mesh::Pyramid:
|
|
m_targetSeries->setMesh(QAbstract3DSeries::Mesh::Cone);
|
|
break;
|
|
case QAbstract3DSeries::Mesh::Cone:
|
|
m_targetSeries->setMesh(QAbstract3DSeries::Mesh::Cylinder);
|
|
break;
|
|
case QAbstract3DSeries::Mesh::Cylinder:
|
|
m_targetSeries->setMesh(QAbstract3DSeries::Mesh::BevelCube);
|
|
break;
|
|
case QAbstract3DSeries::Mesh::BevelCube:
|
|
m_targetSeries->setMesh(QAbstract3DSeries::Mesh::Sphere);
|
|
break;
|
|
case QAbstract3DSeries::Mesh::Sphere:
|
|
m_targetSeries->setMesh(QAbstract3DSeries::Mesh::Minimal);
|
|
break;
|
|
case QAbstract3DSeries::Mesh::Minimal:
|
|
m_targetSeries->setMesh(QAbstract3DSeries::Mesh::Point);
|
|
break;
|
|
default:
|
|
m_targetSeries->setMesh(QAbstract3DSeries::Mesh::Cube);
|
|
break;
|
|
}
|
|
} else {
|
|
m_targetSeries->setMeshSmooth(true);
|
|
}
|
|
|
|
qDebug() << __FUNCTION__ << m_targetSeries->mesh() << m_targetSeries->isMeshSmooth();
|
|
}
|
|
|
|
void ScatterDataModifier::changePresetCamera()
|
|
{
|
|
static int preset = int(QtGraphs3D::CameraPreset::FrontLow);
|
|
|
|
m_chart->setCameraPreset((QtGraphs3D::CameraPreset) preset);
|
|
|
|
if (++preset > int(QtGraphs3D::CameraPreset::DirectlyAboveCCW45))
|
|
preset = int(QtGraphs3D::CameraPreset::FrontLow);
|
|
}
|
|
|
|
void ScatterDataModifier::changeTheme()
|
|
{
|
|
static int theme = int(QGraphsTheme::Theme::QtGreen);
|
|
|
|
m_chart->activeTheme()->setTheme(QGraphsTheme::Theme(theme));
|
|
|
|
if (++theme > int(QGraphsTheme::Theme::UserDefined))
|
|
theme = int(QGraphsTheme::Theme::QtGreen);
|
|
}
|
|
|
|
void ScatterDataModifier::changeLabelStyle()
|
|
{
|
|
m_chart->activeTheme()->setLabelBackgroundVisible(
|
|
!m_chart->activeTheme()->isLabelBackgroundVisible());
|
|
}
|
|
|
|
void ScatterDataModifier::changeFont(const QFont &font)
|
|
{
|
|
QFont newFont = font;
|
|
newFont.setPointSizeF(m_fontSize);
|
|
m_chart->activeTheme()->setLabelFont(newFont);
|
|
}
|
|
|
|
void ScatterDataModifier::changeFontSize(int fontSize)
|
|
{
|
|
m_fontSize = fontSize;
|
|
QFont font = m_chart->activeTheme()->labelFont();
|
|
font.setPointSize(m_fontSize);
|
|
m_chart->activeTheme()->setLabelFont(font);
|
|
}
|
|
|
|
void ScatterDataModifier::changeLabelSize(int labelSize)
|
|
{
|
|
m_chart->axisX()->setLabelSize(float(labelSize) * 0.1);
|
|
m_chart->axisY()->setLabelSize(float(labelSize) * 0.1);
|
|
m_chart->axisZ()->setLabelSize(float(labelSize) * 0.1);
|
|
}
|
|
|
|
void ScatterDataModifier::changePointSize(int pointSize)
|
|
{
|
|
m_targetSeries->setItemSize(0.01f * float(pointSize));
|
|
}
|
|
|
|
void ScatterDataModifier::shadowQualityUpdatedByVisual(QtGraphs3D::ShadowQuality sq)
|
|
{
|
|
int quality = int(sq);
|
|
// Updates the UI component to show correct shadow quality
|
|
emit shadowQualityChanged(quality);
|
|
}
|
|
|
|
void ScatterDataModifier::changeLightingMode(int mode)
|
|
{
|
|
m_targetSeries->setLightingMode(static_cast<QAbstract3DSeries::LightingMode>(mode));
|
|
}
|
|
|
|
void ScatterDataModifier::clear()
|
|
{
|
|
const auto scatterSeriesList = m_chart->seriesList();
|
|
for (const auto &series : scatterSeriesList) {
|
|
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->dataArray().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->dataArray().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->dataArray().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->dataArray().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->dataArray().size();
|
|
}
|
|
}
|
|
|
|
void ScatterDataModifier::changeBunch()
|
|
{
|
|
if (!m_targetSeries)
|
|
createAndAddSeries();
|
|
|
|
if (m_targetSeries->dataArray().size()) {
|
|
int amount = qMin(m_targetSeries->dataArray().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->dataArray().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->dataArray().size();
|
|
}
|
|
}
|
|
|
|
void ScatterDataModifier::removeBunch()
|
|
{
|
|
if (!m_targetSeries)
|
|
createAndAddSeries();
|
|
|
|
m_targetSeries->dataProxy()->removeItems(0, 100);
|
|
qDebug() << m_loopCounter << "Removed bunch, array size:" << m_targetSeries->dataArray().size();
|
|
}
|
|
|
|
void ScatterDataModifier::timeout()
|
|
{
|
|
int doWhat = QRandomGenerator::global()->bounded(10);
|
|
if (!(QRandomGenerator::global()->bounded(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(QRandomGenerator::global()->bounded(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(qsizetype index)
|
|
{
|
|
m_selectedItem = index;
|
|
m_targetSeries = static_cast<QScatter3DSeries *>(sender());
|
|
int seriesIndex = 0;
|
|
|
|
const auto scatterSeriesList = m_chart->seriesList();
|
|
for (const auto &series : scatterSeriesList) {
|
|
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);
|
|
|
|
QGraphsTheme::ColorStyle oldStyle = m_targetSeries->colorStyle();
|
|
if (oldStyle == QGraphsTheme::ColorStyle::Uniform)
|
|
m_targetSeries->setColorStyle(QGraphsTheme::ColorStyle::ObjectGradient);
|
|
else if (oldStyle == QGraphsTheme::ColorStyle::ObjectGradient)
|
|
m_targetSeries->setColorStyle(QGraphsTheme::ColorStyle::RangeGradient);
|
|
if (oldStyle == QGraphsTheme::ColorStyle::RangeGradient)
|
|
m_targetSeries->setColorStyle(QGraphsTheme::ColorStyle::Uniform);
|
|
}
|
|
}
|
|
|
|
void ScatterDataModifier::clearSeriesData()
|
|
{
|
|
if (m_targetSeries)
|
|
m_targetSeries->dataProxy()->resetArray();
|
|
}
|
|
|
|
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(QRandomGenerator::global()->bounded(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(int fps)
|
|
{
|
|
static const QString fpsPrefix(QStringLiteral("FPS: "));
|
|
m_fpsLabel->setText(fpsPrefix + QString::number(fps));
|
|
}
|
|
|
|
void ScatterDataModifier::changeLabelRotation(int rotation)
|
|
{
|
|
m_chart->axisX()->setLabelAutoAngle(float(rotation));
|
|
m_chart->axisY()->setLabelAutoAngle(float(rotation));
|
|
m_chart->axisZ()->setLabelAutoAngle(float(rotation));
|
|
}
|
|
|
|
void ScatterDataModifier::changeTitleOffset(int offset)
|
|
{
|
|
m_chart->axisX()->setTitleOffset(float(offset) / 100);
|
|
m_chart->axisY()->setTitleOffset(float(offset) / 100);
|
|
m_chart->axisZ()->setTitleOffset(float(offset) / 100);
|
|
}
|
|
|
|
void ScatterDataModifier::changeRadialLabelOffset(int offset)
|
|
{
|
|
m_chart->setRadialLabelOffset(float(offset) / 100.0f);
|
|
}
|
|
|
|
void ScatterDataModifier::toggleAxisTitleVisibility(int enabled)
|
|
{
|
|
m_chart->axisX()->setTitleVisible(enabled);
|
|
m_chart->axisY()->setTitleVisible(enabled);
|
|
m_chart->axisZ()->setTitleVisible(enabled);
|
|
}
|
|
|
|
void ScatterDataModifier::toggleAxisTitleFixed(int enabled)
|
|
{
|
|
m_chart->axisX()->setTitleFixed(enabled);
|
|
m_chart->axisY()->setTitleFixed(enabled);
|
|
m_chart->axisZ()->setTitleFixed(enabled);
|
|
}
|
|
|
|
void ScatterDataModifier::toggleLabelAdjustment(int enabled)
|
|
{
|
|
m_chart->axisX()->setScaleLabelsByCount(enabled);
|
|
m_chart->axisY()->setScaleLabelsByCount(enabled);
|
|
m_chart->axisZ()->setScaleLabelsByCount(enabled);
|
|
}
|
|
|
|
void ScatterDataModifier::renderToImage()
|
|
{
|
|
QSharedPointer<QQuickItemGrabResult> grabResult = m_chart->renderToImage(QSize());
|
|
QObject::connect(grabResult.data(), &QQuickItemGrabResult::ready, this, [grabResult]() {
|
|
grabResult.data()->image().save("./renderedImage.png");
|
|
});
|
|
|
|
QSharedPointer<QQuickItemGrabResult> grabResult2 = m_chart->renderToImage(QSize(100, 100));
|
|
QObject::connect(grabResult2.data(), &QQuickItemGrabResult::ready, this, [grabResult2]() {
|
|
grabResult2.data()->image().save("./renderedImageSmall.png");
|
|
});
|
|
}
|
|
|
|
void ScatterDataModifier::togglePolar(int enable)
|
|
{
|
|
m_chart->setPolar(enable);
|
|
}
|
|
|
|
void ScatterDataModifier::toggleLegacy(int enable)
|
|
{
|
|
if (!enable)
|
|
m_chart->setOptimizationHint(QtGraphs3D::OptimizationHint::Default);
|
|
else
|
|
m_chart->setOptimizationHint(QtGraphs3D::OptimizationHint::Legacy);
|
|
}
|
|
|
|
void ScatterDataModifier::toggleOrtho(int enable)
|
|
{
|
|
m_chart->setOrthoProjection(enable);
|
|
}
|
|
|
|
void ScatterDataModifier::setCameraTargetX(int value)
|
|
{
|
|
// Value is (-100, 100), normalize
|
|
m_cameraTarget.setX(float(value) / 100.0f);
|
|
m_chart->setCameraTargetPosition(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->setCameraTargetPosition(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->setCameraTargetPosition(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::setXAxisSegemntCount(int count)
|
|
{
|
|
m_chart->axisX()->setSegmentCount(count);
|
|
}
|
|
void ScatterDataModifier::setYAxisSegemntCount(int count)
|
|
{
|
|
m_chart->axisY()->setSegmentCount(count);
|
|
}
|
|
void ScatterDataModifier::setZAxisSegemntCount(int count)
|
|
{
|
|
m_chart->axisZ()->setSegmentCount(count);
|
|
}
|
|
|
|
void ScatterDataModifier::setXAxisSubsegemntCount(int count)
|
|
{
|
|
m_chart->axisX()->setSubSegmentCount(count);
|
|
}
|
|
void ScatterDataModifier::setYAxisSubsegemntCount(int count)
|
|
{
|
|
m_chart->axisY()->setSubSegmentCount(count);
|
|
}
|
|
void ScatterDataModifier::setZAxisSubsegemntCount(int count)
|
|
{
|
|
m_chart->axisZ()->setSubSegmentCount(count);
|
|
}
|
|
void ScatterDataModifier::changeShadowQuality(int quality)
|
|
{
|
|
QtGraphs3D::ShadowQuality sq = QtGraphs3D::ShadowQuality(quality);
|
|
m_chart->setShadowQuality(sq);
|
|
emit shadowQualityChanged(quality);
|
|
}
|
|
|
|
void ScatterDataModifier::setBackgroundVisible(int visible)
|
|
{
|
|
m_chart->activeTheme()->setBackgroundVisible((bool)visible);
|
|
}
|
|
|
|
void ScatterDataModifier::setGridVisible(int visible)
|
|
{
|
|
m_chart->activeTheme()->setGridVisible((bool)visible);
|
|
}
|
|
|
|
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)(QRandomGenerator::global()->bounded(100)) / 2.0f - (float)(QRandomGenerator::global()->bounded(100)) / 2.0f,
|
|
(float)(QRandomGenerator::global()->bounded(100)) / 100.0f - (float)(QRandomGenerator::global()->bounded(100)) / 100.0f,
|
|
(float)(QRandomGenerator::global()->bounded(100)) / 2.0f - (float)(QRandomGenerator::global()->bounded(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::Mesh::Sphere);
|
|
series->setMeshSmooth(true);
|
|
series->setBaseColor(QColor(QRandomGenerator::global()->bounded(256), QRandomGenerator::global()->bounded(256), QRandomGenerator::global()->bounded(256)));
|
|
series->setItemSize(float(QRandomGenerator::global()->bounded(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;
|
|
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;
|
|
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);
|
|
}
|
|
|
|
void ScatterDataModifier::populateNanSeries(QScatter3DSeries *series,
|
|
int rows,
|
|
int columns,
|
|
float value)
|
|
{
|
|
QScatterDataArray dataArray;
|
|
int arraySize = rows * columns;
|
|
dataArray.resize(arraySize);
|
|
for (int i = 0; i < rows; i++) {
|
|
for (int j = 0; j < columns; j++) {
|
|
float yValue = i % 2 == 0 ? value : std::numeric_limits<float>::quiet_NaN();
|
|
dataArray[i * columns + j].setPosition(QVector3D(float(i), yValue, float(j)));
|
|
}
|
|
}
|
|
series->dataProxy()->resetArray(dataArray);
|
|
}
|