sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-04-14 00:07:35 -04:00
Code Issues Packages Projects Releases Wiki Activity

use MDAL Groups instead of guessing them from dataset names

Browse Source
This commit is contained in:
Peter Petrik 2018-07-18 08:35:43 +02:00 committed by Martin Dobias
parent 245d6e29ff
commit 21613cd132
32 changed files with 772 additions and 404 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

167
python/core/auto_generated/mesh/qgsmeshdataprovider.sip.in
View File

@ -10,6 +10,43 @@
class QgsMeshDatasetIndex
{
%Docstring
QgsMeshDatasetIndex is index that identifies the dataset group (e.g. wind speed)
and a dataset in this group (e.g. magnitude of wind speed in particular time)
.. note::
The API is considered EXPERIMENTAL and can be changed without a notice
.. versionadded:: 3.4
%End
%TypeHeaderCode
#include "qgsmeshdataprovider.h"
%End
public:
QgsMeshDatasetIndex( int group = -1, int dataset = -1 );
%Docstring
Creates an index. -1 represents invalid group/dataset
%End
int group() const;
%Docstring
Returns a group index
%End
int dataset() const;
%Docstring
Returns a dataset index within group()
%End
bool isValid() const;
%Docstring
Returns whether index is valid, ie at least groups is set
%End
bool operator == ( const QgsMeshDatasetIndex &other ) const;
};
typedef QgsPoint QgsMeshVertex;
typedef QVector<int> QgsMeshFace;
@ -18,7 +55,7 @@ class QgsMeshDatasetValue
{
%Docstring
QgsMeshDatasetValue represents single mesh dataset value
QgsMeshDatasetValue represents single dataset value
could be scalar or vector. Nodata values are represented by NaNs.
@ -85,14 +122,75 @@ Returns y value
};
class QgsMeshDatasetGroupMetadata
{
%Docstring
QgsMeshDatasetGroupMetadata is a collection of dataset group metadata
such as whether the data is vector or scalar, name
.. note::
The API is considered EXPERIMENTAL and can be changed without a notice
.. versionadded:: 3.4
%End
%TypeHeaderCode
#include "qgsmeshdataprovider.h"
%End
public:
QgsMeshDatasetGroupMetadata();
%Docstring
Constructs an empty metadata object
%End
QgsMeshDatasetGroupMetadata( const QString &name,
bool isScalar,
bool isOnVertices,
const QMap<QString, QString> &extraOptions );
%Docstring
Constructs a valid metadata object
:param name: name of the dataset group
:param isScalar: dataset contains scalar data, specifically the y-value of QgsMeshDatasetValue is NaN
:param isOnVertices: dataset values are defined on mesh's vertices. If false, values are defined on faces.
:param extraOptions: dataset's extra options stored by the provider. Usually contains the name, time value, time units, data file vendor, ...
%End
QString name() const;
%Docstring
Returns name of the dataset group
%End
QMap<QString, QString> extraOptions() const;
%Docstring
Returns extra metadata options, for example description
%End
bool isVector() const;
%Docstring
Returns whether dataset group has vector data
%End
bool isScalar() const;
%Docstring
Returns whether dataset group has scalar data
%End
bool isOnVertices() const;
%Docstring
Returns whether dataset group data is defined on vertices
%End
};
class QgsMeshDatasetMetadata
{
%Docstring
QgsMeshDatasetMetadata is a collection of mesh dataset metadata such
as whether the data is vector or scalar, etc.
as whether the data is valid or associated time for the dataset
.. note::
@ -110,38 +208,18 @@ as whether the data is vector or scalar, etc.
Constructs an empty metadata object
%End
QgsMeshDatasetMetadata( bool isScalar,
bool isValid,
bool isOnVertices,
const QMap<QString, QString> &extraOptions );
QgsMeshDatasetMetadata( double time,
bool isValid );
%Docstring
Constructs a valid metadata object
:param isScalar: dataset contains scalar data, specifically the y-value of QgsMeshDatasetValue is NaN
:param time: a time which this dataset represents in the dataset group
:param isValid: dataset is loadad and valid for fetching the data
:param isOnVertices: dataset values are defined on mesh's vertices. If false, values are defined on faces.
:param extraOptions: dataset's extra options stored by the provider. Usually contains the name, time value, time units, data file vendor, ...
%End
QMap<QString, QString> extraOptions() const;
double time() const;
%Docstring
Returns extra metadata options
Usually including name, description or time variable
%End
bool isVector() const;
%Docstring
Returns whether dataset has vector data
%End
bool isScalar() const;
%Docstring
Returns whether dataset has scalar data
%End
bool isOnVertices() const;
%Docstring
Returns whether dataset data is defined on vertices
Returns the time value for this dataset
%End
bool isValid() const;
@ -157,7 +235,7 @@ class QgsMeshDataSourceInterface /Abstract/
Interface for mesh data sources
Mesh is a collection of vertices and faces in 2D or 3D space
Mesh is a collection of vertices and faces in 2D or 3D space
- vertex - XY(Z) point (in the mesh's coordinate reference system)
- faces - sets of vertices forming a closed shape - typically triangles or quadrilaterals
@ -205,12 +283,15 @@ Returns the mesh face at index
class QgsMeshDatasetSourceInterface /Abstract/
{
%Docstring
Interface for mesh datasets
Interface for mesh datasets and dataset groups
Dataset is a collection of vector or scalar values on vertices or faces of the mesh.
Based on the underlying data provider/format, whole dataset is either stored in memory
or read on demand
Datasets are grouped in the dataset groups. A dataset group represents a measured quantity
(e.g. depth or wind speed), dataset represents values of the quantity in a particular time.
.. note::
The API is considered EXPERIMENTAL and can be changed without a notice
@ -231,17 +312,37 @@ Associate dataset with the mesh
emits dataChanged when successful
%End
virtual int datasetCount() const = 0;
virtual int datasetGroupCount( ) const = 0;
%Docstring
Returns number of datasets loaded
Returns number of datasets groups loaded
%End
virtual QgsMeshDatasetMetadata datasetMetadata( int datasetIndex ) const = 0;
virtual int datasetCount( int groupIndex ) const = 0;
%Docstring
Returns number of datasets loaded in the group
%End
int datasetCount( QgsMeshDatasetIndex index ) const;
%Docstring
Returns number of datasets loaded in the group
%End
virtual QgsMeshDatasetGroupMetadata datasetGroupMetadata( int groupIndex ) const = 0;
%Docstring
Returns dataset group metadata
%End
QgsMeshDatasetGroupMetadata datasetGroupMetadata( QgsMeshDatasetIndex index ) const;
%Docstring
Returns dataset group metadata
%End
virtual QgsMeshDatasetMetadata datasetMetadata( QgsMeshDatasetIndex index ) const = 0;
%Docstring
Returns dataset metadata
%End
virtual QgsMeshDatasetValue datasetValue( int datasetIndex, int valueIndex ) const = 0;
virtual QgsMeshDatasetValue datasetValue( QgsMeshDatasetIndex index, int valueIndex ) const = 0;
%Docstring
Returns vector/scalar value associated with the index from the dataset

10
python/core/auto_generated/mesh/qgsmeshlayer.sip.in
View File

@ -10,8 +10,6 @@
const int NO_ACTIVE_MESH_DATASET;
class QgsMeshLayer : QgsMapLayer
{
@ -171,24 +169,24 @@ Returns renderer settings
Sets new renderer settings, triggers repaint
%End
void setActiveScalarDataset( int index = NO_ACTIVE_MESH_DATASET );
void setActiveScalarDataset( QgsMeshDatasetIndex index = QgsMeshDatasetIndex() );
%Docstring
Sets active scalar dataset for rendering
Triggers repaint
%End
int activeScalarDataset() const;
QgsMeshDatasetIndex activeScalarDataset() const;
%Docstring
Returns active scalar dataset
%End
void setActiveVectorDataset( int index = NO_ACTIVE_MESH_DATASET );
void setActiveVectorDataset( QgsMeshDatasetIndex index = QgsMeshDatasetIndex() );
%Docstring
Sets active vector dataset for rendering.
If dataset is not vector based, do nothing. Triggers repaint
%End
int activeVectorDataset() const;
QgsMeshDatasetIndex activeVectorDataset() const;
%Docstring
Returns active vector dataset
%End

66
src/app/mesh/qgsmeshdatasetgrouptreeview.cpp
View File

@ -217,12 +217,9 @@ void QgsMeshDatasetGroupTreeView::setLayer( QgsMeshLayer *layer )
}
}
QVector<int> QgsMeshDatasetGroupTreeView::datasetsInActiveGroup() const
int QgsMeshDatasetGroupTreeView::activeGroup() const
{
if ( mGroups.constFind( mActiveGroup ) == mGroups.constEnd() )
return QVector<int>();
else
return mGroups[mActiveGroup];
return mActiveGroup;
}
void QgsMeshDatasetGroupTreeView::onSelectionChanged( const QItemSelection &selected, const QItemSelection &deselected )
@ -231,55 +228,43 @@ void QgsMeshDatasetGroupTreeView::onSelectionChanged( const QItemSelection &sele
if ( selected.isEmpty() )
{
mActiveGroup = QString();
mActiveGroup = 0;
return;
}
if ( selected.first().indexes().isEmpty() )
{
mActiveGroup = QString();
mActiveGroup = 0;
return;
}
QModelIndex index = selected.first().indexes().first(); //single selection only
QVariant name = mModel.data( index, 0 );
mActiveGroup = name.toString();
mActiveGroup = index.row();
emit activeGroupChanged();
}
void QgsMeshDatasetGroupTreeView::extractGroups()
{
// TODO replace with MDAL groups when introduced
mGroups.clear();
if ( !mMeshLayer || !mMeshLayer->dataProvider() )
return;
for ( int i = 0; i < mMeshLayer->dataProvider()->datasetCount(); ++i )
for ( int i = 0; i < mMeshLayer->dataProvider()->datasetGroupCount(); ++i )
{
const QgsMeshDatasetMetadata meta = mMeshLayer->dataProvider()->datasetMetadata( i );
QString name = meta.extraOptions()["name"];
if ( mGroups.constFind( name ) == mGroups.constEnd() )
{
QVector<int> datasets;
datasets.append( i );
mGroups[name] = datasets;
}
else
{
mGroups[name].append( i );
}
const QgsMeshDatasetGroupMetadata meta = mMeshLayer->dataProvider()->datasetGroupMetadata( i );
mGroups << meta.name();
}
}
void QgsMeshDatasetGroupTreeView::syncToLayer()
{
mActiveGroup.clear();
mActiveGroup = 0;
extractGroups();
mModel.setupModelData( mGroups.keys() );
mModel.setupModelData( mGroups );
int index = setActiveGroupFromActiveDataset();
@ -290,35 +275,24 @@ void QgsMeshDatasetGroupTreeView::syncToLayer()
int QgsMeshDatasetGroupTreeView::setActiveGroupFromActiveDataset()
{
// find active dataset
int activeDataset = -1;
QgsMeshDatasetIndex activeDataset;
if ( mMeshLayer )
{
activeDataset = mMeshLayer->activeScalarDataset();
if ( activeDataset == -1 )
if ( !activeDataset.isValid() )
activeDataset = mMeshLayer->activeVectorDataset();
}
// find group that contains active dataset
int index = 0;
if ( activeDataset > -1 )
if ( activeDataset.isValid() && activeDataset.group() < mGroups.size() )
{
for ( auto it = mGroups.constBegin(); it != mGroups.constEnd(); ++it )
{
int datasetIndex = it.value().indexOf( activeDataset );
if ( datasetIndex > -1 )
{
mActiveGroup = it.key();
return index;
}
else
{
++index;
}
}
mActiveGroup = activeDataset.group();
}
else
{
// not found, select first item
mActiveGroup = 0;
}
// not found return first item in the list
mActiveGroup = QString();
return 0;
return mActiveGroup;
}

8
src/app/mesh/qgsmeshdatasetgrouptreeview.h
View File

@ -111,8 +111,8 @@ class APP_EXPORT QgsMeshDatasetGroupTreeView : public QTreeView
//! Associates mesh layer with the widget
void setLayer( QgsMeshLayer *layer );
//! Returns all the dataset indexes in the active group
QVector<int> datasetsInActiveGroup() const;
//! Returns index of active group
int activeGroup() const;
//! Synchronize widgets state with associated mesh layer
void syncToLayer();
@ -130,8 +130,8 @@ class APP_EXPORT QgsMeshDatasetGroupTreeView : public QTreeView
QgsMeshDatasetGroupTreeModel mModel;
QgsMeshLayer *mMeshLayer = nullptr; // not owned
QMap<QString, QVector<int>> mGroups; // group name -> dataset indices
QString mActiveGroup;
QStringList mGroups; // group names
int mActiveGroup; // index of active group
};
#endif // QGSMESHDATASETGROUPTREE_H

2
src/app/mesh/qgsmeshlayerproperties.cpp
View File

@ -95,7 +95,7 @@ void QgsMeshLayerProperties::syncToLayer()
info += QStringLiteral( "<tr><td>%1: </td><td>%2</td><tr>" ).arg( tr( "Uri" ) ).arg( mMeshLayer->dataProvider()->dataSourceUri() );
info += QStringLiteral( "<tr><td>%1: </td><td>%2</td><tr>" ).arg( tr( "Vertex count" ) ).arg( mMeshLayer->dataProvider()->vertexCount() );
info += QStringLiteral( "<tr><td>%1: </td><td>%2</td><tr>" ).arg( tr( "Face count" ) ).arg( mMeshLayer->dataProvider()->faceCount() );
info += QStringLiteral( "<tr><td>%1: </td><td>%2</td><tr>" ).arg( tr( "Dataset count" ) ).arg( mMeshLayer->dataProvider()->datasetCount() );
info += QStringLiteral( "<tr><td>%1: </td><td>%2</td><tr>" ).arg( tr( "Dataset groups count" ) ).arg( mMeshLayer->dataProvider()->datasetGroupCount() );
info += QStringLiteral( "</table>" );
}
else

68
src/app/mesh/qgsmeshrendereractivedatasetwidget.cpp
View File

@ -40,36 +40,37 @@ void QgsMeshRendererActiveDatasetWidget::setLayer( QgsMeshLayer *layer )
syncToLayer();
}
int QgsMeshRendererActiveDatasetWidget::activeScalarDataset() const
QgsMeshDatasetIndex QgsMeshRendererActiveDatasetWidget::activeScalarDataset() const
{
return mActiveScalarDataset;
}
int QgsMeshRendererActiveDatasetWidget::activeVectorDataset() const
QgsMeshDatasetIndex QgsMeshRendererActiveDatasetWidget::activeVectorDataset() const
{
return mActiveVectorDataset;
}
void QgsMeshRendererActiveDatasetWidget::onActiveGroupChanged()
{
const QVector<int> datasets = mDatasetGroupTreeView->datasetsInActiveGroup();
int datasetCount = mMeshLayer->dataProvider()->datasetCount( mDatasetGroupTreeView->activeGroup() );
mDatasetSlider->setMinimum( 0 );
mDatasetSlider->setMaximum( datasets.size() - 1 );
mDatasetSlider->setMaximum( datasetCount - 1 );
mDatasetSlider->setValue( 0 );
}
void QgsMeshRendererActiveDatasetWidget::onActiveDatasetChanged( int value )
{
int datasetIndex = -1;
const QVector<int> datasets = mDatasetGroupTreeView->datasetsInActiveGroup();
mActiveScalarDataset = -1;
mActiveVectorDataset = -1;
int groupIndex = mDatasetGroupTreeView->activeGroup();
int datasetCount = mMeshLayer->dataProvider()->datasetCount( groupIndex );
if ( datasets.size() > value && mMeshLayer && mMeshLayer->dataProvider() )
mActiveScalarDataset = QgsMeshDatasetIndex();
mActiveVectorDataset = QgsMeshDatasetIndex();
QgsMeshDatasetIndex datasetIndex( groupIndex, value );
if ( datasetCount > value && mMeshLayer && mMeshLayer->dataProvider() )
{
datasetIndex = datasets[value];
const QgsMeshDatasetMetadata meta = mMeshLayer->dataProvider()->datasetMetadata( datasetIndex );
const QgsMeshDatasetGroupMetadata meta = mMeshLayer->dataProvider()->datasetGroupMetadata( datasetIndex );
mActiveScalarDataset = datasetIndex;
if ( meta.isVector() )
mActiveVectorDataset = datasetIndex;
@ -83,27 +84,36 @@ void QgsMeshRendererActiveDatasetWidget::onActiveDatasetChanged( int value )
emit widgetChanged();
}
void QgsMeshRendererActiveDatasetWidget::updateMetadata( int datasetIndex )
void QgsMeshRendererActiveDatasetWidget::updateMetadata( QgsMeshDatasetIndex datasetIndex )
{
if ( datasetIndex == -1 )
if ( !datasetIndex.isValid() )
{
mActiveDatasetMetadata->setText( tr( "No dataset selected" ) );
}
else
{
const QgsMeshDatasetMetadata meta = mMeshLayer->dataProvider()->datasetMetadata( datasetIndex );
QString msg;
msg += QStringLiteral( "<table>" );
const QgsMeshDatasetMetadata meta = mMeshLayer->dataProvider()->datasetMetadata( datasetIndex );
msg += QStringLiteral( "<tr><td>%1</td><td>%2</td></tr>" )
.arg( tr( "Is valid" ) )
.arg( meta.isValid() ? tr( "Yes" ) : tr( "No" ) );
msg += QStringLiteral( "<tr><td>%1</td><td>%2</td></tr>" )
.arg( tr( "Time" ) )
.arg( meta.time() );
const QgsMeshDatasetGroupMetadata gmeta = mMeshLayer->dataProvider()->datasetGroupMetadata( datasetIndex );
msg += QStringLiteral( "<tr><td>%1</td><td>%2</td></tr>" )
.arg( tr( "Is on vertices" ) )
.arg( meta.isOnVertices() ? tr( "Yes" ) : tr( "No" ) );
.arg( gmeta.isOnVertices() ? tr( "Yes" ) : tr( "No" ) );
msg += QStringLiteral( "<tr><td>%1</td><td>%2</td></tr>" )
.arg( tr( "Is vector" ) )
.arg( meta.isVector() ? tr( "Yes" ) : tr( "No" ) );
.arg( gmeta.isVector() ? tr( "Yes" ) : tr( "No" ) );
for ( auto it = meta.extraOptions().constBegin(); it != meta.extraOptions().constEnd(); ++it )
for ( auto it = gmeta.extraOptions().constBegin(); it != gmeta.extraOptions().constEnd(); ++it )
{
msg += QStringLiteral( "<tr><td>%1</td><td>%2</td></tr>" ).arg( it.key() ).arg( it.value() );
}
@ -114,16 +124,16 @@ void QgsMeshRendererActiveDatasetWidget::updateMetadata( int datasetIndex )
}
int QgsMeshRendererActiveDatasetWidget::datasetIndex() const
QgsMeshDatasetIndex QgsMeshRendererActiveDatasetWidget::datasetIndex() const
{
const QVector<int> datasets = mDatasetGroupTreeView->datasetsInActiveGroup();
int value = mDatasetSlider->value();
int datasetIndex = -1;
if ( value < datasets.size() )
{
datasetIndex = datasets[value];
}
return datasetIndex;
int groupIndex = mDatasetGroupTreeView->activeGroup();
int datasetCount = mMeshLayer->dataProvider()->datasetCount( groupIndex );
if ( datasetCount > value && mMeshLayer && mMeshLayer->dataProvider() )
return QgsMeshDatasetIndex( groupIndex, value );
else
return QgsMeshDatasetIndex();
}
void QgsMeshRendererActiveDatasetWidget::syncToLayer()
@ -137,10 +147,10 @@ void QgsMeshRendererActiveDatasetWidget::syncToLayer()
}
else
{
mActiveScalarDataset = -1;
mActiveVectorDataset = -1;
mActiveScalarDataset = QgsMeshDatasetIndex();
mActiveVectorDataset = QgsMeshDatasetIndex();
}
if ( mActiveScalarDataset != -1 )
whileBlocking( mDatasetSlider )->setValue( mActiveScalarDataset );
if ( mActiveScalarDataset.isValid() )
whileBlocking( mDatasetSlider )->setValue( mActiveScalarDataset.dataset() );
}

17
src/app/mesh/qgsmeshrendereractivedatasetwidget.h
View File

@ -18,6 +18,7 @@
#include "ui_qgsmeshrendereractivedatasetwidgetbase.h"
#include "qgis_app.h"
#include "qgsmeshdataprovider.h"
#include <QWidget>
@ -47,10 +48,10 @@ class APP_EXPORT QgsMeshRendererActiveDatasetWidget : public QWidget, private Ui
void setLayer( QgsMeshLayer *layer );
//! Gets index of the selected/active scalar dataset
int activeScalarDataset() const;
QgsMeshDatasetIndex activeScalarDataset() const;
//! Gets index of the selected/active vector dataset
int activeVectorDataset() const;
QgsMeshDatasetIndex activeVectorDataset() const;
//! Synchronizes widgets state with associated mesh layer
void syncToLayer();
@ -58,10 +59,10 @@ class APP_EXPORT QgsMeshRendererActiveDatasetWidget : public QWidget, private Ui
signals:
//! Emitted when active scalar dataset changed
void activeScalarDatasetChanged( int index );
void activeScalarDatasetChanged( QgsMeshDatasetIndex index );
//! Emitted when active vector dataset changed
void activeVectorDatasetChanged( int index );
void activeVectorDatasetChanged( QgsMeshDatasetIndex index );
//! Emitted when any settings related to rendering changed
void widgetChanged();
@ -69,14 +70,14 @@ class APP_EXPORT QgsMeshRendererActiveDatasetWidget : public QWidget, private Ui
private slots:
void onActiveGroupChanged();
void onActiveDatasetChanged( int value );
void updateMetadata( int datasetIndex );
void updateMetadata( QgsMeshDatasetIndex datasetIndex );
private:
int datasetIndex() const;
QgsMeshDatasetIndex datasetIndex() const;
QgsMeshLayer *mMeshLayer = nullptr; // not owned
int mActiveScalarDataset = -1;
int mActiveVectorDataset = -1;
QgsMeshDatasetIndex mActiveScalarDataset ;
QgsMeshDatasetIndex mActiveVectorDataset;
};
#endif // QGSMESHRENDERERSCALARSETTINGSWIDGET_H

6
src/app/mesh/qgsmeshrendererscalarsettingswidget.cpp
View File

@ -98,12 +98,12 @@ void QgsMeshRendererScalarSettingsWidget::recalculateMinMaxButtonClicked()
mScalarColorRampShaderWidget->setMinimumMaximumAndClassify( min, max );
}
void QgsMeshRendererScalarSettingsWidget::setActiveDataset( int activeDataset )
void QgsMeshRendererScalarSettingsWidget::setActiveDataset( QgsMeshDatasetIndex activeDataset )
{
mActiveDataset = activeDataset;
}
void QgsMeshRendererScalarSettingsWidget::calcMinMax( int datasetIndex, double &min, double &max ) const
void QgsMeshRendererScalarSettingsWidget::calcMinMax( QgsMeshDatasetIndex datasetIndex, double &min, double &max ) const
{
if ( !mMeshLayer )
return;
@ -111,7 +111,7 @@ void QgsMeshRendererScalarSettingsWidget::calcMinMax( int datasetIndex, double &
if ( !mMeshLayer->dataProvider() )
return;
const QgsMeshDatasetMetadata metadata = mMeshLayer->dataProvider()->datasetMetadata( datasetIndex );
const QgsMeshDatasetGroupMetadata metadata = mMeshLayer->dataProvider()->datasetGroupMetadata( datasetIndex );
bool scalarDataOnVertices = metadata.isOnVertices();
int count;
if ( scalarDataOnVertices )

7
src/app/mesh/qgsmeshrendererscalarsettingswidget.h
View File

@ -19,6 +19,7 @@
#include "ui_qgsmeshrendererscalarsettingswidgetbase.h"
#include "qgis_app.h"
#include "qgsmeshrenderersettings.h"
#include "qgsmeshdataprovider.h"
#include <QWidget>
@ -57,7 +58,7 @@ class APP_EXPORT QgsMeshRendererScalarSettingsWidget : public QWidget, private U
public slots:
//! Set active scalar dataset to be used
void setActiveDataset( int activeDatase );
void setActiveDataset( QgsMeshDatasetIndex activeDatase );
private slots:
void minMaxChanged();
@ -66,10 +67,10 @@ class APP_EXPORT QgsMeshRendererScalarSettingsWidget : public QWidget, private U
private:
double lineEditValue( const QLineEdit *lineEdit ) const;
void calcMinMax( int datasetIndex, double &min, double &max ) const;
void calcMinMax( QgsMeshDatasetIndex datasetIndex, double &min, double &max ) const;
QgsMeshLayer *mMeshLayer = nullptr; // not owned
int mActiveDataset = -1;
QgsMeshDatasetIndex mActiveDataset;
};
#endif // QGSMESHRENDERERSCALARSETTINGSWIDGET_H

2
src/app/mesh/qgsmeshrenderervectorsettingswidget.cpp
View File

@ -97,7 +97,7 @@ QgsMeshRendererVectorSettings QgsMeshRendererVectorSettingsWidget::settings() co
return settings;
}
void QgsMeshRendererVectorSettingsWidget::setActiveDataset( int activeDataset )
void QgsMeshRendererVectorSettingsWidget::setActiveDataset( QgsMeshDatasetIndex activeDataset )
{
mActiveDataset = activeDataset;
}

5
src/app/mesh/qgsmeshrenderervectorsettingswidget.h
View File

@ -19,6 +19,7 @@
#include "ui_qgsmeshrenderervectorsettingswidgetbase.h"
#include "qgis_app.h"
#include "qgsmeshrenderersettings.h"
#include "qgsmeshdataprovider.h"
#include <memory>
#include <QWidget>
@ -58,7 +59,7 @@ class APP_EXPORT QgsMeshRendererVectorSettingsWidget : public QWidget, private U
public slots:
//! Set active vector dataset to be used
void setActiveDataset( int activeDataset );
void setActiveDataset( QgsMeshDatasetIndex activeDataset );
private:
@ -69,7 +70,7 @@ class APP_EXPORT QgsMeshRendererVectorSettingsWidget : public QWidget, private U
double filterValue( const QString &text, double errVal ) const;
QgsMeshLayer *mMeshLayer = nullptr; //not owned
int mActiveDataset = -1;
QgsMeshDatasetIndex mActiveDataset;
};
#endif // QGSMESHRENDERERVECTORSETTINGSWIDGET_H

28
src/app/mesh/qgsrenderermeshpropertieswidget.cpp
View File

@ -82,18 +82,18 @@ void QgsRendererMeshPropertiesWidget::apply()
whileBlocking( mMeshLayer )->setRendererTriangularMeshSettings( triangularMeshSettings );
// SCALAR
int activeScalarDatasetIndex = activeScalarDataset();
const QgsMeshDatasetIndex activeScalarDatasetIndex = activeScalarDataset();
whileBlocking( mMeshLayer )->setActiveScalarDataset( activeScalarDatasetIndex );
if ( activeScalarDatasetIndex != -1 )
if ( activeScalarDatasetIndex.isValid() )
{
const QgsMeshRendererScalarSettings settings = mMeshRendererScalarSettingsWidget->settings();
whileBlocking( mMeshLayer )->setRendererScalarSettings( settings );
}
// VECTOR
int activeVectorDatasetIndex = activeVectorDataset();
const QgsMeshDatasetIndex activeVectorDatasetIndex = activeVectorDataset();
whileBlocking( mMeshLayer )->setActiveVectorDataset( activeVectorDatasetIndex );
if ( activeVectorDatasetIndex != -1 )
if ( activeVectorDatasetIndex.isValid() )
{
const QgsMeshRendererVectorSettings settings = mMeshRendererVectorSettingsWidget->settings();
whileBlocking( mMeshLayer )->setRendererVectorSettings( settings );
@ -113,25 +113,25 @@ void QgsRendererMeshPropertiesWidget::syncToLayer()
enableVectorRenderingTab( activeVectorDataset() );
}
void QgsRendererMeshPropertiesWidget::enableVectorRenderingTab( int vectorDatasetIndex )
void QgsRendererMeshPropertiesWidget::enableVectorRenderingTab( QgsMeshDatasetIndex vectorDatasetIndex )
{
mVectorsGroupBox->setEnabled( vectorDatasetIndex != -1 );
mVectorsGroupBox->setEnabled( vectorDatasetIndex.isValid() );
}
int QgsRendererMeshPropertiesWidget::activeScalarDataset() const
QgsMeshDatasetIndex QgsRendererMeshPropertiesWidget::activeScalarDataset() const
{
int activeScalarDatasetIndex = mMeshRendererActiveDatasetWidget->activeScalarDataset();
if ( activeScalarDatasetIndex != -1 && mContoursGroupBox->isChecked() )
QgsMeshDatasetIndex activeScalarDatasetIndex = mMeshRendererActiveDatasetWidget->activeScalarDataset();
if ( activeScalarDatasetIndex.isValid() && mContoursGroupBox->isChecked() )
return activeScalarDatasetIndex;
else
return -1;
return QgsMeshDatasetIndex();
}
int QgsRendererMeshPropertiesWidget::activeVectorDataset() const
QgsMeshDatasetIndex QgsRendererMeshPropertiesWidget::activeVectorDataset() const
{
int activeScalarDatasetIndex = mMeshRendererActiveDatasetWidget->activeVectorDataset();
if ( activeScalarDatasetIndex != -1 && mVectorsGroupBox->isChecked() )
QgsMeshDatasetIndex activeScalarDatasetIndex = mMeshRendererActiveDatasetWidget->activeVectorDataset();
if ( activeScalarDatasetIndex.isValid() && mVectorsGroupBox->isChecked() )
return activeScalarDatasetIndex;
else
return -1;
return QgsMeshDatasetIndex();
}

6
src/app/mesh/qgsrenderermeshpropertieswidget.h
View File

@ -54,14 +54,14 @@ class APP_EXPORT QgsRendererMeshPropertiesWidget : public QgsMapLayerConfigWidge
void syncToLayer();
private slots:
void enableVectorRenderingTab( int vectorDatasetIndex );
void enableVectorRenderingTab( QgsMeshDatasetIndex vectorDatasetIndex );
private:
//! Gets index of the selected/active scalar dataset
int activeScalarDataset() const;
QgsMeshDatasetIndex activeScalarDataset() const;
//! Gets index of the selected/active vector dataset
int activeVectorDataset() const;
QgsMeshDatasetIndex activeVectorDataset() const;
QgsMeshLayer *mMeshLayer = nullptr; //not owned
};

78
src/core/mesh/qgsmeshdataprovider.cpp
View File

@ -18,6 +18,31 @@
#include "qgsmeshdataprovider.h"
#include "qgis.h"
QgsMeshDatasetIndex::QgsMeshDatasetIndex( int group, int dataset ):
mGroupIndex( group ), mDatasetIndex( dataset ) {}
int QgsMeshDatasetIndex::group() const
{
return mGroupIndex;
}
int QgsMeshDatasetIndex::dataset() const
{
return mDatasetIndex;
}
bool QgsMeshDatasetIndex::isValid() const
{
return ( group() > -1 ) && ( dataset() > -1 );
}
bool QgsMeshDatasetIndex::operator ==( const QgsMeshDatasetIndex &other ) const
{
return other.group() == group() && other.dataset() == dataset();
}
QgsMeshDataProvider::QgsMeshDataProvider( const QString &uri, const QgsDataProvider::ProviderOptions &options )
: QgsDataProvider( uri, options )
{
@ -109,40 +134,67 @@ bool QgsMeshDatasetValue::operator==( const QgsMeshDatasetValue &other ) const
return equal;
}
QgsMeshDatasetMetadata::QgsMeshDatasetMetadata(
QgsMeshDatasetGroupMetadata::QgsMeshDatasetGroupMetadata(
const QString &name,
bool isScalar,
bool isValid,
bool isOnVertices,
const QMap<QString, QString> &extraOptions )
: mIsScalar( isScalar )
, mIsValid( isValid )
: mName( name )
, mIsScalar( isScalar )
, mIsOnVertices( isOnVertices )
, mExtraOptions( extraOptions )
{
}
QMap<QString, QString> QgsMeshDatasetMetadata::extraOptions() const
QMap<QString, QString> QgsMeshDatasetGroupMetadata::extraOptions() const
{
return mExtraOptions;
}
bool QgsMeshDatasetMetadata::isVector() const
bool QgsMeshDatasetGroupMetadata::isVector() const
{
return !mIsScalar;
}
bool QgsMeshDatasetMetadata::isScalar() const
bool QgsMeshDatasetGroupMetadata::isScalar() const
{
return mIsScalar;
}
QString QgsMeshDatasetGroupMetadata::name() const
{
return mName;
}
bool QgsMeshDatasetGroupMetadata::isOnVertices() const
{
return mIsOnVertices;
}
int QgsMeshDatasetSourceInterface::datasetCount( QgsMeshDatasetIndex index ) const
{
return datasetCount( index.group() );
}
QgsMeshDatasetGroupMetadata QgsMeshDatasetSourceInterface::datasetGroupMetadata( QgsMeshDatasetIndex index ) const
{
return datasetGroupMetadata( index.group() );
}
QgsMeshDatasetMetadata::QgsMeshDatasetMetadata( double time,
bool isValid )
: mTime( time )
, mIsValid( isValid )
{
}
double QgsMeshDatasetMetadata::time() const
{
return mTime;
}
bool QgsMeshDatasetMetadata::isValid() const
{
return mIsValid;
}
bool QgsMeshDatasetMetadata::isOnVertices() const
{
return mIsOnVertices;
}

160
src/core/mesh/qgsmeshdataprovider.h
View File

@ -28,6 +28,34 @@
#include <QMap>
#include <limits>
/**
* \ingroup core
*
* QgsMeshDatasetIndex is index that identifies the dataset group (e.g. wind speed)
* and a dataset in this group (e.g. magnitude of wind speed in particular time)
*
* \note The API is considered EXPERIMENTAL and can be changed without a notice
*
* \since QGIS 3.4
*/
class CORE_EXPORT QgsMeshDatasetIndex
{
public:
//! Creates an index. -1 represents invalid group/dataset
QgsMeshDatasetIndex( int group = -1, int dataset = -1 );
//! Returns a group index
int group() const;
//! Returns a dataset index within group()
int dataset() const;
//! Returns whether index is valid, ie at least groups is set
bool isValid() const;
//! Equality operator
bool operator == ( const QgsMeshDatasetIndex &other ) const;
private:
int mGroupIndex = -1;
int mDatasetIndex = -1;
};
//! xyz coords of vertex
typedef QgsPoint QgsMeshVertex;
@ -37,7 +65,7 @@ typedef QVector<int> QgsMeshFace;
/**
* \ingroup core
*
* QgsMeshDatasetValue represents single mesh dataset value
* QgsMeshDatasetValue represents single dataset value
*
* could be scalar or vector. Nodata values are represented by NaNs.
*
@ -86,13 +114,72 @@ class CORE_EXPORT QgsMeshDatasetValue
double mY = std::numeric_limits<double>::quiet_NaN();
};
/**
* \ingroup core
*
* QgsMeshDatasetGroupMetadata is a collection of dataset group metadata
* such as whether the data is vector or scalar, name
*
* \note The API is considered EXPERIMENTAL and can be changed without a notice
*
* \since QGIS 3.4
*/
class CORE_EXPORT QgsMeshDatasetGroupMetadata
{
public:
//! Constructs an empty metadata object
QgsMeshDatasetGroupMetadata() = default;
/**
* Constructs a valid metadata object
*
* \param name name of the dataset group
* \param isScalar dataset contains scalar data, specifically the y-value of QgsMeshDatasetValue is NaN
* \param isOnVertices dataset values are defined on mesh's vertices. If false, values are defined on faces.
* \param extraOptions dataset's extra options stored by the provider. Usually contains the name, time value, time units, data file vendor, ...
*/
QgsMeshDatasetGroupMetadata( const QString &name,
bool isScalar,
bool isOnVertices,
const QMap<QString, QString> &extraOptions );
/**
* Returns name of the dataset group
*/
QString name() const;
/**
* Returns extra metadata options, for example description
*/
QMap<QString, QString> extraOptions() const;
/**
* \brief Returns whether dataset group has vector data
*/
bool isVector() const;
/**
* \brief Returns whether dataset group has scalar data
*/
bool isScalar() const;
/**
* \brief Returns whether dataset group data is defined on vertices
*/
bool isOnVertices() const;
private:
QString mName;
bool mIsScalar = false;
bool mIsOnVertices = false;
QMap<QString, QString> mExtraOptions;
};
/**
* \ingroup core
*
* QgsMeshDatasetMetadata is a collection of mesh dataset metadata such
* as whether the data is vector or scalar, etc.
* as whether the data is valid or associated time for the dataset
*
* \note The API is considered EXPERIMENTAL and can be changed without a notice
*
@ -107,36 +194,16 @@ class CORE_EXPORT QgsMeshDatasetMetadata
/**
* Constructs a valid metadata object
*
* \param isScalar dataset contains scalar data, specifically the y-value of QgsMeshDatasetValue is NaN
* \param time a time which this dataset represents in the dataset group
* \param isValid dataset is loadad and valid for fetching the data
* \param isOnVertices dataset values are defined on mesh's vertices. If false, values are defined on faces.
* \param extraOptions dataset's extra options stored by the provider. Usually contains the name, time value, time units, data file vendor, ...
*/
QgsMeshDatasetMetadata( bool isScalar,
bool isValid,
bool isOnVertices,
const QMap<QString, QString> &extraOptions );
QgsMeshDatasetMetadata( double time,
bool isValid );
/**
* Returns extra metadata options
* Usually including name, description or time variable
* \brief Returns the time value for this dataset
*/
QMap<QString, QString> extraOptions() const;
/**
* \brief Returns whether dataset has vector data
*/
bool isVector() const;
/**
* \brief Returns whether dataset has scalar data
*/
bool isScalar() const;
/**
* \brief Returns whether dataset data is defined on vertices
*/
bool isOnVertices() const;
double time() const;
/**
* \brief Returns whether dataset is valid
@ -144,10 +211,8 @@ class CORE_EXPORT QgsMeshDatasetMetadata
bool isValid() const;
private:
bool mIsScalar = false;
double mTime = std::numeric_limits<double>::quiet_NaN();
bool mIsValid = false;
bool mIsOnVertices = false;
QMap<QString, QString> mExtraOptions;
};
/**
@ -155,7 +220,7 @@ class CORE_EXPORT QgsMeshDatasetMetadata
*
* Interface for mesh data sources
*
* Mesh is a collection of vertices and faces in 2D or 3D space
* Mesh is a collection of vertices and faces in 2D or 3D space
* - vertex - XY(Z) point (in the mesh's coordinate reference system)
* - faces - sets of vertices forming a closed shape - typically triangles or quadrilaterals
*
@ -197,12 +262,15 @@ class CORE_EXPORT QgsMeshDataSourceInterface SIP_ABSTRACT
/**
* \ingroup core
* Interface for mesh datasets
* Interface for mesh datasets and dataset groups
*
* Dataset is a collection of vector or scalar values on vertices or faces of the mesh.
* Based on the underlying data provider/format, whole dataset is either stored in memory
* or read on demand
*
* Datasets are grouped in the dataset groups. A dataset group represents a measured quantity
* (e.g. depth or wind speed), dataset represents values of the quantity in a particular time.
*
* \note The API is considered EXPERIMENTAL and can be changed without a notice
*
* \since QGIS 3.2
@ -221,21 +289,41 @@ class CORE_EXPORT QgsMeshDatasetSourceInterface SIP_ABSTRACT
virtual bool addDataset( const QString &uri ) = 0;
/**
* \brief Returns number of datasets loaded
* \brief Returns number of datasets groups loaded
*/
virtual int datasetCount() const = 0;
virtual int datasetGroupCount( ) const = 0;
/**
* \brief Returns number of datasets loaded in the group
*/
virtual int datasetCount( int groupIndex ) const = 0;
/**
* \brief Returns number of datasets loaded in the group
*/
int datasetCount( QgsMeshDatasetIndex index ) const;
/**
* \brief Returns dataset group metadata
*/
virtual QgsMeshDatasetGroupMetadata datasetGroupMetadata( int groupIndex ) const = 0;
/**
* \brief Returns dataset group metadata
*/
QgsMeshDatasetGroupMetadata datasetGroupMetadata( QgsMeshDatasetIndex index ) const;
/**
* \brief Returns dataset metadata
*/
virtual QgsMeshDatasetMetadata datasetMetadata( int datasetIndex ) const = 0;
virtual QgsMeshDatasetMetadata datasetMetadata( QgsMeshDatasetIndex index ) const = 0;
/**
* \brief Returns vector/scalar value associated with the index from the dataset
*
* See QgsMeshDatasetMetadata::isVector() to check if the returned value is vector or scalar
*/
virtual QgsMeshDatasetValue datasetValue( int datasetIndex, int valueIndex ) const = 0;
virtual QgsMeshDatasetValue datasetValue( QgsMeshDatasetIndex index, int valueIndex ) const = 0;
};

16
src/core/mesh/qgsmeshlayer.cpp
View File

@ -144,35 +144,35 @@ void QgsMeshLayer::setRendererVectorSettings( const QgsMeshRendererVectorSetting
}
void QgsMeshLayer::setActiveScalarDataset( int index )
void QgsMeshLayer::setActiveScalarDataset( QgsMeshDatasetIndex index )
{
if ( index == mActiveScalarDataset )
return;
if ( ( index >= 0 ) && ( index < dataProvider()->datasetCount() ) )
if ( index.isValid() )
mActiveScalarDataset = index;
else
mActiveScalarDataset = NO_ACTIVE_MESH_DATASET;
mActiveScalarDataset = QgsMeshDatasetIndex();
triggerRepaint();
}
void QgsMeshLayer::setActiveVectorDataset( int index )
void QgsMeshLayer::setActiveVectorDataset( QgsMeshDatasetIndex index )
{
if ( index == mActiveVectorDataset )
return;
if ( ( index < 0 ) || ( index >= dataProvider()->datasetCount() ) )
if ( !index.isValid() )
{
mActiveVectorDataset = NO_ACTIVE_MESH_DATASET;
mActiveVectorDataset = QgsMeshDatasetIndex();
}
else
{
const QgsMeshDatasetMetadata metadata = dataProvider()->datasetMetadata( index );
const QgsMeshDatasetGroupMetadata metadata = dataProvider()->datasetGroupMetadata( index );
if ( metadata.isVector() )
mActiveVectorDataset = index;
else
mActiveVectorDataset = NO_ACTIVE_MESH_DATASET;
mActiveVectorDataset = QgsMeshDatasetIndex();
}
triggerRepaint();

14
src/core/mesh/qgsmeshlayer.h
View File

@ -26,8 +26,6 @@
#include "qgsmeshdataprovider.h"
#include "qgsmeshrenderersettings.h"
const int NO_ACTIVE_MESH_DATASET = -1;
class QgsMapLayerRenderer;
class QgsSymbol;
class QgsTriangularMesh;
@ -172,18 +170,18 @@ class CORE_EXPORT QgsMeshLayer : public QgsMapLayer
*
* Triggers repaint
*/
void setActiveScalarDataset( int index = NO_ACTIVE_MESH_DATASET );
void setActiveScalarDataset( QgsMeshDatasetIndex index = QgsMeshDatasetIndex() );
//! Returns active scalar dataset
int activeScalarDataset() const { return mActiveScalarDataset; }
QgsMeshDatasetIndex activeScalarDataset() const { return mActiveScalarDataset; }
/**
* Sets active vector dataset for rendering.
*
* If dataset is not vector based, do nothing. Triggers repaint
*/
void setActiveVectorDataset( int index = NO_ACTIVE_MESH_DATASET );
void setActiveVectorDataset( QgsMeshDatasetIndex index = QgsMeshDatasetIndex() );
//! Returns active vector dataset
int activeVectorDataset() const { return mActiveVectorDataset; }
QgsMeshDatasetIndex activeVectorDataset() const { return mActiveVectorDataset; }
private: // Private methods
@ -225,10 +223,10 @@ class CORE_EXPORT QgsMeshLayer : public QgsMapLayer
QgsMeshRendererVectorSettings mRendererVectorSettings;
//! index of active scalar dataset; -1 if none
int mActiveScalarDataset = NO_ACTIVE_MESH_DATASET;
QgsMeshDatasetIndex mActiveScalarDataset;
//! index of active vector dataset; -1 if none
int mActiveVectorDataset = NO_ACTIVE_MESH_DATASET;
QgsMeshDatasetIndex mActiveVectorDataset;
};
#endif //QGSMESHLAYER_H

12
src/core/mesh/qgsmeshlayerrenderer.cpp
View File

@ -136,10 +136,10 @@ void QgsMeshLayerRenderer::createMeshSymbol( std::unique_ptr<QgsSymbol> &symbol,
void QgsMeshLayerRenderer::copyScalarDatasetValues( QgsMeshLayer *layer )
{
int datasetIndex = layer->activeScalarDataset();
if ( datasetIndex != NO_ACTIVE_MESH_DATASET )
const QgsMeshDatasetIndex datasetIndex = layer->activeScalarDataset();
if ( datasetIndex.isValid() )
{
const QgsMeshDatasetMetadata metadata = layer->dataProvider()->datasetMetadata( datasetIndex );
const QgsMeshDatasetGroupMetadata metadata = layer->dataProvider()->datasetGroupMetadata( datasetIndex );
mScalarDataOnVertices = metadata.isOnVertices();
int count;
if ( mScalarDataOnVertices )
@ -160,10 +160,10 @@ void QgsMeshLayerRenderer::copyScalarDatasetValues( QgsMeshLayer *layer )
void QgsMeshLayerRenderer::copyVectorDatasetValues( QgsMeshLayer *layer )
{
int datasetIndex = layer->activeVectorDataset();
if ( datasetIndex != NO_ACTIVE_MESH_DATASET )
const QgsMeshDatasetIndex datasetIndex = layer->activeVectorDataset();
if ( datasetIndex.isValid() )
{
const QgsMeshDatasetMetadata metadata = layer->dataProvider()->datasetMetadata( datasetIndex );
const QgsMeshDatasetGroupMetadata metadata = layer->dataProvider()->datasetGroupMetadata( datasetIndex );
bool isScalar = metadata.isScalar();
if ( isScalar )

129
src/core/mesh/qgsmeshmemorydataprovider.cpp
View File

@ -143,47 +143,56 @@ bool QgsMeshMemoryDataProvider::addMeshFaces( const QString &def )
}
bool QgsMeshMemoryDataProvider::splitDatasetSections( const QString &uri, QgsMeshMemoryDataset &dataset )
bool QgsMeshMemoryDataProvider::splitDatasetSections( const QString &uri, QgsMeshMemoryDatasetGroup &datasetGroup )
{
const QStringList sections = uri.split( QStringLiteral( "---" ), QString::SkipEmptyParts );
bool success = sections.size() == 3;
bool success = sections.size() > 2;
if ( !success )
{
setError( QgsError( tr( "Invalid dataset definition, does not contain 3 sections" ),
setError( QgsError( tr( "Invalid dataset definition, does not contain 3+ sections" ),
QStringLiteral( "Mesh Memory Provider" ) ) );
}
if ( success )
success = setDatasetType( sections[0], dataset );
success = setDatasetGroupType( sections[0], datasetGroup );
if ( success )
success = addDatasetMetadata( sections[1], dataset );
if ( success )
success = addDatasetValues( sections[2], dataset );
if ( success )
success = checkDatasetValidity( dataset );
success = addDatasetGroupMetadata( sections[1], datasetGroup );
for ( int i = 2; i < sections.size(); ++i )
{
if ( !success )
break;
QgsMeshMemoryDataset dataset;
success = addDatasetValues( sections[i], dataset, datasetGroup.isScalar );
if ( success )
success = checkDatasetValidity( dataset, datasetGroup.isOnVertices );
if ( success )
datasetGroup.datasets.push_back( dataset );
}
return success;
}
bool QgsMeshMemoryDataProvider::setDatasetType( const QString &def, QgsMeshMemoryDataset &dataset )
bool QgsMeshMemoryDataProvider::setDatasetGroupType( const QString &def, QgsMeshMemoryDatasetGroup &datasetGroup )
{
const QStringList types = def.split( ' ', QString::SkipEmptyParts );
if ( types.size() != 2 )
if ( types.size() != 3 )
{
setError( QgsError( tr( "Invalid type definition, must be Vertex/Face Vector/Scalar" ),
setError( QgsError( tr( "Invalid type definition, must be Vertex/Face Vector/Scalar Name" ),
QStringLiteral( "Mesh Memory Provider" ) ) );
return false;
}
dataset.isOnVertices = 0 == QString::compare( types[0].trimmed(), QStringLiteral( "vertex" ), Qt::CaseInsensitive );
dataset.isScalar = 0 == QString::compare( types[1].trimmed(), QStringLiteral( "scalar" ), Qt::CaseInsensitive );
datasetGroup.isOnVertices = 0 == QString::compare( types[0].trimmed(), QStringLiteral( "vertex" ), Qt::CaseInsensitive );
datasetGroup.isScalar = 0 == QString::compare( types[1].trimmed(), QStringLiteral( "scalar" ), Qt::CaseInsensitive );
datasetGroup.name = types[2].trimmed();
return true;
}
bool QgsMeshMemoryDataProvider::addDatasetMetadata( const QString &def, QgsMeshMemoryDataset &dataset )
bool QgsMeshMemoryDataProvider::addDatasetGroupMetadata( const QString &def, QgsMeshMemoryDatasetGroup &datasetGroup )
{
const QStringList metadataLines = def.split( '\n', QString::SkipEmptyParts );
for ( int i = 0; i < metadataLines.size(); ++i )
@ -196,20 +205,30 @@ bool QgsMeshMemoryDataProvider::addDatasetMetadata( const QString &def, QgsMeshM
return false;
}
dataset.metadata.insert( keyVal.at( 0 ).trimmed(), keyVal.at( 1 ).trimmed() );
datasetGroup.metadata.insert( keyVal.at( 0 ).trimmed(), keyVal.at( 1 ).trimmed() );
}
return true;
}
bool QgsMeshMemoryDataProvider::addDatasetValues( const QString &def, QgsMeshMemoryDataset &dataset )
bool QgsMeshMemoryDataProvider::addDatasetValues( const QString &def, QgsMeshMemoryDataset &dataset, bool isScalar )
{
const QStringList valuesLines = def.split( '\n', QString::SkipEmptyParts );
for ( int i = 0; i < valuesLines.size(); ++i )
// first line is time
if ( valuesLines.size() < 2 )
{
setError( QgsError( tr( "Invalid dataset definition, must contain at least 1 line (time)" ),
QStringLiteral( "Mesh Memory Provider" ) ) );
return false;
}
dataset.time = valuesLines[0].toDouble();
for ( int i = 1; i < valuesLines.size(); ++i )
{
const QStringList values = valuesLines[i].split( ',', QString::SkipEmptyParts );
QgsMeshDatasetValue point;
if ( dataset.isScalar )
if ( isScalar )
{
if ( values.size() != 1 )
{
@ -242,11 +261,11 @@ bool QgsMeshMemoryDataProvider::addDatasetValues( const QString &def, QgsMeshMem
return true;
}
bool QgsMeshMemoryDataProvider::checkDatasetValidity( QgsMeshMemoryDataset &dataset )
bool QgsMeshMemoryDataProvider::checkDatasetValidity( QgsMeshMemoryDataset &dataset, bool isOnVertices )
{
bool valid = true;
if ( dataset.isOnVertices )
if ( isOnVertices )
{
if ( dataset.values.count() != vertexCount() )
{
@ -266,6 +285,7 @@ bool QgsMeshMemoryDataProvider::checkDatasetValidity( QgsMeshMemoryDataset &data
}
}
dataset.valid = valid;
return valid;
}
@ -293,40 +313,68 @@ QgsMeshFace QgsMeshMemoryDataProvider::face( int index ) const
bool QgsMeshMemoryDataProvider::addDataset( const QString &uri )
{
QgsMeshMemoryDataset ds;
QgsMeshMemoryDatasetGroup group;
bool valid = false;
if ( mIsValid )
{
ds.valid = splitDatasetSections( uri, ds );
valid = splitDatasetSections( uri, group );
}
else
{
setError( QgsError( tr( "Unable to add dataset to invalid mesh" ),
setError( QgsError( tr( "Unable to add dataset group to invalid mesh" ),
QStringLiteral( "Mesh Memory Provider" ) ) );
}
mDatasets.push_back( ds );
mDatasetGroups.push_back( group );
if ( ds.valid )
if ( valid )
emit dataChanged();
return ds.valid;
return valid;
}
int QgsMeshMemoryDataProvider::datasetCount() const
int QgsMeshMemoryDataProvider::datasetGroupCount() const
{
return mDatasets.count();
return mDatasetGroups.count();
}
QgsMeshDatasetMetadata QgsMeshMemoryDataProvider::datasetMetadata( int index ) const
int QgsMeshMemoryDataProvider::datasetCount( int groupIndex ) const
{
if ( ( index >= 0 ) && ( index < datasetCount() ) )
if ( ( groupIndex >= 0 ) && ( groupIndex < datasetGroupCount() ) )
return mDatasetGroups[groupIndex].datasets.count();
else
return 0;
}
QgsMeshDatasetGroupMetadata QgsMeshMemoryDataProvider::datasetGroupMetadata( int groupIndex ) const
{
if ( ( groupIndex >= 0 ) && ( groupIndex < datasetGroupCount() ) )
{
QgsMeshDatasetGroupMetadata metadata(
mDatasetGroups[groupIndex].name,
mDatasetGroups[groupIndex].isScalar,
mDatasetGroups[groupIndex].isOnVertices,
mDatasetGroups[groupIndex].metadata
);
return metadata;
}
else
{
return QgsMeshDatasetGroupMetadata();
}
}
QgsMeshDatasetMetadata QgsMeshMemoryDataProvider::datasetMetadata( QgsMeshDatasetIndex index ) const
{
if ( ( index.group() >= 0 ) && ( index.group() < datasetGroupCount() ) &&
( index.dataset() >= 0 ) && ( index.dataset() < datasetCount( index.group() ) )
)
{
const QgsMeshMemoryDatasetGroup &grp = mDatasetGroups.at( index.group() );
QgsMeshDatasetMetadata metadata(
mDatasets[index].isScalar,
mDatasets[index].valid,
mDatasets[index].isOnVertices,
mDatasets[index].metadata
grp.datasets[index.dataset()].time,
grp.datasets[index.dataset()].valid
);
return metadata;
}
@ -336,14 +384,13 @@ QgsMeshDatasetMetadata QgsMeshMemoryDataProvider::datasetMetadata( int index ) c
}
}
QgsMeshDatasetValue QgsMeshMemoryDataProvider::datasetValue( int datasetIndex, int valueIndex ) const
QgsMeshDatasetValue QgsMeshMemoryDataProvider::datasetValue( QgsMeshDatasetIndex index, int valueIndex ) const
{
if ( ( datasetIndex >= 0 ) &&
( datasetIndex < datasetCount() ) &&
( valueIndex >= 0 ) &&
( valueIndex < mDatasets[datasetIndex].values.count() ) )
if ( ( index.group() >= 0 ) && ( index.group() < datasetGroupCount() ) &&
( index.dataset() >= 0 ) && ( index.dataset() < datasetCount( index.group() ) ) &&
( valueIndex >= 0 ) && ( valueIndex < mDatasetGroups[index.group()].datasets[index.dataset()].values.count() ) )
{
return mDatasets[datasetIndex].values[valueIndex];
return mDatasetGroups[index.group()].datasets[index.dataset()].values[valueIndex];
}
else
{

49
src/core/mesh/qgsmeshmemorydataprovider.h
View File

@ -31,11 +31,18 @@
struct QgsMeshMemoryDataset
{
QMap<QString, QString> metadata;
QVector<QgsMeshDatasetValue> values;
double time = -1;
bool valid = false;
};
struct QgsMeshMemoryDatasetGroup
{
QMap<QString, QString> metadata;
QVector<QgsMeshMemoryDataset> datasets;
QString name;
bool isScalar = true;
bool isOnVertices = true;
bool valid = false;
};
/**
@ -89,29 +96,37 @@ class QgsMeshMemoryDataProvider: public QgsMeshDataProvider
*
* Data string constains simple definition of datasets
* Each entry is separated by "\n" sign and section deliminer "---"
* First section defines the type of dataset: Vertex/Face Vector/Scalar
* Second section defines the metadata: key: value pairs
* Third section defines the values. One value on line. For vectors separated by comma
* First section defines the dataset group: Vertex/Face Vector/Scalar Name
* Second section defines the group metadata: key: value pairs
* Third section defines the datasets (timesteps). First line is time,
* other lines are values (one value on line). For vectors separated by comma
*
* For example:
*
* \code
* QString uri(
* "Vertex Vector \n" \
* "Vertex Vector MyVertexVectorDataset\n" \
* "---"
* "name: MyVertexVectorDataset \n" \
* "time: 0 \n" \
* "description: My great dataset \n" \
* "reference_time: Midnight \n" \
* "---"
* "0 \n"
* "3, 2 \n" \
* "1, -2 \n"
* "---"
* "1 \n"
* "2, 2 \n" \
* "2, -2 \n"
* );
* \endcode
*/
bool addDataset( const QString &uri ) override;
int datasetCount() const override;
int datasetGroupCount() const override;
int datasetCount( int groupIndex ) const override;
QgsMeshDatasetMetadata datasetMetadata( int datasetIndex ) const override;
QgsMeshDatasetValue datasetValue( int datasetIndex, int valueIndex ) const override;
QgsMeshDatasetGroupMetadata datasetGroupMetadata( int groupIndex ) const override;
QgsMeshDatasetMetadata datasetMetadata( QgsMeshDatasetIndex index ) const override;
QgsMeshDatasetValue datasetValue( QgsMeshDatasetIndex index, int valueIndex ) const override;
//! Returns the memory provider key
static QString providerKey();
@ -124,15 +139,15 @@ class QgsMeshMemoryDataProvider: public QgsMeshDataProvider
bool addMeshVertices( const QString &def );
bool addMeshFaces( const QString &def );
bool splitDatasetSections( const QString &uri, QgsMeshMemoryDataset &dataset );
bool setDatasetType( const QString &uri, QgsMeshMemoryDataset &dataset );
bool addDatasetMetadata( const QString &def, QgsMeshMemoryDataset &dataset );
bool addDatasetValues( const QString &def, QgsMeshMemoryDataset &dataset );
bool checkDatasetValidity( QgsMeshMemoryDataset &dataset );
bool splitDatasetSections( const QString &uri, QgsMeshMemoryDatasetGroup &datasetGroup );
bool setDatasetGroupType( const QString &uri, QgsMeshMemoryDatasetGroup &datasetGroup );
bool addDatasetGroupMetadata( const QString &def, QgsMeshMemoryDatasetGroup &datasetGroup );
bool addDatasetValues( const QString &def, QgsMeshMemoryDataset &dataset, bool isScalar );
bool checkDatasetValidity( QgsMeshMemoryDataset &dataset, bool isOnVertices );
QVector<QgsMeshVertex> mVertices;
QVector<QgsMeshFace> mFaces;
QVector<QgsMeshMemoryDataset> mDatasets;
QVector<QgsMeshMemoryDatasetGroup> mDatasetGroups;
bool mIsValid = false;
};

87
src/providers/mdal/qgsmdalprovider.cpp
View File

@ -52,7 +52,6 @@ QgsMdalProvider::QgsMdalProvider( const QString &uri, const ProviderOptions &opt
{
QByteArray curi = uri.toAscii();
mMeshH = MDAL_LoadMesh( curi.constData() );
refreshDatasets();
}
QgsMdalProvider::~QgsMdalProvider()
@ -103,13 +102,12 @@ QgsMeshFace QgsMdalProvider::face( int index ) const
bool QgsMdalProvider::addDataset( const QString &uri )
{
int datasetCount = mDatasets.count();
int datasetCount = datasetGroupCount();
std::string str = uri.toStdString();
MDAL_M_LoadDatasets( mMeshH, str.c_str() );
refreshDatasets();
if ( datasetCount == mDatasets.count() )
if ( datasetCount == datasetGroupCount() )
{
return false;
}
@ -120,37 +118,43 @@ bool QgsMdalProvider::addDataset( const QString &uri )
}
}
int QgsMdalProvider::datasetCount() const
int QgsMdalProvider::datasetGroupCount() const
{
return MDAL_M_datasetCount( mMeshH );
return MDAL_M_datasetGroupCount( mMeshH );
}
QgsMeshDatasetMetadata QgsMdalProvider::datasetMetadata( int datasetIndex ) const
int QgsMdalProvider::datasetCount( int groupIndex ) const
{
if ( datasetIndex >= mDatasets.length() )
return QgsMeshDatasetMetadata();
DatasetGroupH group = MDAL_M_datasetGroup( mMeshH, groupIndex );
if ( !group )
return 0;
return MDAL_G_datasetCount( group );
}
if ( datasetIndex < 0 )
return QgsMeshDatasetMetadata();
QgsMeshDatasetGroupMetadata QgsMdalProvider::datasetGroupMetadata( int groupIndex ) const
{
DatasetGroupH group = MDAL_M_datasetGroup( mMeshH, groupIndex );
if ( !group )
return QgsMeshDatasetGroupMetadata();
DatasetH dataset = mDatasets[datasetIndex];
bool isScalar = MDAL_D_hasScalarData( dataset );
bool isValid = MDAL_D_isValid( dataset );
bool isOnVertices = MDAL_D_isOnVertices( dataset );
bool isScalar = MDAL_G_hasScalarData( group );
bool isOnVertices = MDAL_G_isOnVertices( group );
QString name = MDAL_G_name( group );
QMap<QString, QString> metadata;
int n = MDAL_D_metadataCount( dataset );
int n = MDAL_G_metadataCount( group );
for ( int i = 0; i < n; ++i )
{
QString key = MDAL_D_metadataKey( dataset, i );
QString value = MDAL_D_metadataValue( dataset, i );
QString key = MDAL_G_metadataKey( group, i );
QString value = MDAL_G_metadataValue( group, i );
metadata[key] = value;
}
QgsMeshDatasetMetadata meta(
QgsMeshDatasetGroupMetadata meta(
name,
isScalar,
isValid,
isOnVertices,
metadata
);
@ -158,18 +162,39 @@ QgsMeshDatasetMetadata QgsMdalProvider::datasetMetadata( int datasetIndex ) cons
return meta;
}
QgsMeshDatasetValue QgsMdalProvider::datasetValue( int datasetIndex, int valueIndex ) const
QgsMeshDatasetMetadata QgsMdalProvider::datasetMetadata( QgsMeshDatasetIndex index ) const
{
if ( datasetIndex >= mDatasets.length() )
DatasetGroupH group = MDAL_M_datasetGroup( mMeshH, index.group() );
if ( !group )
return QgsMeshDatasetMetadata();
DatasetH dataset = MDAL_G_dataset( group, index.dataset() );
bool isValid = MDAL_D_isValid( dataset );
double time = MDAL_D_time( dataset );
QgsMeshDatasetMetadata meta(
time,
isValid
);
return meta;
}
QgsMeshDatasetValue QgsMdalProvider::datasetValue( QgsMeshDatasetIndex index, int valueIndex ) const
{
DatasetGroupH group = MDAL_M_datasetGroup( mMeshH, index.group() );
if ( !group )
return QgsMeshDatasetValue();
if ( datasetIndex < 0 )
DatasetH dataset = MDAL_G_dataset( group, index.dataset() );
if ( !dataset )
return QgsMeshDatasetValue();
DatasetH dataset = mDatasets[datasetIndex];
QgsMeshDatasetValue val;
if ( MDAL_D_hasScalarData( dataset ) )
if ( MDAL_G_hasScalarData( group ) )
{
val.setX( MDAL_D_value( dataset, valueIndex ) );
}
@ -182,18 +207,6 @@ QgsMeshDatasetValue QgsMdalProvider::datasetValue( int datasetIndex, int valueIn
return val;
}
void QgsMdalProvider::refreshDatasets()
{
int n = MDAL_M_datasetCount( mMeshH );
mDatasets.resize( 0 ); // keeps allocated space - potentially avoids reallocation
mDatasets.reserve( n );
for ( int i = 0; i < n; ++i )
{
DatasetH dataset = MDAL_M_dataset( mMeshH, i );
mDatasets.push_back( dataset );
}
}
/*----------------------------------------------------------------------------------------------*/
/**

15
src/providers/mdal/qgsmdalprovider.h
View File

@ -55,16 +55,17 @@ class QgsMdalProvider : public QgsMeshDataProvider
QgsMeshVertex vertex( int index ) const override;
QgsMeshFace face( int index ) const override;
bool addDataset( const QString &uri ) override;
int datasetCount() const override;
QgsMeshDatasetMetadata datasetMetadata( int datasetIndex ) const override;
QgsMeshDatasetValue datasetValue( int datasetIndex, int valueIndex ) const override;
private:
void refreshDatasets();
int datasetGroupCount() const override;
int datasetCount( int groupIndex ) const override;
QgsMeshDatasetGroupMetadata datasetGroupMetadata( int groupIndex ) const override;
QgsMeshDatasetMetadata datasetMetadata( QgsMeshDatasetIndex index ) const override;
QgsMeshDatasetValue datasetValue( QgsMeshDatasetIndex index, int valueIndex ) const override;
private:
MeshH mMeshH;
QVector<DatasetH> mDatasets;
};
#endif //QGSMDALPROVIDER_H

135
tests/src/core/testqgsmeshlayer.cpp
View File

@ -139,7 +139,6 @@ void TestQgsMeshLayer::test_read_mesh()
void TestQgsMeshLayer::test_read_vertex_scalar_dataset()
{
int ds = 0;
QList<const QgsMeshDataProvider *> dataProviders;
dataProviders.append( mMemoryLayer->dataProvider() );
dataProviders.append( mMdalLayer->dataProvider() );
@ -149,29 +148,38 @@ void TestQgsMeshLayer::test_read_vertex_scalar_dataset()
QVERIFY( dp != nullptr );
QVERIFY( dp->isValid() );
QCOMPARE( 4, dp->datasetCount() );
QCOMPARE( 4, dp->datasetGroupCount() );
const QgsMeshDatasetMetadata meta = dp->datasetMetadata( ds );
QCOMPARE( meta.extraOptions().count(), 2 );
QCOMPARE( meta.extraOptions()["name"], QString( "VertexScalarDataset" ) );
QVERIFY( qgsDoubleNear( meta.extraOptions()["time"].toDouble(), 0.0 ) );
for ( int i = 0; i < 2 ; ++i )
{
QgsMeshDatasetIndex ds( 0, i );
QVERIFY( meta.isValid() );
QVERIFY( meta.isScalar() );
QVERIFY( meta.isOnVertices() );
const QgsMeshDatasetGroupMetadata meta = dp->datasetGroupMetadata( ds );
if ( meta.extraOptions().count() == 2 )
{
QCOMPARE( meta.extraOptions()["description"], QString( "Vertex Scalar Dataset" ) );
QCOMPARE( meta.extraOptions()["meta2"], QString( "best dataset" ) );
}
QCOMPARE( meta.name(), QString( "VertexScalarDataset" ) );
QVERIFY( meta.isScalar() );
QVERIFY( meta.isOnVertices() );
// We have 5 values, since dp->vertexCount() = 5
QCOMPARE( QgsMeshDatasetValue( 1.0 ), dp->datasetValue( ds, 0 ) );
QCOMPARE( QgsMeshDatasetValue( 2.0 ), dp->datasetValue( ds, 1 ) );
QCOMPARE( QgsMeshDatasetValue( 3.0 ), dp->datasetValue( ds, 2 ) );
QCOMPARE( QgsMeshDatasetValue( 2.0 ), dp->datasetValue( ds, 3 ) );
QCOMPARE( QgsMeshDatasetValue( 1.0 ), dp->datasetValue( ds, 4 ) );
const QgsMeshDatasetMetadata dmeta = dp->datasetMetadata( ds );
QVERIFY( qgsDoubleNear( dmeta.time(), i ) );
QVERIFY( dmeta.isValid() );
// We have 5 values, since dp->vertexCount() = 5
QCOMPARE( QgsMeshDatasetValue( 1.0 + i ), dp->datasetValue( ds, 0 ) );
QCOMPARE( QgsMeshDatasetValue( 2.0 + i ), dp->datasetValue( ds, 1 ) );
QCOMPARE( QgsMeshDatasetValue( 3.0 + i ), dp->datasetValue( ds, 2 ) );
QCOMPARE( QgsMeshDatasetValue( 2.0 + i ), dp->datasetValue( ds, 3 ) );
QCOMPARE( QgsMeshDatasetValue( 1.0 + i ), dp->datasetValue( ds, 4 ) );
}
}
}
void TestQgsMeshLayer::test_read_vertex_vector_dataset()
{
int ds = 1;
QList<const QgsMeshDataProvider *> dataProviders;
dataProviders.append( mMemoryLayer->dataProvider() );
dataProviders.append( mMdalLayer->dataProvider() );
@ -181,29 +189,35 @@ void TestQgsMeshLayer::test_read_vertex_vector_dataset()
QVERIFY( dp != nullptr );
QVERIFY( dp->isValid() );
QCOMPARE( 4, dp->datasetCount() );
QCOMPARE( 4, dp->datasetGroupCount() );
const QgsMeshDatasetMetadata meta = dp->datasetMetadata( ds );
QCOMPARE( meta.extraOptions().count(), 2 );
QCOMPARE( meta.extraOptions()["name"], QString( "VertexVectorDataset" ) );
QVERIFY( qgsDoubleNear( meta.extraOptions()["time"].toDouble(), 0.0 ) );
for ( int i = 0; i < 2 ; ++i )
{
QgsMeshDatasetIndex ds( 1, i );
QVERIFY( meta.isValid() );
QVERIFY( !meta.isScalar() );
QVERIFY( meta.isOnVertices() );
const QgsMeshDatasetGroupMetadata meta = dp->datasetGroupMetadata( ds );
if ( meta.extraOptions().count() == 2 )
QCOMPARE( meta.extraOptions()["description"], QString( "Vertex Vector Dataset" ) );
QCOMPARE( meta.name(), QString( "VertexVectorDataset" ) );
QVERIFY( !meta.isScalar() );
QVERIFY( meta.isOnVertices() );
// We have 5 values, since dp->vertexCount() = 5
QCOMPARE( QgsMeshDatasetValue( 1, 1 ), dp->datasetValue( ds, 0 ) );
QCOMPARE( QgsMeshDatasetValue( 2, 1 ), dp->datasetValue( ds, 1 ) );
QCOMPARE( QgsMeshDatasetValue( 3, 2 ), dp->datasetValue( ds, 2 ) );
QCOMPARE( QgsMeshDatasetValue( 2, 2 ), dp->datasetValue( ds, 3 ) );
QCOMPARE( QgsMeshDatasetValue( 1, -2 ), dp->datasetValue( ds, 4 ) );
const QgsMeshDatasetMetadata dmeta = dp->datasetMetadata( ds );
QVERIFY( qgsDoubleNear( dmeta.time(), i ) );
QVERIFY( dmeta.isValid() );
// We have 5 values, since dp->vertexCount() = 5
QCOMPARE( QgsMeshDatasetValue( 1 + i, 1 + i ), dp->datasetValue( ds, 0 ) );
QCOMPARE( QgsMeshDatasetValue( 2 + i, 1 + i ), dp->datasetValue( ds, 1 ) );
QCOMPARE( QgsMeshDatasetValue( 3 + i, 2 + i ), dp->datasetValue( ds, 2 ) );
QCOMPARE( QgsMeshDatasetValue( 2 + i, 2 + i ), dp->datasetValue( ds, 3 ) );
QCOMPARE( QgsMeshDatasetValue( 1 + i, -2 + i ), dp->datasetValue( ds, 4 ) );
}
}
}
void TestQgsMeshLayer::test_read_face_scalar_dataset()
{
int ds = 2;
QList<const QgsMeshDataProvider *> dataProviders;
dataProviders.append( mMemoryLayer->dataProvider() );
dataProviders.append( mMdalLayer->dataProvider() );
@ -213,27 +227,33 @@ void TestQgsMeshLayer::test_read_face_scalar_dataset()
QVERIFY( dp != nullptr );
QVERIFY( dp->isValid() );
QCOMPARE( 4, dp->datasetCount() );
QCOMPARE( 4, dp->datasetGroupCount() );
const QgsMeshDatasetMetadata meta = dp->datasetMetadata( ds );
QCOMPARE( meta.extraOptions().count(), 2 );
QCOMPARE( meta.extraOptions()["name"], QString( "FaceScalarDataset" ) );
QVERIFY( qgsDoubleNear( meta.extraOptions()["time"].toDouble(), 0.0 ) );
for ( int i = 0; i < 2 ; ++i )
{
QgsMeshDatasetIndex ds( 2, i );
QVERIFY( meta.isValid() );
QVERIFY( meta.isScalar() );
QVERIFY( !meta.isOnVertices() );
const QgsMeshDatasetGroupMetadata meta = dp->datasetGroupMetadata( ds );
if ( meta.extraOptions().count() == 2 )
QCOMPARE( meta.extraOptions()["description"], QString( "Face Scalar Dataset" ) );
QCOMPARE( meta.name(), QString( "FaceScalarDataset" ) );
QVERIFY( meta.isScalar() );
QVERIFY( !meta.isOnVertices() );
// We have 2 values, since dp->faceCount() = 2
QCOMPARE( QgsMeshDatasetValue( 1 ), dp->datasetValue( ds, 0 ) );
QCOMPARE( QgsMeshDatasetValue( 2 ), dp->datasetValue( ds, 1 ) );
const QgsMeshDatasetMetadata dmeta = dp->datasetMetadata( ds );
QVERIFY( qgsDoubleNear( dmeta.time(), i ) );
QVERIFY( dmeta.isValid() );
// We have 2 values, since dp->faceCount() = 2
QCOMPARE( QgsMeshDatasetValue( 1 + i ), dp->datasetValue( ds, 0 ) );
QCOMPARE( QgsMeshDatasetValue( 2 + i ), dp->datasetValue( ds, 1 ) );
}
}
}
void TestQgsMeshLayer::test_read_face_vector_dataset()
{
int ds = 3;
QList<const QgsMeshDataProvider *> dataProviders;
dataProviders.append( mMemoryLayer->dataProvider() );
dataProviders.append( mMdalLayer->dataProvider() );
@ -243,20 +263,27 @@ void TestQgsMeshLayer::test_read_face_vector_dataset()
QVERIFY( dp != nullptr );
QVERIFY( dp->isValid() );
QCOMPARE( 4, dp->datasetCount() );
QCOMPARE( 4, dp->datasetGroupCount() );
const QgsMeshDatasetMetadata meta = dp->datasetMetadata( ds );
QCOMPARE( meta.extraOptions().count(), 2 );
QCOMPARE( meta.extraOptions()["name"], QString( "FaceVectorDataset" ) );
QVERIFY( qgsDoubleNear( meta.extraOptions()["time"].toDouble(), 0.0 ) );
for ( int i = 0; i < 2 ; ++i )
{
QgsMeshDatasetIndex ds( 3, i );
QVERIFY( meta.isValid() );
QVERIFY( !meta.isScalar() );
QVERIFY( !meta.isOnVertices() );
const QgsMeshDatasetGroupMetadata meta = dp->datasetGroupMetadata( ds );
if ( meta.extraOptions().count() == 2 )
QCOMPARE( meta.extraOptions()["description"], QString( "Face Vector Dataset" ) );
QCOMPARE( meta.name(), QString( "FaceVectorDataset" ) );
QVERIFY( !meta.isScalar() );
QVERIFY( !meta.isOnVertices() );
// We have 2 values, since dp->faceCount() = 2
QCOMPARE( QgsMeshDatasetValue( 1, 1 ), dp->datasetValue( ds, 0 ) );
QCOMPARE( QgsMeshDatasetValue( 2, 2 ), dp->datasetValue( ds, 1 ) );
const QgsMeshDatasetMetadata dmeta = dp->datasetMetadata( ds );
QVERIFY( qgsDoubleNear( dmeta.time(), i ) );
QVERIFY( dmeta.isValid() );
// We have 2 values, since dp->faceCount() = 2
QCOMPARE( QgsMeshDatasetValue( 1 + i, 1 + i ), dp->datasetValue( ds, 0 ) );
QCOMPARE( QgsMeshDatasetValue( 2 + i, 2 + i ), dp->datasetValue( ds, 1 ) );
}
}
}

24
tests/src/core/testqgsmeshlayerrenderer.cpp
View File

@ -155,19 +155,19 @@ void TestQgsMeshRenderer::test_triangular_mesh_rendering()
void TestQgsMeshRenderer::test_vertex_scalar_dataset_rendering()
{
int ds = 0;
QgsMeshDatasetIndex ds( 0, 0 );
mMemoryLayer->setActiveScalarDataset( ds );
const QgsMeshDatasetMetadata metadata = mMemoryLayer->dataProvider()->datasetMetadata( ds );
QVERIFY( metadata.extraOptions()["name"] == "VertexScalarDataset" );
const QgsMeshDatasetGroupMetadata metadata = mMemoryLayer->dataProvider()->datasetGroupMetadata( ds );
QVERIFY( metadata.name() == "VertexScalarDataset" );
QVERIFY( imageCheck( "quad_and_triangle_vertex_scalar_dataset" ) );
}
void TestQgsMeshRenderer::test_vertex_vector_dataset_rendering()
{
int ds = 1;
QgsMeshDatasetIndex ds( 1, 0 );
mMemoryLayer->setActiveVectorDataset( ds );
const QgsMeshDatasetMetadata metadata = mMemoryLayer->dataProvider()->datasetMetadata( ds );
QVERIFY( metadata.extraOptions()["name"] == "VertexVectorDataset" );
const QgsMeshDatasetGroupMetadata metadata = mMemoryLayer->dataProvider()->datasetGroupMetadata( ds );
QVERIFY( metadata.name() == "VertexVectorDataset" );
QgsMeshRendererVectorSettings settings = mMemoryLayer->rendererVectorSettings();
settings.setMinShaftLength( 15 );
@ -178,19 +178,19 @@ void TestQgsMeshRenderer::test_vertex_vector_dataset_rendering()
void TestQgsMeshRenderer::test_face_scalar_dataset_rendering()
{
int ds = 2;
QgsMeshDatasetIndex ds( 2, 0 );
mMemoryLayer->setActiveScalarDataset( ds );
const QgsMeshDatasetMetadata metadata = mMemoryLayer->dataProvider()->datasetMetadata( ds );
QVERIFY( metadata.extraOptions()["name"] == "FaceScalarDataset" );
const QgsMeshDatasetGroupMetadata metadata = mMemoryLayer->dataProvider()->datasetGroupMetadata( ds );
QVERIFY( metadata.name() == "FaceScalarDataset" );
QVERIFY( imageCheck( "quad_and_triangle_face_scalar_dataset" ) );
}
void TestQgsMeshRenderer::test_face_vector_dataset_rendering()
{
int ds = 3;
QgsMeshDatasetIndex ds( 3, 0 );
mMemoryLayer->setActiveVectorDataset( ds );
const QgsMeshDatasetMetadata metadata = mMemoryLayer->dataProvider()->datasetMetadata( ds );
QVERIFY( metadata.extraOptions()["name"] == "FaceVectorDataset" );
const QgsMeshDatasetGroupMetadata metadata = mMemoryLayer->dataProvider()->datasetGroupMetadata( ds );
QVERIFY( metadata.name() == "FaceVectorDataset" );
QVERIFY( imageCheck( "quad_and_triangle_face_vector_dataset" ) );
}

3
tests/testdata/mesh/quad_and_triangle_els_face_scalar.dat vendored
View File

@ -9,4 +9,7 @@ TIMEUNITS se
TS 0 0.000000
1
2
TS 1 3600.000000
2
3
ENDDS

3
tests/testdata/mesh/quad_and_triangle_els_face_vector.dat vendored
View File

@ -9,4 +9,7 @@ TIMEUNITS se
TS 0 0.000000
1 1
2 2
TS 0 3600.000000
2 2
3 3
ENDDS

10
tests/testdata/mesh/quad_and_triangle_face_scalar.txt vendored
View File

@ -1,7 +1,11 @@
Face Scalar
Face Scalar FaceScalarDataset
---
name: FaceScalarDataset
time: 0
description: Face Scalar Dataset
---
0
1
2
---
1
2
3

10
tests/testdata/mesh/quad_and_triangle_face_vector.txt vendored
View File

@ -1,7 +1,11 @@
Face Vector
Face Vector FaceVectorDataset
---
name: FaceVectorDataset
time: 0
description: Face Vector Dataset
---
0
1, 1
2, 2
---
1
2, 2
3, 3

6
tests/testdata/mesh/quad_and_triangle_vertex_scalar.dat vendored
View File

@ -12,4 +12,10 @@ TS 0 0.000000
3
2
1
TS 0 3600.000000
2
3
4
3
2
ENDDS

14
tests/testdata/mesh/quad_and_triangle_vertex_scalar.txt vendored
View File

@ -1,10 +1,18 @@
Vertex Scalar
Vertex Scalar VertexScalarDataset
---
name: VertexScalarDataset
time: 0
description: Vertex Scalar Dataset
meta2: best dataset
---
0
1
2
3
2
1
---
1
2
3
4
3
2

6
tests/testdata/mesh/quad_and_triangle_vertex_vector.dat vendored
View File

@ -12,4 +12,10 @@ TS 0 0.000000
3 2
2 2
1 -2
TS 0 3600.000000
2 2
3 2
4 3
3 3
2 -1
ENDDS

13
tests/testdata/mesh/quad_and_triangle_vertex_vector.txt vendored
View File

@ -1,10 +1,17 @@
Vertex Vector
Vertex Vector VertexVectorDataset
---
name: VertexVectorDataset
time: 0
description: Vertex Vector Dataset
---
0
1, 1
2, 1
3, 2
2, 2
1, -2
---
1
2, 2
3, 2
4, 3
3, 3
2, -1