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 "qgspoint.h"
#include "qgsdataprovider.h"
 
 
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,
                                 bool isScalar,
                                 DataType dataType,
                                 double minimum,
                                 double maximum,
                                 int maximumVerticalLevels,
                                 const QDateTime &referenceTime,
                                 bool isTemporal,
                                 const QMap<QString, QString> &extraOptions );
 
    QString name() 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;
    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 QgsMeshDatasetGroupTreeItem
{
  public:
 
    QgsMeshDatasetGroupTreeItem();
 
    QgsMeshDatasetGroupTreeItem( const QString &defaultName,
                                 bool isVector,
                                 int index );
 
    QgsMeshDatasetGroupTreeItem( const QDomElement &itemElement, const QgsReadWriteContext &context );
 
    ~QgsMeshDatasetGroupTreeItem();
 
    QgsMeshDatasetGroupTreeItem *clone() const SIP_FACTORY;
 
    void appendChild( QgsMeshDatasetGroupTreeItem *item SIP_TRANSFER );
 
    QgsMeshDatasetGroupTreeItem *child( int row ) const;
 
    QgsMeshDatasetGroupTreeItem *childFromDatasetGroupIndex( int index );
 
    int childCount() const;
 
    int totalChildCount() const;
 
    QgsMeshDatasetGroupTreeItem *parentItem() const;
 
    int row() const;
 
    QString name() const;
 
    void setName( const QString &name );
 
    bool isVector() const;
 
    int datasetGroupIndex() const;
 
    bool isEnabled() const;
 
    void setIsEnabled( bool isEnabled );
 
    QString defaultName() const;
 
    QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context );
 
  private:
    QgsMeshDatasetGroupTreeItem *mParent = nullptr;
    QList< QgsMeshDatasetGroupTreeItem * > mChildren;
    QMap<int, QgsMeshDatasetGroupTreeItem *> mDatasetGroupIndexToChild;
 
    // Data
    QString mUserName;
    QString mProviderName;
    bool mIsVector = false;
    int mDatasetGroupIndex = -1;
    bool mIsEnabled = true;
};
 
#endif // QGSMESHDATASET_H