qiurui
/
qtgraphs
mirror of https://github.com/qt/qtgraphs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Change data api for surface graph 

Task-number: QTBUG-114091
Change-Id: Ie49b35e8804760e5ffa26d3dd907f40deec519bd
Reviewed-by: Tomi Korpipää <tomi.korpipaa@qt.io>
Reviewed-by: Dilek Akcay <dilek.akcay@qt.io>
Reviewed-by: Jere Tuliniemi <jere.tuliniemi@qt.io>
Reviewed-by: Sakaria Pouke <sakaria.pouke@qt.io>
This commit is contained in:
Sami Varanka 2023-09-08 14:39:55 +03:00
parent 93ea6f009a
commit 758abf8d29
23 changed files with 380 additions and 362 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
examples/graphs/surfacegallery/datasource.cpp
View File

@ -7,8 +7,7 @@
DataSource::DataSource(QObject *parent) :
QObject(parent),
m_index(-1),
m_resetArray(nullptr)
m_index(-1)
{
//! [3]
qRegisterMetaType<QSurface3DSeries *>();
@ -36,7 +35,7 @@ void DataSource::generateData(int cacheCount, int rowCount, int columnCount,
QSurfaceDataArray &array = m_data[i];
array.reserve(rowCount);
for (int j = 0; j < rowCount; j++)
array.append(new QSurfaceDataRow(columnCount));
array.append(QSurfaceDataRow(columnCount));
}
float xRange = xMax - xMin;
@ -52,7 +51,7 @@ void DataSource::generateData(int cacheCount, int rowCount, int columnCount,
float cacheXAdjustment = cacheStep * i;
float cacheIndexAdjustment = cacheIndexStep * i;
for (int j = 0; j < rowCount; j++) {
QSurfaceDataRow &row = *(cache[j]);
QSurfaceDataRow &row = cache[j];
float rowMod = (float(j)) / float(rowCount);
float yRangeMod = yRange * rowMod;
float zRangeMod = zRange * rowMod;
@ -92,22 +91,22 @@ void DataSource::update(QSurface3DSeries *series)
QSurfaceDataArray array = m_data.at(m_index);
int newRowCount = array.size();
int newColumnCount = array.at(0)->size();
int newColumnCount = array.at(0).size();
// If the first time or the dimensions of the cache array have changed,
// reconstruct the reset array
if (!m_resetArray || series->dataProxy()->rowCount() != newRowCount
if (m_resetArray.isEmpty() || series->dataProxy()->rowCount() != newRowCount
|| series->dataProxy()->columnCount() != newColumnCount) {
m_resetArray = new QSurfaceDataArray();
m_resetArray->reserve(newRowCount);
m_resetArray.clear();
m_resetArray.reserve(newRowCount);
for (int i = 0; i < newRowCount; i++)
m_resetArray->append(new QSurfaceDataRow(newColumnCount));
m_resetArray.append(QSurfaceDataRow(newColumnCount));
}
// Copy items from our cache to the reset array
for (int i = 0; i < newRowCount; i++) {
const QSurfaceDataRow &sourceRow = *(array.at(i));
QSurfaceDataRow &row = *(*m_resetArray)[i];
const QSurfaceDataRow &sourceRow = array.at(i);
QSurfaceDataRow &row = m_resetArray[i];
for (int j = 0; j < newColumnCount; j++)
row[j].setPosition(sourceRow.at(j).position());
}
@ -122,8 +121,6 @@ void DataSource::clearData()
{
for (int i = 0; i < m_data.size(); i++) {
QSurfaceDataArray &array = m_data[i];
for (int j = 0; j < array.size(); j++)
delete array[j];
array.clear();
}
}

2
examples/graphs/surfacegallery/datasource.h
View File

@ -32,7 +32,7 @@ private:
QList<QSurfaceDataArray> m_data;
int m_index;
QSurfaceDataArray *m_resetArray;
QSurfaceDataArray m_resetArray;
};
#endif

22
examples/graphs/widgetgraphgallery/highlightseries.cpp
View File

@ -26,8 +26,8 @@ HighlightSeries::~HighlightSeries()
void HighlightSeries::setTopographicSeries(TopographicSeries *series)
{
m_topographicSeries = series;
m_srcWidth = m_topographicSeries->dataProxy()->array()->at(0)->size();
m_srcHeight = m_topographicSeries->dataProxy()->array()->size();
m_srcWidth = m_topographicSeries->dataProxy()->array().at(0).size();
m_srcHeight = m_topographicSeries->dataProxy()->array().size();
QObject::connect(m_topographicSeries, &QSurface3DSeries::selectedPointChanged,
this, &HighlightSeries::handlePositionChange);
@ -61,20 +61,20 @@ void HighlightSeries::handlePositionChange(const QPoint &position)
endZ = m_srcHeight - 1;
QSurfaceDataProxy *srcProxy = m_topographicSeries->dataProxy();
const QSurfaceDataArray &srcArray = *srcProxy->array();
const QSurfaceDataArray &srcArray = srcProxy->array();
auto *dataArray = new QSurfaceDataArray;
dataArray->reserve(endZ - startZ);
QSurfaceDataArray dataArray;
dataArray.reserve(endZ - startZ);
for (int i = startZ; i < endZ; ++i) {
auto *newRow = new QSurfaceDataRow;
newRow->reserve(endX - startX);
QSurfaceDataRow *srcRow = srcArray.at(i);
QSurfaceDataRow newRow;
newRow.reserve(endX - startX);
QSurfaceDataRow srcRow = srcArray.at(i);
for (int j = startX; j < endX; ++j) {
QVector3D pos = srcRow->at(j).position();
QVector3D pos = srcRow.at(j).position();
pos.setY(pos.y() + m_heightAdjustment);
newRow->append(QSurfaceDataItem(pos));
newRow.append(QSurfaceDataItem(pos));
}
dataArray->append(newRow);
dataArray.append(newRow);
}
dataProxy()->resetArray(dataArray);

12
examples/graphs/widgetgraphgallery/surfacegraphmodifier.cpp
View File

@ -156,11 +156,11 @@ void SurfaceGraphModifier::fillSqrtSinProxy()
float stepZ = (sampleMax - sampleMin) / float(sampleCountZ - 1);
//! [1]
auto *dataArray = new QSurfaceDataArray;
dataArray->reserve(sampleCountZ);
QSurfaceDataArray dataArray;
dataArray.reserve(sampleCountZ);
for (int i = 0 ; i < sampleCountZ ; ++i) {
auto *newRow = new QSurfaceDataRow;
newRow->reserve(sampleCountX);
QSurfaceDataRow newRow;
newRow.reserve(sampleCountX);
// Keep values within range bounds, since just adding step can cause minor drift due
// to the rounding errors.
float z = qMin(sampleMax, (i * stepZ + sampleMin));
@ -168,9 +168,9 @@ void SurfaceGraphModifier::fillSqrtSinProxy()
float x = qMin(sampleMax, (j * stepX + sampleMin));
float R = qSqrt(z * z + x * x) + 0.01f;
float y = (qSin(R) / R + 0.24f) * 1.61f;
newRow->append(QSurfaceDataItem({x, y, z}));
newRow.append(QSurfaceDataItem({x, y, z}));
}
dataArray->append(newRow);
dataArray.append(newRow);
}
m_sqrtSinProxy->resetArray(dataArray);

12
examples/graphs/widgetgraphgallery/topographicseries.cpp
View File

@ -28,23 +28,23 @@ void TopographicSeries::setTopographyFile(const QString file, float width, float
float stepX = width / float(imageWidth);
float stepZ = height / float(imageHeight);
auto *dataArray = new QSurfaceDataArray;
dataArray->reserve(imageHeight);
QSurfaceDataArray dataArray;
dataArray.reserve(imageHeight);
for (int i = 0; i < imageHeight; ++i) {
int p = i * widthBits;
float z = height - float(i) * stepZ;
auto *newRow = new QSurfaceDataRow;
newRow->reserve(imageWidth);
QSurfaceDataRow newRow;
newRow.reserve(imageWidth);
for (int j = 0; j < imageWidth; ++j) {
uchar aa = bits[p + 0];
uchar rr = bits[p + 1];
uchar gg = bits[p + 2];
uint color = uint((gg << 16) + (rr << 8) + aa);
float y = float(color) / packingFactor;
newRow->append(QSurfaceDataItem({float(j) * stepX, y, z}));
newRow.append(QSurfaceDataItem({float(j) * stepX, y, z}));
p += 4;
}
dataArray->append(newRow);
dataArray.append(newRow);
}
dataProxy()->resetArray(dataArray);

16
src/graphs/data/qheightmapsurfacedataproxy.cpp
View File

@ -679,13 +679,13 @@ void QHeightMapSurfaceDataProxyPrivate::handlePendingResolve()
float height = 0;
// Do not recreate array if dimensions have not changed
QSurfaceDataArray *dataArray = m_dataArray;
if (imageWidth != q->columnCount() || imageHeight != dataArray->size()) {
dataArray = new QSurfaceDataArray;
dataArray->reserve(imageHeight);
QSurfaceDataArray dataArray = m_dataArray;
if (imageWidth != q->columnCount() || imageHeight != dataArray.size()) {
dataArray.clear();
dataArray.reserve(imageHeight);
for (int i = 0; i < imageHeight; i++) {
QSurfaceDataRow *newProxyRow = new QSurfaceDataRow(imageWidth);
dataArray->append(newProxyRow);
QSurfaceDataRow newProxyRow(imageWidth);
dataArray.append(newProxyRow);
}
}
yMul *= m_maxYValue - m_minYValue;
@ -701,7 +701,7 @@ void QHeightMapSurfaceDataProxyPrivate::handlePendingResolve()
if (heightImage.isGrayscale()) {
// Grayscale, it's enough to read Red byte
for (int i = 0; i < imageHeight; i++, bitCount -= widthBits) {
QSurfaceDataRow &newRow = *dataArray->at(i);
QSurfaceDataRow &newRow = dataArray[i];
float zVal;
if (i == lastRow)
zVal = m_maxZValue;
@ -727,7 +727,7 @@ void QHeightMapSurfaceDataProxyPrivate::handlePendingResolve()
} else {
// Not grayscale, we'll need to calculate height from RGB
for (int i = 0; i < imageHeight; i++, bitCount -= widthBits) {
QSurfaceDataRow &newRow = *dataArray->at(i);
QSurfaceDataRow &newRow = dataArray[i];
float zVal;
if (i == lastRow)
zVal = m_maxZValue;

2
src/graphs/data/qsurface3dseries.cpp
View File

@ -489,7 +489,7 @@ void QSurface3DSeriesPrivate::createItemLabel()
QValue3DAxis *axisX = static_cast<QValue3DAxis *>(m_controller->axisX());
QValue3DAxis *axisY = static_cast<QValue3DAxis *>(m_controller->axisY());
QValue3DAxis *axisZ = static_cast<QValue3DAxis *>(m_controller->axisZ());
QVector3D selectedPosition = q->dataProxy()->itemAt(m_selectedPoint)->position();
QVector3D selectedPosition = q->dataProxy()->itemAt(m_selectedPoint).position();
m_itemLabel = m_itemLabelFormat;

16
src/graphs/data/qsurfacedataitem.cpp
View File

@ -44,6 +44,11 @@ QSurfaceDataItem::QSurfaceDataItem(const QSurfaceDataItem &other)
operator=(other);
}
QSurfaceDataItem::QSurfaceDataItem(QSurfaceDataItem &&other) noexcept
{
*this = std::move(other);
}
/*!
* Deletes a surface data item.
*/
@ -66,6 +71,17 @@ QSurfaceDataItem &QSurfaceDataItem::operator=(const QSurfaceDataItem &other)
return *this;
}
QSurfaceDataItem &QSurfaceDataItem::operator=(QSurfaceDataItem &&other) noexcept
{
m_position = other.m_position;
QSurfaceDataItemPrivate *temp = std::move(other.d_ptr);
other.d_ptr = nullptr;
d_ptr = temp;
return *this;
}
/*!
* \fn void QSurfaceDataItem::setPosition(const QVector3D &pos)
* Sets the position \a pos to this data item.

2
src/graphs/data/qsurfacedataitem.h
View File

@ -17,9 +17,11 @@ public:
QSurfaceDataItem();
QSurfaceDataItem(const QVector3D &position);
QSurfaceDataItem(const QSurfaceDataItem &other);
QSurfaceDataItem(QSurfaceDataItem &&other) noexcept;
~QSurfaceDataItem();
QSurfaceDataItem &operator=(const QSurfaceDataItem &other);
QSurfaceDataItem &operator=(QSurfaceDataItem &&other) noexcept;
constexpr inline void setPosition(const QVector3D &pos) noexcept { m_position = pos; }
constexpr inline QVector3D position() const noexcept { return m_position; }

183
src/graphs/data/qsurfacedataproxy.cpp
View File

@ -138,12 +138,23 @@ QSurface3DSeries *QSurfaceDataProxy::series() const
* Passing a null array deletes the old array and creates a new empty array.
* All rows in \a newArray must be of same length.
*/
void QSurfaceDataProxy::resetArray(QSurfaceDataArray *newArray)
void QSurfaceDataProxy::resetArray()
{
Q_D(QSurfaceDataProxy);
if (d->m_dataArray != newArray) {
d->resetArray(newArray);
d->resetArray(QSurfaceDataArray());
emit arrayReset();
emit rowCountChanged(rowCount());
emit columnCountChanged(columnCount());
}
void QSurfaceDataProxy::resetArray(QSurfaceDataArray newArray)
{
Q_D(QSurfaceDataProxy);
if (d->m_dataArray.data() != newArray.data()) {
d->resetArray(std::move(newArray));
}
emit arrayReset();
emit rowCountChanged(rowCount());
emit columnCountChanged(columnCount());
@ -155,10 +166,10 @@ void QSurfaceDataProxy::resetArray(QSurfaceDataArray *newArray)
* existing row already stored at the \a rowIndex. The new row must have
* the same number of columns as the row it is replacing.
*/
void QSurfaceDataProxy::setRow(int rowIndex, QSurfaceDataRow *row)
void QSurfaceDataProxy::setRow(int rowIndex, QSurfaceDataRow row)
{
Q_D(QSurfaceDataProxy);
d->setRow(rowIndex, row);
d->setRow(rowIndex, std::move(row));
emit rowsChanged(rowIndex, 1);
}
@ -169,10 +180,10 @@ void QSurfaceDataProxy::setRow(int rowIndex, QSurfaceDataRow *row)
* stored at the \a rowIndex. The new rows must have the same number of columns
* as the rows they are replacing.
*/
void QSurfaceDataProxy::setRows(int rowIndex, const QSurfaceDataArray &rows)
void QSurfaceDataProxy::setRows(int rowIndex, QSurfaceDataArray rows)
{
Q_D(QSurfaceDataProxy);
d->setRows(rowIndex, rows);
d->setRows(rowIndex, std::move(rows));
emit rowsChanged(rowIndex, rows.size());
}
@ -180,10 +191,10 @@ void QSurfaceDataProxy::setRows(int rowIndex, const QSurfaceDataArray &rows)
* Changes a single item at the position specified by \a rowIndex and
* \a columnIndex to the item \a item.
*/
void QSurfaceDataProxy::setItem(int rowIndex, int columnIndex, const QSurfaceDataItem &item)
void QSurfaceDataProxy::setItem(int rowIndex, int columnIndex, QSurfaceDataItem item)
{
Q_D(QSurfaceDataProxy);
d->setItem(rowIndex, columnIndex, item);
d->setItem(rowIndex, columnIndex, std::move(item));
emit itemChanged(rowIndex, columnIndex);
}
@ -192,7 +203,7 @@ void QSurfaceDataProxy::setItem(int rowIndex, int columnIndex, const QSurfaceDat
* The x-value of \a position indicates the row and the y-value indicates the
* column.
*/
void QSurfaceDataProxy::setItem(const QPoint &position, const QSurfaceDataItem &item)
void QSurfaceDataProxy::setItem(const QPoint &position, QSurfaceDataItem item)
{
setItem(position.x(), position.y(), item);
}
@ -203,10 +214,10 @@ void QSurfaceDataProxy::setItem(const QPoint &position, const QSurfaceDataItem &
*
* Returns the index of the added row.
*/
int QSurfaceDataProxy::addRow(QSurfaceDataRow *row)
int QSurfaceDataProxy::addRow(QSurfaceDataRow row)
{
Q_D(QSurfaceDataProxy);
int addIndex = d->addRow(row);
int addIndex = d->addRow(std::move(row));
emit rowsAdded(addIndex, 1);
emit rowCountChanged(rowCount());
return addIndex;
@ -218,10 +229,10 @@ int QSurfaceDataProxy::addRow(QSurfaceDataRow *row)
*
* Returns the index of the first added row.
*/
int QSurfaceDataProxy::addRows(const QSurfaceDataArray &rows)
int QSurfaceDataProxy::addRows(QSurfaceDataArray rows)
{
Q_D(QSurfaceDataProxy);
int addIndex = d->addRows(rows);
int addIndex = d->addRows(std::move(rows));
emit rowsAdded(addIndex, rows.size());
emit rowCountChanged(rowCount());
return addIndex;
@ -233,10 +244,10 @@ int QSurfaceDataProxy::addRows(const QSurfaceDataArray &rows)
* the array. The new row must have the same number of columns as the rows in
* the initial array.
*/
void QSurfaceDataProxy::insertRow(int rowIndex, QSurfaceDataRow *row)
void QSurfaceDataProxy::insertRow(int rowIndex, QSurfaceDataRow row)
{
Q_D(QSurfaceDataProxy);
d->insertRow(rowIndex, row);
d->insertRow(rowIndex, std::move(row));
emit rowsInserted(rowIndex, 1);
emit rowCountChanged(rowCount());
}
@ -247,10 +258,10 @@ void QSurfaceDataProxy::insertRow(int rowIndex, QSurfaceDataRow *row)
* the array. The new \a rows must have the same number of columns as the rows
* in the initial array.
*/
void QSurfaceDataProxy::insertRows(int rowIndex, const QSurfaceDataArray &rows)
void QSurfaceDataProxy::insertRows(int rowIndex, QSurfaceDataArray rows)
{
Q_D(QSurfaceDataProxy);
d->insertRows(rowIndex, rows);
d->insertRows(rowIndex, std::move(rows));
emit rowsInserted(rowIndex, rows.size());
emit rowCountChanged(rowCount());
}
@ -273,7 +284,7 @@ void QSurfaceDataProxy::removeRows(int rowIndex, int removeCount)
/*!
* Returns the pointer to the data array.
*/
const QSurfaceDataArray *QSurfaceDataProxy::array() const
const QSurfaceDataArray &QSurfaceDataProxy::array() const
{
const Q_D(QSurfaceDataProxy);
return d->m_dataArray;
@ -284,14 +295,14 @@ const QSurfaceDataArray *QSurfaceDataProxy::array() const
* \a columnIndex. It is guaranteed to be valid only
* until the next call that modifies data.
*/
const QSurfaceDataItem *QSurfaceDataProxy::itemAt(int rowIndex, int columnIndex) const
const QSurfaceDataItem &QSurfaceDataProxy::itemAt(int rowIndex, int columnIndex) const
{
const Q_D(QSurfaceDataProxy);
const QSurfaceDataArray &dataArray = *d->m_dataArray;
const QSurfaceDataArray &dataArray = d->m_dataArray;
Q_ASSERT(rowIndex >= 0 && rowIndex < dataArray.size());
const QSurfaceDataRow &dataRow = *dataArray[rowIndex];
const QSurfaceDataRow &dataRow = dataArray[rowIndex];
Q_ASSERT(columnIndex >= 0 && columnIndex < dataRow.size());
return &dataRow.at(columnIndex);
return dataRow.at(columnIndex);
}
/*!
@ -299,7 +310,7 @@ const QSurfaceDataItem *QSurfaceDataProxy::itemAt(int rowIndex, int columnIndex)
* \a position indicates the row and the y-value indicates the column. The item
* is guaranteed to be valid only until the next call that modifies data.
*/
const QSurfaceDataItem *QSurfaceDataProxy::itemAt(const QPoint &position) const
const QSurfaceDataItem &QSurfaceDataProxy::itemAt(const QPoint &position) const
{
return itemAt(position.x(), position.y());
}
@ -312,7 +323,7 @@ const QSurfaceDataItem *QSurfaceDataProxy::itemAt(const QPoint &position) const
int QSurfaceDataProxy::rowCount() const
{
const Q_D(QSurfaceDataProxy);
return d->m_dataArray->size();
return d->m_dataArray.size();
}
/*!
@ -323,8 +334,8 @@ int QSurfaceDataProxy::rowCount() const
int QSurfaceDataProxy::columnCount() const
{
const Q_D(QSurfaceDataProxy);
if (d->m_dataArray->size() > 0)
return d->m_dataArray->at(0)->size();
if (d->m_dataArray.size() > 0)
return d->m_dataArray.at(0).size();
else
return 0;
}
@ -388,8 +399,7 @@ int QSurfaceDataProxy::columnCount() const
// QSurfaceDataProxyPrivate
QSurfaceDataProxyPrivate::QSurfaceDataProxyPrivate(QSurfaceDataProxy *q)
: QAbstractDataProxyPrivate(q, QAbstractDataProxy::DataType::Surface),
m_dataArray(new QSurfaceDataArray)
: QAbstractDataProxyPrivate(q, QAbstractDataProxy::DataType::Surface)
{
}
@ -398,36 +408,33 @@ QSurfaceDataProxyPrivate::~QSurfaceDataProxyPrivate()
clearArray();
}
void QSurfaceDataProxyPrivate::resetArray(QSurfaceDataArray *newArray)
void QSurfaceDataProxyPrivate::resetArray(QSurfaceDataArray &&newArray)
{
if (!newArray)
newArray = new QSurfaceDataArray;
if (newArray != m_dataArray) {
if (newArray.data() != m_dataArray.data()) {
clearArray();
m_dataArray = newArray;
}
}
void QSurfaceDataProxyPrivate::setRow(int rowIndex, QSurfaceDataRow *row)
void QSurfaceDataProxyPrivate::setRow(int rowIndex, QSurfaceDataRow &&row)
{
Q_ASSERT(rowIndex >= 0 && rowIndex < m_dataArray->size());
Q_ASSERT(m_dataArray->at(rowIndex)->size() == row->size());
Q_ASSERT(rowIndex >= 0 && rowIndex < m_dataArray.size());
Q_ASSERT(m_dataArray.at(rowIndex).size() == row.size());
if (row != m_dataArray->at(rowIndex)) {
if (row.data() != m_dataArray.at(rowIndex).data()) {
clearRow(rowIndex);
(*m_dataArray)[rowIndex] = row;
m_dataArray[rowIndex] = row;
}
}
void QSurfaceDataProxyPrivate::setRows(int rowIndex, const QSurfaceDataArray &rows)
void QSurfaceDataProxyPrivate::setRows(int rowIndex, QSurfaceDataArray &&rows)
{
QSurfaceDataArray &dataArray = *m_dataArray;
QSurfaceDataArray &dataArray = m_dataArray;
Q_ASSERT(rowIndex >= 0 && (rowIndex + rows.size()) <= dataArray.size());
for (int i = 0; i < rows.size(); i++) {
Q_ASSERT(m_dataArray->at(rowIndex)->size() == rows.at(i)->size());
if (rows.at(i) != dataArray.at(rowIndex)) {
Q_ASSERT(m_dataArray.at(rowIndex).size() == rows.at(i).size());
if (rows.at(i).data() != dataArray.at(rowIndex).data()) {
clearRow(rowIndex);
dataArray[rowIndex] = rows.at(i);
}
@ -435,61 +442,61 @@ void QSurfaceDataProxyPrivate::setRows(int rowIndex, const QSurfaceDataArray &ro
}
}
void QSurfaceDataProxyPrivate::setItem(int rowIndex, int columnIndex, const QSurfaceDataItem &item)
void QSurfaceDataProxyPrivate::setItem(int rowIndex, int columnIndex, QSurfaceDataItem &&item)
{
Q_ASSERT(rowIndex >= 0 && rowIndex < m_dataArray->size());
QSurfaceDataRow &row = *(*m_dataArray)[rowIndex];
Q_ASSERT(rowIndex >= 0 && rowIndex < m_dataArray.size());
QSurfaceDataRow &row = m_dataArray[rowIndex];
Q_ASSERT(columnIndex < row.size());
row[columnIndex] = item;
}
int QSurfaceDataProxyPrivate::addRow(QSurfaceDataRow *row)
int QSurfaceDataProxyPrivate::addRow(QSurfaceDataRow &&row)
{
Q_ASSERT(m_dataArray->isEmpty()
|| m_dataArray->at(0)->size() == row->size());
int currentSize = m_dataArray->size();
m_dataArray->append(row);
Q_ASSERT(m_dataArray.isEmpty()
|| m_dataArray.at(0).size() == row.size());
int currentSize = m_dataArray.size();
m_dataArray.append(row);
return currentSize;
}
int QSurfaceDataProxyPrivate::addRows(const QSurfaceDataArray &rows)
int QSurfaceDataProxyPrivate::addRows(QSurfaceDataArray &&rows)
{
int currentSize = m_dataArray->size();
int currentSize = m_dataArray.size();
for (int i = 0; i < rows.size(); i++) {
Q_ASSERT(m_dataArray->isEmpty()
|| m_dataArray->at(0)->size() == rows.at(i)->size());
m_dataArray->append(rows.at(i));
Q_ASSERT(m_dataArray.isEmpty()
|| m_dataArray.at(0).size() == rows.at(i).size());
m_dataArray.append(rows.at(i));
}
return currentSize;
}
void QSurfaceDataProxyPrivate::insertRow(int rowIndex, QSurfaceDataRow *row)
void QSurfaceDataProxyPrivate::insertRow(int rowIndex, QSurfaceDataRow &&row)
{
Q_ASSERT(rowIndex >= 0 && rowIndex <= m_dataArray->size());
Q_ASSERT(m_dataArray->isEmpty()
|| m_dataArray->at(0)->size() == row->size());
m_dataArray->insert(rowIndex, row);
Q_ASSERT(rowIndex >= 0 && rowIndex <= m_dataArray.size());
Q_ASSERT(m_dataArray.isEmpty()
|| m_dataArray.at(0).size() == row.size());
m_dataArray.insert(rowIndex, row);
}
void QSurfaceDataProxyPrivate::insertRows(int rowIndex, const QSurfaceDataArray &rows)
void QSurfaceDataProxyPrivate::insertRows(int rowIndex, QSurfaceDataArray &&rows)
{
Q_ASSERT(rowIndex >= 0 && rowIndex <= m_dataArray->size());
Q_ASSERT(rowIndex >= 0 && rowIndex <= m_dataArray.size());
for (int i = 0; i < rows.size(); i++) {
Q_ASSERT(m_dataArray->isEmpty()
|| m_dataArray->at(0)->size() == rows.at(i)->size());
m_dataArray->insert(rowIndex++, rows.at(i));
Q_ASSERT(m_dataArray.isEmpty()
|| m_dataArray.at(0).size() == rows.at(i).size());
m_dataArray.insert(rowIndex++, rows.at(i));
}
}
void QSurfaceDataProxyPrivate::removeRows(int rowIndex, int removeCount)
{
Q_ASSERT(rowIndex >= 0);
int maxRemoveCount = m_dataArray->size() - rowIndex;
int maxRemoveCount = m_dataArray.size() - rowIndex;
removeCount = qMin(removeCount, maxRemoveCount);
for (int i = 0; i < removeCount; i++) {
clearRow(rowIndex);
m_dataArray->removeAt(rowIndex);
m_dataArray.removeAt(rowIndex);
}
}
@ -500,21 +507,21 @@ void QSurfaceDataProxyPrivate::limitValues(QVector3D &minValues, QVector3D &maxV
float min = 0.0f;
float max = 0.0f;
int rows = m_dataArray->size();
int rows = m_dataArray.size();
int columns = 0;
if (rows)
columns = m_dataArray->at(0)->size();
columns = m_dataArray.at(0).size();
if (rows && columns) {
min = m_dataArray->at(0)->at(0).y();
max = m_dataArray->at(0)->at(0).y();
min = m_dataArray.at(0).at(0).y();
max = m_dataArray.at(0).at(0).y();
}
for (int i = 0; i < rows; i++) {
QSurfaceDataRow *row = m_dataArray->at(i);
if (row) {
const QSurfaceDataRow &row = m_dataArray.at(i);
if (!row.isEmpty()) {
for (int j = 0; j < columns; j++) {
float itemValue = m_dataArray->at(i)->at(j).y();
float itemValue = m_dataArray.at(i).at(j).y();
if (qIsNaN(itemValue) || qIsInf(itemValue))
continue;
if ((min > itemValue || (qIsNaN(min) || qIsInf(min)))
@ -532,13 +539,13 @@ void QSurfaceDataProxyPrivate::limitValues(QVector3D &minValues, QVector3D &maxV
if (columns) {
// Have some defaults
float xLow = m_dataArray->at(0)->at(0).x();
float xHigh = m_dataArray->at(0)->last().x();
float zLow = m_dataArray->at(0)->at(0).z();
float zHigh = m_dataArray->last()->at(0).z();
float xLow = m_dataArray.at(0).at(0).x();
float xHigh = m_dataArray.at(0).last().x();
float zLow = m_dataArray.at(0).at(0).z();
float zHigh = m_dataArray.last().at(0).z();
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
float zItemValue = m_dataArray->at(i)->at(j).z();
float zItemValue = m_dataArray.at(i).at(j).z();
if (qIsNaN(zItemValue) || qIsInf(zItemValue))
continue;
else if (isValidValue(zItemValue, axisZ))
@ -549,7 +556,7 @@ void QSurfaceDataProxyPrivate::limitValues(QVector3D &minValues, QVector3D &maxV
}
for (int i = rows - 1; i >= 0; i--) {
for (int j = 0; j < columns; j++) {
float zItemValue = m_dataArray->at(i)->at(j).z();
float zItemValue = m_dataArray.at(i).at(j).z();
if (qIsNaN(zItemValue) || qIsInf(zItemValue))
continue;
else if (isValidValue(zItemValue, axisZ))
@ -565,7 +572,7 @@ void QSurfaceDataProxyPrivate::limitValues(QVector3D &minValues, QVector3D &maxV
}
for (int j = 0; j<columns; j++){
for (int i = 0; i < rows; i++) {
float xItemValue = m_dataArray->at(i)->at(j).x();
float xItemValue = m_dataArray.at(i).at(j).x();
if (qIsNaN(xItemValue) || qIsInf(xItemValue))
continue;
else if (isValidValue(xItemValue, axisX))
@ -576,7 +583,7 @@ void QSurfaceDataProxyPrivate::limitValues(QVector3D &minValues, QVector3D &maxV
}
for (int j = columns-1; j >= 0; j--){
for (int i = 0; i < rows; i++) {
float xItemValue = m_dataArray->at(i)->at(j).x();
float xItemValue = m_dataArray.at(i).at(j).x();
if (qIsNaN(xItemValue) || qIsInf(xItemValue))
continue;
else if (isValidValue(xItemValue, axisX))
@ -610,18 +617,12 @@ bool QSurfaceDataProxyPrivate::isValidValue(float value, QAbstract3DAxis *axis)
void QSurfaceDataProxyPrivate::clearRow(int rowIndex)
{
if (m_dataArray->at(rowIndex)) {
delete m_dataArray->at(rowIndex);
(*m_dataArray)[rowIndex] = 0;
}
m_dataArray[rowIndex].clear();
}
void QSurfaceDataProxyPrivate::clearArray()
{
for (int i = 0; i < m_dataArray->size(); i++)
clearRow(i);
m_dataArray->clear();
delete m_dataArray;
m_dataArray.clear();
}
void QSurfaceDataProxyPrivate::setSeries(QAbstract3DSeries *series)

27
src/graphs/data/qsurfacedataproxy.h
View File

@ -15,7 +15,7 @@ class QSurfaceDataProxyPrivate;
class QSurface3DSeries;
using QSurfaceDataRow = QList<QSurfaceDataItem>;
using QSurfaceDataArray = QList<QSurfaceDataRow *>;
using QSurfaceDataArray = QList<QSurfaceDataRow>;
class Q_GRAPHS_EXPORT QSurfaceDataProxy : public QAbstractDataProxy
{
@ -32,23 +32,24 @@ public:
QSurface3DSeries *series() const;
int rowCount() const;
int columnCount() const;
const QSurfaceDataArray *array() const;
const QSurfaceDataItem *itemAt(int rowIndex, int columnIndex) const;
const QSurfaceDataItem *itemAt(const QPoint &position) const;
const QSurfaceDataArray &array() const;
const QSurfaceDataItem &itemAt(int rowIndex, int columnIndex) const;
const QSurfaceDataItem &itemAt(const QPoint &position) const;
void resetArray(QSurfaceDataArray *newArray);
void resetArray();
void resetArray(QSurfaceDataArray newArray);
void setRow(int rowIndex, QSurfaceDataRow *row);
void setRows(int rowIndex, const QSurfaceDataArray &rows);
void setRow(int rowIndex, QSurfaceDataRow row);
void setRows(int rowIndex, QSurfaceDataArray rows);
void setItem(int rowIndex, int columnIndex, const QSurfaceDataItem &item);
void setItem(const QPoint &position, const QSurfaceDataItem &item);
void setItem(int rowIndex, int columnIndex, QSurfaceDataItem item);
void setItem(const QPoint &position, QSurfaceDataItem item);
int addRow(QSurfaceDataRow *row);
int addRows(const QSurfaceDataArray &rows);
int addRow(QSurfaceDataRow row);
int addRows(QSurfaceDataArray rows);
void insertRow(int rowIndex, QSurfaceDataRow *row);
void insertRows(int rowIndex, const QSurfaceDataArray &rows);
void insertRow(int rowIndex, QSurfaceDataRow row);
void insertRows(int rowIndex, QSurfaceDataArray rows);
void removeRows(int rowIndex, int removeCount);

18
src/graphs/data/qsurfacedataproxy_p.h
View File

@ -29,14 +29,14 @@ public:
QSurfaceDataProxyPrivate(QSurfaceDataProxy *q);
virtual ~QSurfaceDataProxyPrivate();
void resetArray(QSurfaceDataArray *newArray);
void setRow(int rowIndex, QSurfaceDataRow *row);
void setRows(int rowIndex, const QSurfaceDataArray &rows);
void setItem(int rowIndex, int columnIndex, const QSurfaceDataItem &item);
int addRow(QSurfaceDataRow *row);
int addRows(const QSurfaceDataArray &rows);
void insertRow(int rowIndex, QSurfaceDataRow *row);
void insertRows(int rowIndex, const QSurfaceDataArray &rows);
void resetArray(QSurfaceDataArray &&newArray);
void setRow(int rowIndex, QSurfaceDataRow &&row);
void setRows(int rowIndex, QSurfaceDataArray &&rows);
void setItem(int rowIndex, int columnIndex, QSurfaceDataItem &&item);
int addRow(QSurfaceDataRow &&row);
int addRows(QSurfaceDataArray &&rows);
void insertRow(int rowIndex, QSurfaceDataRow &&row);
void insertRows(int rowIndex, QSurfaceDataArray &&rows);
void removeRows(int rowIndex, int removeCount);
void limitValues(QVector3D &minValues, QVector3D &maxValues, QAbstract3DAxis *axisX,
QAbstract3DAxis *axisY, QAbstract3DAxis *axisZ) const;
@ -45,7 +45,7 @@ public:
void setSeries(QAbstract3DSeries *series) override;
protected:
QSurfaceDataArray *m_dataArray;
QSurfaceDataArray m_dataArray;
private:
void clearRow(int rowIndex);

38
src/graphs/data/surfaceitemmodelhandler.cpp
View File

@ -46,7 +46,7 @@ void SurfaceItemModelHandler::handleDataChanged(const QModelIndex &topLeft,
QVariant xValueVar = index.data(m_xPosRole);
QVariant yValueVar = index.data(m_yPosRole);
QVariant zValueVar = index.data(m_zPosRole);
const QSurfaceDataItem *oldItem = m_proxy->itemAt(i, j);
const QSurfaceDataItem &oldItem = m_proxy->itemAt(i, j);
float xPos;
float yPos;
float zPos;
@ -56,7 +56,7 @@ void SurfaceItemModelHandler::handleDataChanged(const QModelIndex &topLeft,
else
xPos = xValueVar.toFloat();
} else {
xPos = oldItem->x();
xPos = oldItem.x();
}
if (m_haveYPosPattern)
@ -70,7 +70,7 @@ void SurfaceItemModelHandler::handleDataChanged(const QModelIndex &topLeft,
else
zPos = zValueVar.toFloat();
} else {
zPos = oldItem->z();
zPos = oldItem.z();
}
item.setPosition(QVector3D(xPos, yPos, zPos));
m_proxy->setItem(i, j, item);
@ -84,15 +84,15 @@ void SurfaceItemModelHandler::handleDataChanged(const QModelIndex &topLeft,
void SurfaceItemModelHandler::resolveModel()
{
if (m_itemModel.isNull()) {
m_proxy->resetArray(0);
m_proxyArray = 0;
m_proxy->resetArray();
m_proxyArray.clear();
return;
}
if (!m_proxy->useModelCategories()
&& (m_proxy->rowRole().isEmpty() || m_proxy->columnRole().isEmpty())) {
m_proxy->resetArray(0);
m_proxyArray = 0;
m_proxy->resetArray();
m_proxyArray.clear();
return;
}
@ -124,15 +124,15 @@ void SurfaceItemModelHandler::resolveModel()
if (m_proxy->useModelCategories()) {
// If dimensions have changed, recreate the array
if (m_proxyArray != m_proxy->array() || columnCount != m_proxy->columnCount()
|| rowCount != m_proxyArray->size()) {
m_proxyArray = new QSurfaceDataArray;
m_proxyArray->reserve(rowCount);
if (m_proxyArray.data() != m_proxy->array().data() || columnCount != m_proxy->columnCount()
|| rowCount != m_proxyArray.size()) {
m_proxyArray.clear();
m_proxyArray.reserve(rowCount);
for (int i = 0; i < rowCount; i++)
m_proxyArray->append(new QSurfaceDataRow(columnCount));
m_proxyArray.append(QSurfaceDataRow(columnCount));
}
for (int i = 0; i < rowCount; i++) {
QSurfaceDataRow &newProxyRow = *m_proxyArray->at(i);
QSurfaceDataRow &newProxyRow = m_proxyArray[i];
for (int j = 0; j < columnCount; j++) {
QModelIndex index = m_itemModel->index(i, j);
QVariant xValueVar = index.data(m_xPosRole);
@ -273,17 +273,17 @@ void SurfaceItemModelHandler::resolveModel()
columnList = m_proxy->columnCategories();
// If dimensions have changed, recreate the array
if (m_proxyArray != m_proxy->array() || columnList.size() != m_proxy->columnCount()
|| rowList.size() != m_proxyArray->size()) {
m_proxyArray = new QSurfaceDataArray;
m_proxyArray->reserve(rowList.size());
if (m_proxyArray.data() != m_proxy->array().data() || columnList.size() != m_proxy->columnCount()
|| rowList.size() != m_proxyArray.size()) {
m_proxyArray.clear();
m_proxyArray.reserve(rowList.size());
for (int i = 0; i < rowList.size(); i++)
m_proxyArray->append(new QSurfaceDataRow(columnList.size()));
m_proxyArray.append(QSurfaceDataRow(columnList.size()));
}
// Create data array from itemValueMap
for (int i = 0; i < rowList.size(); i++) {
QString rowKey = rowList.at(i);
QSurfaceDataRow &newProxyRow = *m_proxyArray->at(i);
QSurfaceDataRow &newProxyRow = m_proxyArray[i];
for (int j = 0; j < columnList.size(); j++) {
QVector3D &itemPos = itemValueMap[rowKey][columnList.at(j)];
if (cumulative) {

2
src/graphs/data/surfaceitemmodelhandler_p.h
View File

@ -34,7 +34,7 @@ protected:
void resolveModel() override;
QItemModelSurfaceDataProxy *m_proxy; // Not owned
QSurfaceDataArray *m_proxyArray; // Not owned
QSurfaceDataArray m_proxyArray;
int m_xPosRole;
int m_yPosRole;
int m_zPosRole;

12
src/graphs/doc/snippets/doc_src_q3dsurface_construction.cpp
View File

@ -14,15 +14,15 @@ int main(int argc, char **argv)
surface.setResizeMode(QQuickWidget::SizeRootObjectToView);
//! [0]
//! [1]
QSurfaceDataArray *data = new QSurfaceDataArray;
QSurfaceDataRow *dataRow1 = new QSurfaceDataRow;
QSurfaceDataRow *dataRow2 = new QSurfaceDataRow;
QSurfaceDataArray data;
QSurfaceDataRow dataRow1;
QSurfaceDataRow dataRow2;
//! [1]
//! [2]
*dataRow1 << QVector3D(0.0f, 0.1f, 0.5f) << QVector3D(1.0f, 0.5f, 0.5f);
*dataRow2 << QVector3D(0.0f, 1.8f, 1.0f) << QVector3D(1.0f, 1.2f, 1.0f);
*data << dataRow1 << dataRow2;
dataRow1 << QVector3D(0.0f, 0.1f, 0.5f) << QVector3D(1.0f, 0.5f, 0.5f);
dataRow2 << QVector3D(0.0f, 1.8f, 1.0f) << QVector3D(1.0f, 1.2f, 1.0f);
data << dataRow1 << dataRow2;
//! [2]
//! [3]

2
src/graphs/engine/surface3dcontroller.cpp
View File

@ -191,7 +191,7 @@ void Surface3DController::setSelectedPoint(const QPoint &position, QSurface3DSer
float axisMinZ = m_axisZ->min();
float axisMaxZ = m_axisZ->max();
QSurfaceDataItem item = proxy->array()->at(pos.x())->at(pos.y());
QSurfaceDataItem item = proxy->array().at(pos.x()).at(pos.y());
if (item.x() < axisMinX || item.x() > axisMaxX
|| item.z() < axisMinZ || item.z() > axisMaxZ) {
scene()->setSlicingActive(false);

33
src/graphs/qml/qquickgraphssurface.cpp
View File

@ -393,9 +393,9 @@ void QQuickGraphsSurface::handleChangedSeries()
inline static float getDataValue(const QSurfaceDataArray &array, bool searchRow, int index)
{
if (searchRow)
return array.at(0)->at(index).x();
return array.at(0).at(index).x();
else
return array.at(index)->at(0).z();
return array.at(index).at(0).z();
}
inline static int binarySearchArray(const QSurfaceDataArray &array, int maxIndex, float limitValue, bool searchRow, bool lowBound, bool ascending)
@ -451,12 +451,12 @@ QRect QQuickGraphsSurface::calculateSampleSpace(const QSurfaceDataArray &array)
{
QRect sampleSpace;
if (array.size() > 0) {
if (array.size() >= 2 && array.at(0)->size() >= 2) {
if (array.size() >= 2 && array.at(0).size() >= 2) {
const int maxRow = array.size() - 1;
const int maxColumn = array.at(0)->size() - 1;
const int maxColumn = array.at(0).size() - 1;
const bool ascendingX = array.at(0)->at(0).x() < array.at(0)->at(maxColumn).x();
const bool ascendingZ = array.at(0)->at(0).z() < array.at(maxRow)->at(0).z();
const bool ascendingX = array.at(0).at(0).x() < array.at(0).at(maxColumn).x();
const bool ascendingZ = array.at(0).at(0).z() < array.at(maxRow).at(0).z();
int idx = binarySearchArray(array, maxColumn, m_surfaceController->axisX()->min(), true, true, ascendingX);
if (idx != -1) {
@ -504,10 +504,11 @@ QRect QQuickGraphsSurface::calculateSampleSpace(const QSurfaceDataArray &array)
void QQuickGraphsSurface::updateModel(SurfaceModel *model)
{
const QSurfaceDataArray &array = *(model->series->dataProxy())->array();
const QSurfaceDataArray &array = model->series->dataProxy()->array();
if (!array.isEmpty()) {
int rowCount = array.size();
int columnCount = array.at(0)->size();
int columnCount = array.at(0).size();
const int maxSize = 4096; //maximum texture size
columnCount = qMin(maxSize, columnCount);
@ -546,7 +547,7 @@ void QQuickGraphsSurface::updateModel(SurfaceModel *model)
QPoint selC = model->selectedVertex.coord;
selC.setX(qMin(selC.x(), rowCount - 1));
selC.setY(qMin(selC.y(), columnCount - 1));
QVector3D selP = array.at(selC.x())->at(selC.y()).position();
QVector3D selP = array.at(selC.x()).at(selC.y()).position();
bool pickOutOfRange = false;
if (selP.x() < axisX->min() || selP.x() > axisX->max() || selP.z() < axisZ->min()
@ -613,7 +614,7 @@ void QQuickGraphsSurface::updateModel(SurfaceModel *model)
model->vertices.reserve(totalSize);
for (int i = rowStart; i < rowLimit; i++) {
const QSurfaceDataRow &row = *array.at(i);
const QSurfaceDataRow &row = array.at(i);
for (int j = columnStart; j < columnLimit; j++) {
QVector3D pos = getNormalizedVertex(row.at(j), isPolar, false);
heights.push_back(QVector4D(pos, .0f));
@ -649,7 +650,7 @@ void QQuickGraphsSurface::updateModel(SurfaceModel *model)
if (m_isIndexDirty) {
QVector<SurfaceVertex> vertices;
for (int i = 0; i < rowCount; i++) {
const QSurfaceDataRow &row = *array.at(i);
const QSurfaceDataRow &row = array.at(i);
for (int j = 0; j < columnCount; j++) {
SurfaceVertex vertex;
QVector3D pos = getNormalizedVertex(row.at(j), isPolar, false);
@ -705,7 +706,7 @@ void QQuickGraphsSurface::updateProxyModel(SurfaceModel *model)
if (!model->proxyModel)
createProxyModel(model);
const QSurfaceDataArray &array = *(model->series->dataProxy())->array();
const QSurfaceDataArray &array = model->series->dataProxy()->array();
if (array.isEmpty())
return;
@ -736,7 +737,7 @@ void QQuickGraphsSurface::updateProxyModel(SurfaceModel *model)
bool isPolar = m_surfaceController->isPolar();
int i = rowStart;
while (i < rowLimit) {
const QSurfaceDataRow &row = *array.at(i);
const QSurfaceDataRow &row = array.at(i);
proxyRowCount++;
int j = columnStart;
while (j < columnLimit) {
@ -782,9 +783,9 @@ void QQuickGraphsSurface::updateProxyModel(SurfaceModel *model)
proxyIndices->resize(indexCount);
const int maxRow = array.size() - 1;
const int maxColumn = array.at(0)->size() - 1;
const bool ascendingX = array.at(0)->at(0).x() < array.at(0)->at(maxColumn).x();
const bool ascendingZ = array.at(0)->at(0).z() < array.at(maxRow)->at(0).z();
const int maxColumn = array.at(0).size() - 1;
const bool ascendingX = array.at(0).at(0).x() < array.at(0).at(maxColumn).x();
const bool ascendingZ = array.at(0).at(0).z() < array.at(maxRow).at(0).z();
int rowEnd = endY * proxyColumnCount;
for (int row = 0; row < rowEnd; row += proxyColumnCount) {

66
tests/auto/cpptest/qgsurface-modelproxy-nan/tst_proxy.cpp
View File

@ -53,16 +53,16 @@ void tst_proxy::dataContainingNaNFirstRow()
graph->addSeries(series);
// X
QSurfaceDataArray *array = new QSurfaceDataArray();
array->reserve(size);
QSurfaceDataArray array;
array.reserve(size);
for (int i = 0; i < size; i++) {
QSurfaceDataRow *row = new QSurfaceDataRow(size);
QSurfaceDataRow row(size);
for (int j = 0; j < size; j++) {
(*row)[j].setPosition(QVector3D((i == missingRow) ? std::numeric_limits<float>::quiet_NaN()
row[j].setPosition(QVector3D((i == missingRow) ? std::numeric_limits<float>::quiet_NaN()
: static_cast<float>(i),
qSin(static_cast<float>(i)), static_cast<float>(j)));
}
*array << row;
array << row;
}
proxy->resetArray(array);
QVERIFY(!qIsNaN(graph->axisX()->min()));
@ -74,14 +74,14 @@ void tst_proxy::dataContainingNaNFirstRow()
// Y
for (int i = 0; i < size; i++) {
QSurfaceDataRow *row = new QSurfaceDataRow(size);
QSurfaceDataRow row(size);
for (int j = 0; j < size; j++) {
(*row)[j].setPosition(QVector3D(static_cast<float>(i),
row[j].setPosition(QVector3D(static_cast<float>(i),
(i == missingRow) ? std::numeric_limits<float>::quiet_NaN()
: qSin(static_cast<float>(i)),
static_cast<float>(j)));
}
*array << row;
array << row;
}
proxy->resetArray(array);
QVERIFY(!qIsNaN(graph->axisX()->min()));
@ -93,14 +93,14 @@ void tst_proxy::dataContainingNaNFirstRow()
// Z
for (int i = 0; i < size; i++) {
QSurfaceDataRow *row = new QSurfaceDataRow(size);
QSurfaceDataRow row(size);
for (int j = 0; j < size; j++) {
(*row)[j].setPosition(QVector3D(static_cast<float>(i),
row[j].setPosition(QVector3D(static_cast<float>(i),
qSin(static_cast<float>(i)),
(i == missingRow) ? std::numeric_limits<float>::quiet_NaN()
: static_cast<float>(j)));
}
*array << row;
array << row;
}
proxy->resetArray(array);
QVERIFY(!qIsNaN(graph->axisX()->min()));
@ -127,16 +127,16 @@ void tst_proxy::dataContainingNaNLastRow()
graph->addSeries(series);
// X
QSurfaceDataArray *array = new QSurfaceDataArray();
array->reserve(size);
QSurfaceDataArray array;
array.reserve(size);
for (int i = 0; i < size; i++) {
QSurfaceDataRow *row = new QSurfaceDataRow(size);
QSurfaceDataRow row(size);
for (int j = 0; j < size; j++) {
(*row)[j].setPosition(QVector3D((i == missingRow) ? std::numeric_limits<float>::quiet_NaN()
row[j].setPosition(QVector3D((i == missingRow) ? std::numeric_limits<float>::quiet_NaN()
: static_cast<float>(i),
qSin(static_cast<float>(i)), static_cast<float>(j)));
}
*array << row;
array << row;
}
proxy->resetArray(array);
QVERIFY(!qIsNaN(graph->axisX()->min()));
@ -148,14 +148,14 @@ void tst_proxy::dataContainingNaNLastRow()
// Y
for (int i = 0; i < size; i++) {
QSurfaceDataRow *row = new QSurfaceDataRow(size);
QSurfaceDataRow row(size);
for (int j = 0; j < size; j++) {
(*row)[j].setPosition(QVector3D(static_cast<float>(i),
row[j].setPosition(QVector3D(static_cast<float>(i),
(i == missingRow) ? std::numeric_limits<float>::quiet_NaN()
: qSin(static_cast<float>(i)),
static_cast<float>(j)));
}
*array << row;
array << row;
}
proxy->resetArray(array);
QVERIFY(!qIsNaN(graph->axisX()->min()));
@ -167,14 +167,14 @@ void tst_proxy::dataContainingNaNLastRow()
// Z
for (int i = 0; i < size; i++) {
QSurfaceDataRow *row = new QSurfaceDataRow(size);
QSurfaceDataRow row(size);
for (int j = 0; j < size; j++) {
(*row)[j].setPosition(QVector3D(static_cast<float>(i),
row[j].setPosition(QVector3D(static_cast<float>(i),
qSin(static_cast<float>(i)),
(i == missingRow) ? std::numeric_limits<float>::quiet_NaN()
: static_cast<float>(j)));
}
*array << row;
array << row;
}
proxy->resetArray(array);
QVERIFY(!qIsNaN(graph->axisX()->min()));
@ -200,17 +200,17 @@ void tst_proxy::dataContainingNaNFirstLastRow()
graph->addSeries(series);
// X
QSurfaceDataArray *array = new QSurfaceDataArray();
array->reserve(size);
QSurfaceDataArray array;
array.reserve(size);
for (int i = 0; i < size; i++) {
bool missingRow = (i == rowFirst || i == rowLast);
QSurfaceDataRow *row = new QSurfaceDataRow(size);
QSurfaceDataRow row(size);
for (int j = 0; j < size; j++) {
(*row)[j].setPosition(QVector3D(missingRow ? std::numeric_limits<float>::quiet_NaN()
row[j].setPosition(QVector3D(missingRow ? std::numeric_limits<float>::quiet_NaN()
: static_cast<float>(i),
qSin(static_cast<float>(i)), static_cast<float>(j)));
}
*array << row;
array << row;
}
proxy->resetArray(array);
QVERIFY(!qIsNaN(graph->axisX()->min()));
@ -223,14 +223,14 @@ void tst_proxy::dataContainingNaNFirstLastRow()
// Y
for (int i = 0; i < size; i++) {
bool missingRow = (i == rowFirst || i == rowLast);
QSurfaceDataRow *row = new QSurfaceDataRow(size);
QSurfaceDataRow row(size);
for (int j = 0; j < size; j++) {
(*row)[j].setPosition(QVector3D(static_cast<float>(i),
row[j].setPosition(QVector3D(static_cast<float>(i),
missingRow ? std::numeric_limits<float>::quiet_NaN()
: qSin(static_cast<float>(i)),
static_cast<float>(j)));
}
*array << row;
array << row;
}
proxy->resetArray(array);
QVERIFY(!qIsNaN(graph->axisX()->min()));
@ -243,14 +243,14 @@ void tst_proxy::dataContainingNaNFirstLastRow()
// Z
for (int i = 0; i < size; i++) {
bool missingRow = (i == rowFirst || i == rowLast);
QSurfaceDataRow *row = new QSurfaceDataRow(size);
QSurfaceDataRow row(size);
for (int j = 0; j < size; j++) {
(*row)[j].setPosition(QVector3D(static_cast<float>(i),
row[j].setPosition(QVector3D(static_cast<float>(i),
qSin(static_cast<float>(i)),
missingRow ? std::numeric_limits<float>::quiet_NaN()
: static_cast<float>(j)));
}
*array << row;
array << row;
}
proxy->resetArray(array);
QVERIFY(!qIsNaN(graph->axisX()->min()));

16
tests/auto/cpptest/qgsurface-proxy/tst_proxy.cpp
View File

@ -65,12 +65,12 @@ void tst_proxy::initializeProperties()
{
QVERIFY(m_proxy);
QSurfaceDataArray *data = new QSurfaceDataArray;
QSurfaceDataRow *dataRow1 = new QSurfaceDataRow;
QSurfaceDataRow *dataRow2 = new QSurfaceDataRow;
*dataRow1 << QVector3D(0.0f, 0.1f, 0.5f) << QVector3D(1.0f, 0.5f, 0.5f);
*dataRow2 << QVector3D(0.0f, 1.8f, 1.0f) << QVector3D(1.0f, 1.2f, 1.0f);
*data << dataRow1 << dataRow2;
QSurfaceDataArray data;
QSurfaceDataRow dataRow1;
QSurfaceDataRow dataRow2;
dataRow1 << QVector3D(0.0f, 0.1f, 0.5f) << QVector3D(1.0f, 0.5f, 0.5f);
dataRow2 << QVector3D(0.0f, 1.8f, 1.0f) << QVector3D(1.0f, 1.2f, 1.0f);
data << dataRow1 << dataRow2;
m_proxy->resetArray(data);
@ -83,8 +83,8 @@ void tst_proxy::initialRow()
QSurfaceDataProxy proxy;
QSurfaceDataRow row{QSurfaceDataItem{QVector3D{0, 0, 0}},
QSurfaceDataItem{QVector3D{1, 1, 1}}};
proxy.addRow(new QSurfaceDataRow(row));
proxy.addRow(new QSurfaceDataRow(row));
proxy.addRow(QSurfaceDataRow(row));
proxy.addRow(QSurfaceDataRow(row));
}
QTEST_MAIN(tst_proxy)

12
tests/auto/cpptest/qgsurface/tst_surface.cpp
View File

@ -37,12 +37,12 @@ private:
QSurface3DSeries *newSeries()
{
QSurface3DSeries *series = new QSurface3DSeries;
QSurfaceDataArray *data = new QSurfaceDataArray;
QSurfaceDataRow *dataRow1 = new QSurfaceDataRow;
QSurfaceDataRow *dataRow2 = new QSurfaceDataRow;
*dataRow1 << QVector3D(0.0f, 0.1f, 0.5f) << QVector3D(1.0f, 0.5f, 0.5f);
*dataRow2 << QVector3D(0.0f, 1.8f, 1.0f) << QVector3D(1.0f, 1.2f, 1.0f);
*data << dataRow1 << dataRow2;
QSurfaceDataArray data;
QSurfaceDataRow dataRow1;
QSurfaceDataRow dataRow2;
dataRow1 << QVector3D(0.0f, 0.1f, 0.5f) << QVector3D(1.0f, 0.5f, 0.5f);
dataRow2 << QVector3D(0.0f, 1.8f, 1.0f) << QVector3D(1.0f, 1.2f, 1.0f);
data << dataRow1 << dataRow2;
series->dataProxy()->resetArray(data);
return series;

2
tests/manual/multigraphs/data.cpp
View File

@ -97,7 +97,7 @@ void Data::clearData()
{
m_bars->seriesList().at(0)->dataProxy()->resetArray();
m_scatter->seriesList().at(0)->dataProxy()->resetArray();
m_surface->seriesList().at(0)->dataProxy()->resetArray(0);
m_surface->seriesList().at(0)->dataProxy()->resetArray();
}
void Data::setResolution(int selection)

218
tests/manual/surfacetest/graphmodifier.cpp
View File

@ -125,24 +125,24 @@ void GraphModifier::fillSeries()
{
float full = m_limitX * m_limitZ;
QSurfaceDataArray *dataArray1 = new QSurfaceDataArray;
dataArray1->reserve(m_zCount);
QSurfaceDataArray *dataArray2 = new QSurfaceDataArray;
dataArray2->reserve(m_zCount);
QSurfaceDataArray *dataArray3 = new QSurfaceDataArray;
dataArray3->reserve(m_zCount);
QSurfaceDataArray *dataArray4 = new QSurfaceDataArray;
dataArray4->reserve(m_zCount);
QSurfaceDataArray dataArray1;
dataArray1.reserve(m_zCount);
QSurfaceDataArray dataArray2;
dataArray2.reserve(m_zCount);
QSurfaceDataArray dataArray3;
dataArray3.reserve(m_zCount);
QSurfaceDataArray dataArray4;
dataArray4.reserve(m_zCount);
for (int i = 0; i < m_zCount; i++) {
QSurfaceDataRow *newRow[4];
QSurfaceDataRow newRow[4];
float zAdjust = 0.0f;
if (i == 2)
zAdjust = 0.7f;
for (int s = 0; s < 4; s++) {
newRow[s] = new QSurfaceDataRow(m_xCount);
newRow[s].resize(m_xCount);
float z = float(i) - m_limitZ + 0.5f + m_multiSampleOffsetZ[s] + zAdjust;
for (int j = 0; j < m_xCount; j++) {
float xAdjust = 0.0f;
@ -151,13 +151,13 @@ void GraphModifier::fillSeries()
float x = float(j) - m_limitX + 0.5f + m_multiSampleOffsetX[s] + xAdjust;
float angle = (z * x) / full * 1.57f;
float y = (qSin(angle * float(qPow(1.3f, s))) + 1.1f * s) * 3.0f - 5.0f + xAdjust + zAdjust;
(*newRow[s])[j].setPosition(QVector3D(x, y, z));
newRow[s][j].setPosition(QVector3D(x, y, z));
}
}
*dataArray1 << newRow[0];
*dataArray2 << newRow[1];
*dataArray3 << newRow[2];
*dataArray4 << newRow[3];
dataArray1 << newRow[0];
dataArray2 << newRow[1];
dataArray3 << newRow[2];
dataArray4 << newRow[3];
}
m_multiseries[0]->dataProxy()->resetArray(dataArray1);
@ -369,10 +369,10 @@ void GraphModifier::toggleSqrtSin(int enable)
float stepX = (maxX - minX) / float(m_xCount - 1);
float stepZ = (maxZ - minZ) / float(m_zCount - 1);
QSurfaceDataArray *dataArray = new QSurfaceDataArray;
dataArray->reserve(m_zCount);
QSurfaceDataArray dataArray;
dataArray.reserve(m_zCount);
for (float i = 0; i < m_zCount; i++) {
QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
QSurfaceDataRow newRow(m_xCount);
// Keep values within range bounds, since just adding step can cause minor drift due
// to the rounding errors.
float z = qMin(maxZ, (i * stepZ + minZ));
@ -380,9 +380,9 @@ void GraphModifier::toggleSqrtSin(int enable)
float x = qMin(maxX, (j * stepX + minX));
float R = qSqrt(x * x + z * z) + 0.01f;
float y = (qSin(R) / R + 0.24f) * 1.61f + 1.0f;
(*newRow)[j].setPosition(QVector3D(x, y, z));
newRow[j].setPosition(QVector3D(x, y, z));
}
*dataArray << newRow;
dataArray << newRow;
}
m_graph->axisY()->setRange(1.0, 3.0);
@ -404,7 +404,7 @@ void GraphModifier::togglePlane(int enable)
qDebug() << "GraphModifier::togglePlane " << enable;
if (enable) {
m_planeArray = new QSurfaceDataArray;
m_planeArray.clear();
#ifdef JITTER_PLANE
m_timer.start(0);
@ -413,7 +413,7 @@ void GraphModifier::togglePlane(int enable)
m_graph->axisX()->setLabelFormat("%.2f");
m_graph->axisZ()->setLabelFormat("%.2f");
m_planeArray->reserve(m_zCount);
m_planeArray.reserve(m_zCount);
float minX = -10.0f;
float maxX = 20.0f;
float minZ = -10.0f;
@ -448,7 +448,7 @@ void GraphModifier::togglePlane(int enable)
resetArrayAndSliders(m_planeArray, minZ, maxZ + add, minX, m_xCount * maxStepX + minX);
#else
for (float i = 0; i < m_zCount; i++) {
QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
QSurfaceDataRow newRow(m_xCount);
// Keep values within range bounds, since just adding step can cause minor drift due
// to the rounding errors.
float zVal;
@ -459,10 +459,10 @@ void GraphModifier::togglePlane(int enable)
float j = 0;
for (; j < m_xCount - 1; j++)
(*newRow)[j].setPosition(QVector3D(j * stepX + minX, -0.04f, zVal));
(*newRow)[j].setPosition(QVector3D(maxX, -0.04f, zVal));
newRow[j].setPosition(QVector3D(j * stepX + minX, -0.04f, zVal));
newRow[j].setPosition(QVector3D(maxX, -0.04f, zVal));
*m_planeArray << newRow;
m_planeArray << newRow;
}
m_theSeries->setName("Plane");
@ -486,11 +486,11 @@ void GraphModifier::setHeightMapData(bool enable)
// Easier alternative would be to use the QHeightMapSurfaceDataProxy.
QImage image(":/maps/map");
QSurfaceDataArray *dataArray = new QSurfaceDataArray;
QSurfaceDataArray dataArray;
uchar *bits = image.bits();
int p = image.width() * 4 * (image.height() - 1);
dataArray->reserve(image.height());
dataArray.reserve(image.height());
float minX = 34.0;
float maxX = 40.0;
float minZ = 18.0;
@ -498,13 +498,13 @@ void GraphModifier::setHeightMapData(bool enable)
float xMul = (maxX - minX) / float(image.width() - 1);
float zMul = (maxZ - minZ) / float(image.height() - 1);
for (int i = 0; i < image.height(); i++, p -= image.width() * 4) {
QSurfaceDataRow *newRow = new QSurfaceDataRow(image.width());
QSurfaceDataRow newRow(image.width());
for (int j = 0; j < image.width(); j++) {
(*newRow)[j].setPosition(QVector3D((float(j) * xMul) + minX,
newRow[j].setPosition(QVector3D((float(j) * xMul) + minX,
(float(bits[p + (j * 4)]) + 1.0f) / 1.0f,
(float(i) * zMul) + minZ));
}
*dataArray << newRow;
dataArray << newRow;
}
m_graph->axisY()->setAutoAdjustRange(true);
@ -666,17 +666,17 @@ void GraphModifier::flipViews()
void GraphModifier::timeout()
{
int rows = m_planeArray->size();
int columns = m_planeArray->at(0)->size();
int rows = m_planeArray.size();
int columns = m_planeArray.at(0).size();
// Induce minor random jitter to the existing plane array
for (int i = 0; i < rows; i++) {
for (int j = 0; j < columns; j++) {
(*m_planeArray->at(i))[j].setX(m_planeArray->at(i)->at(j).x()
m_planeArray[i][j].setX(m_planeArray.at(i).at(j).x()
* ((float((QRandomGenerator::global()->bounded(10)) + 5.0f) / 10000.0f) + 0.999f));
(*m_planeArray->at(i))[j].setY(m_planeArray->at(i)->at(j).y()
m_planeArray[i][j].setY(m_planeArray.at(i).at(j).y()
* ((float((QRandomGenerator::global()->bounded(10)) + 5.0f) / 1000.0f) + 0.99f) + 0.0001f);
(*m_planeArray->at(i))[j].setZ(m_planeArray->at(i)->at(j).z()
m_planeArray[i][j].setZ(m_planeArray.at(i).at(j).z()
* ((float((QRandomGenerator::global()->bounded(10)) + 5.0f) / 10000.0f) + 0.999f));
}
}
@ -741,25 +741,26 @@ void GraphModifier::toggleXAscending(int enabled)
m_ascendingX = enabled;
// Flip data array contents if necessary
const auto surfaceSeriesList = m_graph->seriesList();
for (const auto &series : surfaceSeriesList) {
QSurfaceDataArray *array = const_cast<QSurfaceDataArray *>(series->dataProxy()->array());
const int rowCount = array->size();
const int columnCount = array->at(0)->size();
const bool dataAscending = array->at(0)->at(0).x() < array->at(0)->at(columnCount - 1).x();
QSurfaceDataArray &array = const_cast<QSurfaceDataArray &>(series->dataProxy()->array());
const int rowCount = array.size();
const int columnCount = array.at(0).size();
const bool dataAscending = array.at(0).at(0).x() < array.at(0).at(columnCount - 1).x();
if (dataAscending != enabled) {
// Create new array of equal size
QSurfaceDataArray *newArray = new QSurfaceDataArray;
newArray->reserve(rowCount);
QSurfaceDataArray newArray;
newArray.reserve(rowCount);
for (int i = 0; i < rowCount; i++)
newArray->append(new QSurfaceDataRow(columnCount));
newArray.append(QSurfaceDataRow(columnCount));
// Flip each row
for (int i = 0; i < rowCount; i++) {
QSurfaceDataRow *oldRow = array->at(i);
QSurfaceDataRow *newRow = newArray->at(i);
QSurfaceDataRow oldRow = array.at(i);
QSurfaceDataRow newRow = newArray.at(i);
for (int j = 0; j < columnCount; j++)
(*newRow)[j] = oldRow->at(columnCount - 1 - j);
newRow[j] = oldRow.at(columnCount - 1 - j);
}
series->dataProxy()->resetArray(newArray);
@ -774,23 +775,23 @@ void GraphModifier::toggleZAscending(int enabled)
// Flip data array contents if necessary
const auto surfaceSeriesList = m_graph->seriesList();
for (const auto &series : surfaceSeriesList) {
QSurfaceDataArray *array = const_cast<QSurfaceDataArray *>(series->dataProxy()->array());
const int rowCount = array->size();
const int columnCount = array->at(0)->size();
const bool dataAscending = array->at(0)->at(0).z() < array->at(rowCount - 1)->at(0).z();
QSurfaceDataArray &array = const_cast<QSurfaceDataArray &>(series->dataProxy()->array());
const int rowCount = array.size();
const int columnCount = array.at(0).size();
const bool dataAscending = array.at(0).at(0).z() < array.at(rowCount - 1).at(0).z();
if (dataAscending != enabled) {
// Create new array of equal size
QSurfaceDataArray *newArray = new QSurfaceDataArray;
newArray->reserve(rowCount);
QSurfaceDataArray newArray;
newArray.reserve(rowCount);
for (int i = 0; i < rowCount; i++)
newArray->append(new QSurfaceDataRow(columnCount));
newArray.append(QSurfaceDataRow(columnCount));
// Flip each column
for (int i = 0; i < rowCount; i++) {
QSurfaceDataRow *oldRow = array->at(rowCount - 1 - i);
QSurfaceDataRow *newRow = newArray->at(i);
QSurfaceDataRow oldRow = array.at(rowCount - 1 - i);
QSurfaceDataRow newRow = newArray.at(i);
for (int j = 0; j < columnCount; j++)
(*newRow)[j] = oldRow->at(j);
newRow[j] = oldRow.at(j);
}
series->dataProxy()->resetArray(newArray);
@ -833,7 +834,7 @@ void GraphModifier::setGraphMargin(int value)
qDebug() << "Setting margin:" << m_graph->margin() << value;
}
void GraphModifier::resetArrayAndSliders(QSurfaceDataArray *array, float minZ, float maxZ, float minX, float maxX)
void GraphModifier::resetArrayAndSliders(QSurfaceDataArray array, float minZ, float maxZ, float minX, float maxX)
{
m_axisMinSliderX->setValue(minX);
m_axisMinSliderZ->setValue(minZ);
@ -870,13 +871,13 @@ void GraphModifier::changeRow()
float stepZ = (maxZ - minZ) / float(m_zCount - 1);
float i = float(QRandomGenerator::global()->bounded(m_zCount));
QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
QSurfaceDataRow newRow(m_xCount);
float z = qMin(maxZ, (i * stepZ + minZ));
for (float j = 0; j < m_xCount; j++) {
float x = qMin(maxX, (j * stepX + minX));
float R = qSqrt(x * x + z * z) + 0.01f;
float y = (qSin(R) / R + 0.24f) * 1.61f + 1.2f;
(*newRow)[j].setPosition(QVector3D(x, y, z));
newRow[j].setPosition(QVector3D(x, y, z));
}
m_theSeries->dataProxy()->setRow(int(i), newRow);
@ -886,7 +887,7 @@ void GraphModifier::changeRow()
qDebug() << "Generating new values to a row at random pos for series " << changeRowSeries;
int row = QRandomGenerator::global()->bounded(m_zCount);
QSurfaceDataRow *newRow = createMultiRow(row, changeRowSeries, true);
QSurfaceDataRow newRow = createMultiRow(row, changeRowSeries, true);
if (m_ascendingZ)
m_multiseries[changeRowSeries]->dataProxy()->setRow(row, newRow);
else
@ -901,25 +902,25 @@ void GraphModifier::changeRow()
}
}
QSurfaceDataRow *GraphModifier::createMultiRow(int row, int series, bool change)
QSurfaceDataRow GraphModifier::createMultiRow(int row, int series, bool change)
{
int full = m_limitX * m_limitZ;
float i = float(row);
QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
QSurfaceDataRow newRow(m_xCount);
float z = float(i) - m_limitZ + 0.5f + m_multiSampleOffsetZ[series];
if (m_ascendingX) {
for (int j = 0; j < m_xCount; j++) {
float x = float(j) - m_limitX + 0.5f + m_multiSampleOffsetX[series];
float angle = (z * x) / float(full) * 1.57f;
float y = qSin(angle * float(qPow(1.3f, series))) + 0.2f * float(change) + 1.1f *series;
(*newRow)[j].setPosition(QVector3D(x, y, z));
newRow[j].setPosition(QVector3D(x, y, z));
}
} else {
for (int j = m_xCount - 1; j >= 0 ; j--) {
float x = float(j) - m_limitX + 0.5f + m_multiSampleOffsetX[series];
float angle = (z * x) / float(full) * 1.57f;
float y = qSin(angle * float(qPow(1.3f, series))) + 0.2f * float(change) + 1.1f *series;
(*newRow)[(m_xCount - 1) - j].setPosition(QVector3D(x, y, z));
newRow[(m_xCount - 1) - j].setPosition(QVector3D(x, y, z));
}
}
@ -930,19 +931,19 @@ void GraphModifier::populateRisingSeries(QSurface3DSeries *series, int rows, int
float minValue, float maxValue, bool ascendingX,
bool ascendingZ)
{
QSurfaceDataArray *dataArray = new QSurfaceDataArray;
dataArray->reserve(rows);
QSurfaceDataArray dataArray;
dataArray.reserve(rows);
float range = maxValue - minValue;
int arraySize = rows * columns;
for (int i = 0; i < rows; i++) {
QSurfaceDataRow *dataRow = new QSurfaceDataRow(columns);
QSurfaceDataRow dataRow(columns);
for (int j = 0; j < columns; j++) {
float xValue = ascendingX ? float(j) : float(columns - j - 1);
float yValue = minValue + (range * i * j / arraySize);
float zValue = ascendingZ ? float(i) : float(rows - i - 1);
(*dataRow)[j].setPosition(QVector3D(xValue, yValue, zValue));
dataRow[j].setPosition(QVector3D(xValue, yValue, zValue));
}
dataArray->append(dataRow);
dataArray.append(dataRow);
}
series->dataProxy()->resetArray(dataArray);
@ -964,13 +965,13 @@ void GraphModifier::changeRows()
QSurfaceDataArray dataArray;
for (float i = start; i < (start + 3.0f); i++) {
QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
QSurfaceDataRow newRow(m_xCount);
float z = qMin(maxZ, (i * stepZ + minZ));
for (float j = 0; j < m_xCount; j++) {
float x = qMin(maxX, (j * stepX + minX));
float R = qSqrt(x * x + z * z) + 0.01f;
float y = (qSin(R) / R + 0.24f) * 1.61f + 1.2f;
(*newRow)[j].setPosition(QVector3D(x, y, z));
newRow[j].setPosition(QVector3D(x, y, z));
}
dataArray.append(newRow);
}
@ -984,7 +985,7 @@ void GraphModifier::changeRows()
int row = QRandomGenerator::global()->bounded(m_zCount - 3);
QSurfaceDataArray dataArray;
for (int i = 0; i < 3; i++) {
QSurfaceDataRow *newRow = createMultiRow(row + i, changeRowSeries, true);
QSurfaceDataRow newRow = createMultiRow(row + i, changeRowSeries, true);
dataArray.append(newRow);
}
m_multiseries[changeRowSeries]->dataProxy()->setRows(row, dataArray);
@ -1072,13 +1073,13 @@ void GraphModifier::addRow()
float stepX = (maxX - minX) / float(m_xCount - 1);
float stepZ = (maxZ - minZ) / float(m_zCount - 1);
QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
QSurfaceDataRow newRow(m_xCount);
float z = float(m_addRowCounter) * stepZ + minZ;
for (float j = 0; j < m_xCount; j++) {
float x = qMin(maxX, (j * stepX + minX));
float R = qSqrt(x * x + z * z) + 0.01f;
float y = (qSin(R) / R + 0.24f) * 1.61f + 1.0f;
(*newRow)[j].setPosition(QVector3D(x, y, z));
newRow[j].setPosition(QVector3D(x, y, z));
}
m_addRowCounter++;
@ -1089,12 +1090,12 @@ void GraphModifier::addRow()
int full = m_limitX * m_limitZ;
int series = 2;
QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
QSurfaceDataRow newRow(m_xCount);
float z = float(m_addRowCounter) - m_limitZ + 0.5f + m_multiSampleOffsetZ[series];
for (int j = 0; j < m_xCount; j++) {
float x = float(j) - m_limitX + 0.5f + m_multiSampleOffsetX[series];
float angle = float(z * x) / float(full) * 1.57f;
(*newRow)[j].setPosition(QVector3D(x, qSin(angle *float(qPow(1.3f, series))) + 1.1f * series, z));
newRow[j].setPosition(QVector3D(x, qSin(angle *float(qPow(1.3f, series))) + 1.1f * series, z));
}
m_addRowCounter++;
@ -1120,13 +1121,13 @@ void GraphModifier::addRows()
QSurfaceDataArray dataArray;
for (int i = 0; i < 3; i++) {
QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
QSurfaceDataRow newRow(m_xCount);
float z = m_addRowCounter * stepZ + minZ;
for (float j = 0; j < m_xCount; j++) {
float x = qMin(maxX, (j * stepX + minX));
float R = qSqrt(x * x + z * z) + 0.01f;
float y = (qSin(R) / R + 0.24f) * 1.61f + 1.0f;
(*newRow)[j].setPosition(QVector3D(x, y, z));
newRow[j].setPosition(QVector3D(x, y, z));
}
dataArray.append(newRow);
m_addRowCounter++;
@ -1140,7 +1141,7 @@ void GraphModifier::addRows()
QSurfaceDataArray dataArray;
for (int i = 0; i < 3; i++) {
QSurfaceDataRow *newRow = createMultiRow(m_addRowCounter, changedSeries, false);
QSurfaceDataRow newRow = createMultiRow(m_addRowCounter, changedSeries, false);
dataArray.append(newRow);
m_addRowCounter++;
}
@ -1163,13 +1164,13 @@ void GraphModifier::insertRow()
float stepX = (maxX - minX) / float(m_xCount - 1);
float stepZ = (maxZ - minZ) / float(m_zCount - 1);
QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
QSurfaceDataRow newRow(m_xCount);
float z = qMin(maxZ, (float(m_insertTestZPos) * stepZ + minZ + (stepZ / 2.0f)));
for (float j = 0; j < m_xCount; j++) {
float x = qMin(maxX, (j * stepX + minX));
float R = qSqrt(x * x + z * z) + 0.01f;
float y = (qSin(R) / R + 0.24f) * 1.61f + 1.3f;
(*newRow)[j].setPosition(QVector3D(x, y, z));
newRow[j].setPosition(QVector3D(x, y, z));
}
m_insertTestZPos++;
@ -1181,12 +1182,12 @@ void GraphModifier::insertRow()
int full = m_limitX * m_limitZ;
int changedSeries = 2;
QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
QSurfaceDataRow newRow(m_xCount);
float z = float(m_insertTestZPos) - m_limitZ + m_multiSampleOffsetZ[changedSeries];
for (int j = 0; j < m_xCount; j++) {
float x = float(j) - m_limitX + m_multiSampleOffsetX[changedSeries];
float angle = (z * x) / float(full) * 1.57f;
(*newRow)[j].setPosition(QVector3D(x + 0.5f,
newRow[j].setPosition(QVector3D(x + 0.5f,
qSin(angle * float(qPow(1.3f, changedSeries))) + 1.2f * changedSeries,
z + 1.0f));
}
@ -1214,13 +1215,13 @@ void GraphModifier::insertRows()
QSurfaceDataArray dataArray;
for (int i = 0; i < 3; i++) {
QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
QSurfaceDataRow newRow(m_xCount);
float z = qMin(maxZ, (float(m_insertTestZPos) * stepZ + minZ + i * (stepZ / 4.0f)));
for (float j = 0; j < m_xCount; j++) {
float x = qMin(maxX, (j * stepX + minX));
float R = qSqrt(x * x + z * z) + 0.01f;
float y = (qSin(R) / R + 0.24f) * 1.61f + 1.3f;
(*newRow)[j].setPosition(QVector3D(x, y, z));
newRow[j].setPosition(QVector3D(x, y, z));
}
dataArray.append(newRow);
}
@ -1237,13 +1238,13 @@ void GraphModifier::insertRows()
QSurfaceDataArray dataArray;
float zAdd = 0.25f;
for (int i = 0; i < 3; i++) {
QSurfaceDataRow *newRow = new QSurfaceDataRow(m_xCount);
QSurfaceDataRow newRow(m_xCount);
float z = float(m_insertTestZPos) - m_limitZ + 0.5f + zAdd + m_multiSampleOffsetZ[changedSeries];
for (int j = 0; j < m_xCount; j++) {
float x = float(j) - m_limitX + 0.5f + m_multiSampleOffsetX[changedSeries];
float angle = (z * x) / float(full) * 1.57f;
float y = qSin(angle * float(qPow(1.3f, changedSeries))) + + 1.2f * changedSeries;
(*newRow)[j].setPosition(QVector3D(x, y, z));
newRow[j].setPosition(QVector3D(x, y, z));
}
zAdd += 0.25f;
dataArray.append(newRow);
@ -1282,16 +1283,16 @@ void GraphModifier::resetArray()
int rows = 10;
int columns = 10;
float randFactor = float(QRandomGenerator::global()->bounded(100)) / 100.0f;
QSurfaceDataArray *planeArray = new QSurfaceDataArray;
planeArray->reserve(rows);
QSurfaceDataArray planeArray;
planeArray.reserve(rows);
for (int i = 0; i < rows; i++) {
planeArray->append(new QSurfaceDataRow);
(*planeArray)[i]->resize(columns);
planeArray.append(QSurfaceDataRow());
planeArray[i].resize(columns);
for (int j = 0; j < columns; j++) {
(*planeArray->at(i))[j].setX(float(j) * randFactor);
(*planeArray->at(i))[j].setY(float(i - j) * randFactor);
(*planeArray->at(i))[j].setZ(float(i));
planeArray[i][j].setX(float(j) * randFactor);
planeArray[i][j].setY(float(i - j) * randFactor);
planeArray[i][j].setZ(float(i));
}
}
@ -1305,12 +1306,11 @@ void GraphModifier::resetArray()
void GraphModifier::resetArrayEmpty()
{
QSurfaceDataArray *emptyArray = new QSurfaceDataArray;
#ifdef MULTI_SERIES
int series = QRandomGenerator::global()->bounded(4);
m_multiseries[series]->dataProxy()->resetArray(emptyArray);
m_multiseries[series]->dataProxy()->resetArray();
#else
m_theSeries->dataProxy()->resetArray(emptyArray);
m_theSeries->dataProxy()->resetArray();
#endif
}
@ -1336,8 +1336,8 @@ void GraphModifier::massiveDataTest()
float rowBase = minY;
float direction = 1.0f;
for (int i = 0; i < cacheSize; i++) {
m_massiveTestCacheArray.append(new QSurfaceDataRow);
m_massiveTestCacheArray[i]->resize(columns);
m_massiveTestCacheArray.append(QSurfaceDataRow());
m_massiveTestCacheArray[i].resize(columns);
rowBase += direction * (float(QRandomGenerator::global()->bounded(3)) / 100.0f);
if (rowBase > maxY) {
rowBase = maxY;
@ -1348,8 +1348,8 @@ void GraphModifier::massiveDataTest()
}
for (int j = 0; j < columns; j++) {
float randFactor = float(QRandomGenerator::global()->bounded(100)) / (100 / yRangeMargin);
(*m_massiveTestCacheArray.at(i))[j].setX(float(j));
(*m_massiveTestCacheArray.at(i))[j].setY(rowBase + randFactor);
m_massiveTestCacheArray[i][j].setX(float(j));
m_massiveTestCacheArray[i][j].setY(rowBase + randFactor);
// Z value is irrelevant, we replace it anyway when we take row to use
}
}
@ -1382,15 +1382,15 @@ void GraphModifier::massiveDataTest()
<< rows << "x" << columns;
// Reset to zero first to avoid having memory allocated for two massive arrays at the same
// time on the second and subsequent runs.
series->dataProxy()->resetArray(0);
QSurfaceDataArray *massiveArray = new QSurfaceDataArray;
massiveArray->reserve(rows);
series->dataProxy()->resetArray();
QSurfaceDataArray massiveArray;
massiveArray.reserve(rows);
for (int i = 0; i < rows; i++) {
QSurfaceDataRow *newRow = new QSurfaceDataRow(*m_massiveTestCacheArray.at(i % cacheSize));
QSurfaceDataRow newRow(m_massiveTestCacheArray.at(i % cacheSize));
for (int j = 0; j < columns; j++)
(*newRow)[j].setZ(float(i));
massiveArray->append(newRow);
newRow[j].setZ(float(i));
massiveArray.append(newRow);
}
qDebug() << __FUNCTION__ << testPhase << ": Massive array creation finished!";
@ -1447,9 +1447,9 @@ void GraphModifier::massiveTestAppendAndScroll()
QSurfaceDataArray appendArray;
appendArray.reserve(addedRows);
for (int i = 0; i < addedRows; i++) {
QSurfaceDataRow *newRow = new QSurfaceDataRow(*m_massiveTestCacheArray.at((i + maxRows) % 1000));
QSurfaceDataRow newRow(m_massiveTestCacheArray.at((i + maxRows) % 1000));
for (int j = 0; j < columns; j++)
(*newRow)[j].setZ(float(maxRows + i));
newRow[j].setZ(float(maxRows + i));
appendArray.append(newRow);
}
m_graph->seriesList().at(0)->dataProxy()->addRows(appendArray);

6
tests/manual/surfacetest/graphmodifier.h
View File

@ -124,9 +124,9 @@ public Q_SLOTS:
private:
void fillSeries();
void resetArrayAndSliders(QSurfaceDataArray *array, float minZ, float maxZ, float minX,
void resetArrayAndSliders(QSurfaceDataArray array, float minZ, float maxZ, float minX,
float maxX);
QSurfaceDataRow *createMultiRow(int row, int series, bool change);
QSurfaceDataRow createMultiRow(int row, int series, bool change);
void populateRisingSeries(QSurface3DSeries *series, int rows, int columns, float minValue,
float maxValue, bool ascendingX, bool ascendingZ);
@ -161,7 +161,7 @@ private:
int m_insertTestZPos;
int m_insertTestIndexPos;
QTimer m_timer;
QSurfaceDataArray *m_planeArray;
QSurfaceDataArray m_planeArray;
QLabel *m_selectionInfoLabel;
QSurface3DSeries *m_theSeries;
QSurface3DSeries::DrawFlags m_drawMode;