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 <limits>
#include <memory>
 
#include "qgis_core.h"
#include "qgis_sip.h"
 
#include <QDateTime>
#include <QDomElement>
#include <QMap>
#include <QPair>
#include <QString>
#include <QVector>
 
class QgsMeshLayer;
class QgsMeshDatasetGroup;
class QgsRectangle;
class QDomDocument;
class QgsReadWriteContext;
 
struct QgsMesh;

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( const QgsMesh3DDataBlock &other );
    SIP_SKIP QgsMesh3DDataBlock( QgsMesh3DDataBlock &&other );
    QgsMesh3DDataBlock &operator=( const QgsMesh3DDataBlock &other );
    QgsMesh3DDataBlock &operator=( QgsMesh3DDataBlock &&other );

    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 parentQuantityName() 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 mParentQuantityName;
    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
    {
      Unknown, 
      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 ) const;

    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() const;

    void setStatisticObsolete() const;

    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:
    mutable double mMinimum = std::numeric_limits<double>::quiet_NaN();
    mutable double mMaximum = std::numeric_limits<double>::quiet_NaN();
    mutable bool mIsStatisticObsolete = true;
 
    void updateStatistic() const;
 
    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;
    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;
};

class QgsMeshVerticesElevationDataset: public QgsMeshDataset
{
  public:
    QgsMeshVerticesElevationDataset( QgsMesh *mesh );
 
    QgsMeshDatasetValue datasetValue( int valueIndex ) const override;
    QgsMeshDataBlock datasetValues( bool isScalar, int valueIndex, int count ) const override;;
    QgsMeshDataBlock areFacesActive( int faceIndex, int count ) const override;;
    bool isActive( int ) const override {return true;};
    QgsMeshDatasetMetadata metadata() const override;;
    int valuesCount() const override;
  private:
    QgsMesh *mMesh;
};

class CORE_EXPORT QgsMeshVerticesElevationDatasetGroup : public QgsMeshDatasetGroup
{
  public:
    QgsMeshVerticesElevationDatasetGroup( QString name, QgsMesh *mesh );
 
    void initialize() override;
    QgsMeshDatasetMetadata datasetMetadata( int datasetIndex ) const override;;
    int datasetCount() const override;;
    QgsMeshDataset *dataset( int index ) const override;;
    QgsMeshDatasetGroup::Type type() const override;
    QDomElement writeXml( QDomDocument &, const QgsReadWriteContext & ) const override {return QDomElement();};
 
  private:
    std::unique_ptr<QgsMeshVerticesElevationDataset> mDataset;
};
 
#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::Unknown;
    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(); // cppcheck-suppress functionConst
    void freeFromDependencies(); // cppcheck-suppress functionConst
};
 
#endif // QGSMESHDATASET_H