qgsmeshdataset.h

Go to the documentation of this file.

/***************************************************************************
                         qgsmeshdataset.h
                         ---------------------
    begin                : April 2018
    copyright            : (C) 2018 by Peter Petrik
    email                : zilolv at gmail dot com
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSMESHDATASET_H
#define QGSMESHDATASET_H
 
#include <QVector>
#include <QString>
#include <QMap>
#include <QPair>
 
#include <limits>
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgspoint.h"
#include "qgsdataprovider.h"
 
class QgsMeshLayer;
class QgsMeshDatasetGroup;
class QgsRectangle;
 
class CORE_EXPORT QgsMeshDatasetIndex
{
  public:
    QgsMeshDatasetIndex( int group = -1, int dataset = -1 );
    int group() const;
    int dataset() const;
    bool isValid() const;
    bool operator == ( QgsMeshDatasetIndex other ) const;
    bool operator != ( QgsMeshDatasetIndex other ) const;
  private:
    int mGroupIndex = -1;
    int mDatasetIndex = -1;
};
 
class CORE_EXPORT QgsMeshDatasetValue
{
  public:
    QgsMeshDatasetValue( double x,
                         double y );
 
    QgsMeshDatasetValue( double scalar );
 
    QgsMeshDatasetValue() = default;
 
    ~QgsMeshDatasetValue() = default;
 
    void set( double scalar );
 
    void setX( double x );
 
    void setY( double y ) ;
 
    double scalar() const;
 
    double x() const;
 
    double y() const;
 
    bool operator==( QgsMeshDatasetValue other ) const;
 
  private:
    double mX = std::numeric_limits<double>::quiet_NaN();
    double mY = std::numeric_limits<double>::quiet_NaN();
};
 
class CORE_EXPORT QgsMeshDataBlock
{
  public:
    enum DataType
    {
      ActiveFlagInteger, 
      ScalarDouble, 
      Vector2DDouble, 
    };
 
    QgsMeshDataBlock();
 
    QgsMeshDataBlock( DataType type, int count );
 
    DataType type() const;
 
    int count() const;
 
    bool isValid() const;
 
    QgsMeshDatasetValue value( int index ) const;
 
    bool active( int index ) const;
 
    void setActive( const QVector<int> &vals );
 
    QVector<int> active() const;
 
    QVector<double> values() const;
 
    void setValues( const QVector<double> &vals );
 
    void setValid( bool valid );
 
  private:
    QVector<double> mDoubleBuffer;
    QVector<int> mIntegerBuffer;
    DataType mType;
    int mSize = 0;
    bool mIsValid = false;
};
 
class CORE_EXPORT QgsMesh3dDataBlock
{
  public:
    QgsMesh3dDataBlock();
 
    ~QgsMesh3dDataBlock();
 
    QgsMesh3dDataBlock( int count, bool isVector );
 
    void setValid( bool valid );
 
    bool isValid() const;
 
    bool isVector() const;
 
    int count() const;
 
    int firstVolumeIndex() const;
 
    int lastVolumeIndex() const;
 
    int volumesCount() const;
 
    QVector<int> verticalLevelsCount() const;
 
    void setVerticalLevelsCount( const QVector<int> &verticalLevelsCount );
 
    QVector<double> verticalLevels() const;
 
    void setVerticalLevels( const QVector<double> &verticalLevels );
 
    QVector<int> faceToVolumeIndex() const;
 
    void setFaceToVolumeIndex( const QVector<int> &faceToVolumeIndex );
 
    QVector<double> values() const;
 
    QgsMeshDatasetValue value( int volumeIndex ) const;
 
    void setValues( const QVector<double> &doubleBuffer );
 
  private:
    int mSize = 0;
    bool mIsValid = false;
    bool mIsVector = false;
    QVector<int> mVerticalLevelsCount;
    QVector<double> mVerticalLevels;
    QVector<int> mFaceToVolumeIndex;
    QVector<double> mDoubleBuffer; // for scalar/vector values
};
 
class CORE_EXPORT QgsMeshDatasetGroupMetadata
{
  public:
 
    enum DataType
    {
      DataOnFaces = 0, 
      DataOnVertices,  
      DataOnVolumes,   
      DataOnEdges      
    };
 
    QgsMeshDatasetGroupMetadata() = default;
 
    QgsMeshDatasetGroupMetadata( const QString &name,
                                 const QString uri,
                                 bool isScalar,
                                 DataType dataType,
                                 double minimum,
                                 double maximum,
                                 int maximumVerticalLevels,
                                 const QDateTime &referenceTime,
                                 bool isTemporal,
                                 const QMap<QString, QString> &extraOptions );
 
    QString name() const;
 
    QString uri() const;
 
    QMap<QString, QString> extraOptions() const;
 
    bool isVector() const;
 
    bool isScalar() const;
 
    bool isTemporal() const;
 
    DataType dataType() const;
 
    double minimum() const;
 
    double maximum() const;
 
    int maximumVerticalLevelsCount() const;
 
    QDateTime referenceTime() const;
 
  private:
    QString mName;
    QString mUri;
    bool mIsScalar = false;
    DataType mDataType = DataType::DataOnFaces;
    double mMinimumValue = std::numeric_limits<double>::quiet_NaN();
    double mMaximumValue = std::numeric_limits<double>::quiet_NaN();
    QMap<QString, QString> mExtraOptions;
    int mMaximumVerticalLevelsCount = 0; // for 3d stacked meshes
    QDateTime mReferenceTime;
    bool mIsTemporal = false;
};
 
class CORE_EXPORT QgsMeshDatasetMetadata
{
  public:
    QgsMeshDatasetMetadata() = default;
 
    QgsMeshDatasetMetadata( double time,
                            bool isValid,
                            double minimum,
                            double maximum,
                            int maximumVerticalLevels
                          );
 
    double time() const;
 
    bool isValid() const;
 
    double minimum() const;
 
    double maximum() const;
 
    int maximumVerticalLevelsCount() const;
 
  private:
    double mTime = std::numeric_limits<double>::quiet_NaN();
    bool mIsValid = false;
    double mMinimumValue = std::numeric_limits<double>::quiet_NaN();
    double mMaximumValue = std::numeric_limits<double>::quiet_NaN();
    int mMaximumVerticalLevelsCount = 0; // for 3d stacked meshes
};
 
 
class CORE_EXPORT QgsMeshDataset
{
  public:
    QgsMeshDataset() = default;
 
    virtual ~QgsMeshDataset() = default;
 
    virtual QgsMeshDatasetValue datasetValue( int valueIndex ) const = 0;
 
    virtual QgsMeshDataBlock datasetValues( bool isScalar, int valueIndex, int count ) const = 0;
 
    virtual QgsMeshDataBlock areFacesActive( int faceIndex, int count ) const = 0;
 
    virtual bool isActive( int faceIndex ) const = 0;
 
    virtual QgsMeshDatasetMetadata metadata() const = 0;
 
    virtual int valuesCount() const = 0;
};
 
class CORE_EXPORT QgsMeshDatasetGroup
{
  public:
 
    enum Type
    {
      None, 
      Persistent, 
      Memory, 
      Virtual, 
    };
 
    QgsMeshDatasetGroup() = default;
    virtual ~QgsMeshDatasetGroup();
 
    QgsMeshDatasetGroup( const QString &name );
 
    QgsMeshDatasetGroup( const QString &name, QgsMeshDatasetGroupMetadata::DataType dataType );
 
    virtual void initialize() = 0;
 
    QgsMeshDatasetGroupMetadata groupMetadata() const;
 
    virtual QgsMeshDatasetMetadata datasetMetadata( int datasetIndex ) const = 0 ;
 
    virtual int datasetCount() const = 0;
 
    virtual QgsMeshDataset *dataset( int index ) const = 0;
 
    virtual QgsMeshDatasetGroup::Type type() const = 0;
 
    double minimum() const;
 
    double maximum() const;
 
    void setMinimumMaximum( double min, double max );
 
    QString name() const;
 
    void setName( const QString &name );
 
    QgsMeshDatasetGroupMetadata::DataType dataType() const;
 
    void setDataType( const QgsMeshDatasetGroupMetadata::DataType &dataType );
 
    void addExtraMetadata( QString key, QString value );
    QMap<QString, QString> extraMetadata() const;
 
    bool isScalar() const;
 
    void setIsScalar( bool isScalar );
 
    bool checkValueCountPerDataset( int count ) const;
 
    void calculateStatistic();
 
    virtual QStringList datasetGroupNamesDependentOn() const;
 
    virtual QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const = 0;
 
    virtual QString description() const;
 
    void setReferenceTime( const QDateTime &referenceTime );
 
  protected:
    QString mName;
 
    QgsMeshDatasetGroupMetadata::DataType mDataType = QgsMeshDatasetGroupMetadata::DataOnVertices;
    QMap<QString, QString> mMetadata;
    bool mIsScalar = true;
 
  private:
    double mMinimum = std::numeric_limits<double>::quiet_NaN();
    double mMaximum = std::numeric_limits<double>::quiet_NaN();
 
    QDateTime mReferenceTime;
};
 
#ifndef SIP_RUN
 
class CORE_EXPORT QgsMeshMemoryDataset: public QgsMeshDataset
{
  public:
    QgsMeshMemoryDataset() = default;
 
    QgsMeshDatasetValue datasetValue( int valueIndex ) const override;
    QgsMeshDataBlock datasetValues( bool isScalar, int valueIndex, int count ) const override;
    QgsMeshDataBlock areFacesActive( int faceIndex, int count ) const override;
    QgsMeshDatasetMetadata metadata() const override;
    bool isActive( int faceIndex ) const override;
    int valuesCount() const override;
 
    void calculateMinMax();
 
    QVector<QgsMeshDatasetValue> values;
    QVector<int> active;
    double time = -1;
    bool valid = false;
    double minimum = std::numeric_limits<double>::quiet_NaN();
    double maximum = std::numeric_limits<double>::quiet_NaN();
};
 
class CORE_EXPORT QgsMeshMemoryDatasetGroup: public QgsMeshDatasetGroup
{
  public:
    QgsMeshMemoryDatasetGroup() = default;
    QgsMeshMemoryDatasetGroup( const QString &name );
    QgsMeshMemoryDatasetGroup( const QString &name, QgsMeshDatasetGroupMetadata::DataType dataType );
 
    void initialize() override;
    int datasetCount() const override;
    QgsMeshDatasetMetadata datasetMetadata( int datasetIndex ) const override;
    QgsMeshDataset *dataset( int index ) const override;
    virtual QgsMeshDatasetGroup::Type type() const override {return QgsMeshDatasetGroup::Memory;}
 
    QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context )  const override;
 
    void addDataset( std::shared_ptr<QgsMeshMemoryDataset> dataset );
 
    void clearDatasets();
 
    std::shared_ptr<const QgsMeshMemoryDataset> constDataset( int index ) const;
 
    QVector<std::shared_ptr<QgsMeshMemoryDataset>> memoryDatasets;
};
 
#endif //SIP_RUN
 
class CORE_EXPORT QgsMeshDatasetGroupTreeItem
{
  public:
 
    QgsMeshDatasetGroupTreeItem();
 
    QgsMeshDatasetGroupTreeItem( const QString &defaultName,
                                 const QString &sourceName,
                                 bool isVector,
                                 int index );
 
    QgsMeshDatasetGroupTreeItem( const QDomElement &itemElement, const QgsReadWriteContext &context );
 
    ~QgsMeshDatasetGroupTreeItem();
 
    QgsMeshDatasetGroupTreeItem *clone() const SIP_FACTORY;
 
    void appendChild( QgsMeshDatasetGroupTreeItem *item SIP_TRANSFER );
 
    void removeChild( QgsMeshDatasetGroupTreeItem *item SIP_TRANSFER );
 
    QgsMeshDatasetGroupTreeItem *child( int row ) const;
 
    QgsMeshDatasetGroupTreeItem *childFromDatasetGroupIndex( int index );
 
    int childCount() const;
 
    int totalChildCount() const;
 
    QList<int> enabledDatasetGroupIndexes() const;
 
    QgsMeshDatasetGroupTreeItem *parentItem() const;
 
    int row() const;
 
    QString name() const;
 
    void setName( const QString &name );
 
    QString providerName() const;
 
    bool isVector() const;
 
    int datasetGroupIndex() const;
 
    bool isEnabled() const;
 
    void setIsEnabled( bool isEnabled );
 
    QString defaultName() const;
 
    QgsMeshDatasetGroup::Type datasetGroupType() const;
 
    QList<int> groupIndexDependencies() const;
 
    QString description() const;
 
    void setDatasetGroup( QgsMeshDatasetGroup *datasetGroup );
 
    void setPersistentDatasetGroup( const QString &uri );
 
    QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context );
 
  private:
    QgsMeshDatasetGroupTreeItem *mParent = nullptr;
    QList< QgsMeshDatasetGroupTreeItem * > mChildren;
    QMap<int, QgsMeshDatasetGroupTreeItem *> mDatasetGroupIndexToChild;
 
    // Data
    QString mUserName;
    QString mOriginalName;
    QString mSourceName;
    QgsMeshDatasetGroup::Type mDatasetGroupType = QgsMeshDatasetGroup::None;
    QString mDescription;
 
    bool mIsVector = false;
    int mDatasetGroupIndex = -1;
    bool mIsEnabled = true;
 
    QList<int> mDatasetGroupDependencies;
    QList<int> mDatasetGroupDependentOn;
 
    QgsMeshDatasetGroupTreeItem *searchItemBySourceName( const QString &sourceName ) const;
    QgsMeshDatasetGroupTreeItem *rootItem() const;
    void freeAsDependency();
    void freeFromDependencies();
};
 
#endif // QGSMESHDATASET_H