qgsmesh3daveraging.h

Go to the documentation of this file.

/***************************************************************************
                         qgsmesh3daveraging.h
                         ---------------------
    begin                : November 2019
    copyright            : (C) 2019 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 QGSMESH3DAVERAGING_H
#define QGSMESH3DAVERAGING_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
 
#include <QDomElement>
 
class QgsMeshLayer;
class QgsMesh3dDataBlock;
class QgsMeshDataBlock;
class QgsMeshDatasetIndex;
class QgsFeedback;
class QgsMeshRenderer3dAveragingSettings;
 
class CORE_EXPORT QgsMesh3dAveragingMethod SIP_ABSTRACT
{
 
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    QgsMesh3dAveragingMethod *averagingMethod = dynamic_cast<QgsMesh3dAveragingMethod *>( sipCpp );
 
    sipType = 0;
 
    if ( averagingMethod )
    {
      switch ( averagingMethod->method() )
      {
        case QgsMesh3dAveragingMethod::MultiLevelsAveragingMethod:
          sipType = sipType_QgsMeshMultiLevelsAveragingMethod;
          break;
        case QgsMesh3dAveragingMethod::SigmaAveragingMethod:
          sipType = sipType_QgsMeshSigmaAveragingMethod;
          break;
        case QgsMesh3dAveragingMethod::RelativeHeightAveragingMethod:
          sipType = sipType_QgsMeshRelativeHeightAveragingMethod;
          break;
        case QgsMesh3dAveragingMethod::ElevationAveragingMethod:
          sipType = sipType_QgsMeshElevationAveragingMethod;
          break;
        default:
          sipType = nullptr;
          break;
      }
    }
    SIP_END
#endif
 
  public:
    enum Method
    {
      MultiLevelsAveragingMethod = 0,
      SigmaAveragingMethod,
      RelativeHeightAveragingMethod,
      ElevationAveragingMethod
    };
 
    QgsMesh3dAveragingMethod( Method method );
 
    virtual ~QgsMesh3dAveragingMethod() = default;
 
    QgsMeshDataBlock calculate( const QgsMesh3dDataBlock &block3d, QgsFeedback *feedback = nullptr ) const;
 
    virtual QDomElement writeXml( QDomDocument &doc ) const = 0;
 
    static QgsMesh3dAveragingMethod *createFromXml( const QDomElement &elem ) SIP_FACTORY;
 
    virtual void readXml( const QDomElement &elem ) = 0;
 
    static bool equals( const QgsMesh3dAveragingMethod *a, const QgsMesh3dAveragingMethod *b );
 
    virtual bool equals( const QgsMesh3dAveragingMethod *other ) const = 0;
 
    virtual QgsMesh3dAveragingMethod *clone() const = 0 SIP_FACTORY;
 
    Method method() const;
 
  private:
    virtual bool hasValidInputs() const = 0;
 
    void averageVolumeValuesForFace(
      int faceIndex,
      int volumesBelowFaceCount,
      int startVolumeIndex,
      double methodLevelTop,
      double methodLevelBottom,
      bool isVector,
      const QVector<double> &verticalLevelsForFace,
      const QVector<double> &volumeValues,
      QVector<double> &valuesFaces
    ) const;
 
    virtual void volumeRangeForFace(
      double &startVerticalLevel,
      double &endVerticalLevel,
      const QVector<double> &verticalLevels ) const = 0;
 
    Method mMethod;
};
 
class CORE_EXPORT QgsMeshMultiLevelsAveragingMethod: public QgsMesh3dAveragingMethod
{
  public:
    QgsMeshMultiLevelsAveragingMethod();
 
    QgsMeshMultiLevelsAveragingMethod( int startLevel, int endLevel, bool countedFromTop );
 
    QgsMeshMultiLevelsAveragingMethod( int verticalLevel, bool countedFromTop );
 
    ~QgsMeshMultiLevelsAveragingMethod() override;
    QDomElement writeXml( QDomDocument &doc ) const override;
    void readXml( const QDomElement &elem ) override;
    bool equals( const QgsMesh3dAveragingMethod *other ) const override;
    QgsMesh3dAveragingMethod *clone() const override SIP_FACTORY;
 
    int startVerticalLevel() const;
 
    int endVerticalLevel() const;
 
    bool countedFromTop() const;
 
    bool isSingleLevel() const;
 
  private:
    bool hasValidInputs() const override;
    void volumeRangeForFace( double &startVerticalLevel,
                             double &endVerticalLevel,
                             const QVector<double> &verticalLevels ) const override;
    void setLevels( int startVerticalLevel, int endVerticalLevel );
    int mStartVerticalLevel = 1;
    int mEndVerticalLevel = 1;
    bool mCountedFromTop = true;
};
 
class CORE_EXPORT QgsMeshSigmaAveragingMethod: public QgsMesh3dAveragingMethod
{
  public:
    QgsMeshSigmaAveragingMethod();
 
    QgsMeshSigmaAveragingMethod( double startFraction, double endFraction );
 
    ~QgsMeshSigmaAveragingMethod() override;
    QDomElement writeXml( QDomDocument &doc ) const override;
    void readXml( const QDomElement &elem ) override;
    bool equals( const QgsMesh3dAveragingMethod *other ) const override;
    QgsMesh3dAveragingMethod *clone() const override SIP_FACTORY;
 
    double startFraction() const;
 
    double endFraction() const;
 
  private:
    bool hasValidInputs() const override;
    void volumeRangeForFace( double &startVerticalLevel,
                             double &endVerticalLevel,
                             const QVector<double> &verticalLevels ) const override;
 
    double mStartFraction = 0;
    double mEndFraction = 1;
};
 
class CORE_EXPORT QgsMeshRelativeHeightAveragingMethod: public QgsMesh3dAveragingMethod
{
  public:
 
    QgsMeshRelativeHeightAveragingMethod();
 
    QgsMeshRelativeHeightAveragingMethod( double startHeight, double endHeight, bool countedFromTop );
 
    ~QgsMeshRelativeHeightAveragingMethod() override;
    QDomElement writeXml( QDomDocument &doc ) const override;
    void readXml( const QDomElement &elem ) override;
    bool equals( const QgsMesh3dAveragingMethod *other ) const override;
    QgsMesh3dAveragingMethod *clone() const override SIP_FACTORY;
 
    double startHeight() const;
 
    double endHeight() const;
 
    bool countedFromTop() const;
 
  private:
    bool hasValidInputs() const override;
    void volumeRangeForFace( double &startVerticalLevel,
                             double &endVerticalLevel,
                             const QVector<double> &verticalLevels ) const override;
    double mStartHeight = 0;
    double mEndHeight = 0;
    bool mCountedFromTop = true;
};
 
class CORE_EXPORT QgsMeshElevationAveragingMethod: public QgsMesh3dAveragingMethod
{
  public:
 
    QgsMeshElevationAveragingMethod();
 
    QgsMeshElevationAveragingMethod( double startElevation, double endElevation );
    ~QgsMeshElevationAveragingMethod() override;
 
    QDomElement writeXml( QDomDocument &doc ) const override;
    void readXml( const QDomElement &elem ) override;
    bool equals( const QgsMesh3dAveragingMethod *other ) const override;
    QgsMesh3dAveragingMethod *clone() const override SIP_FACTORY;
 
    double startElevation() const;
 
    double endElevation() const;
 
  private:
    bool hasValidInputs() const override;
    void volumeRangeForFace( double &startVerticalLevel,
                             double &endVerticalLevel,
                             const QVector<double> &verticalLevels ) const override;
    double mStartElevation = 0;
    double mEndElevation = 0;
};
 
#endif // QGSMESH3DAVERAGING_H