qgsmeshcalcutils.h

Go to the documentation of this file.

/***************************************************************************
                          qgsmeshcalcutils.h
                          ------------------
    begin                : December 18th, 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 QGSMESHCALCUTILS_H
#define QGSMESHCALCUTILS_H
 

 
#include <algorithm>
#include <functional>
#include <math.h>
#include <numeric>
 
#include "qgis_core.h"
#include "qgsmeshdataprovider.h"
#include "qgsmeshlayer.h"
#include "qgsrectangle.h"
 
#include <QMap>
#include <QStringList>
#include <QVector>
 
#define SIP_NO_FILE

class CORE_EXPORT QgsMeshCalcUtils
{
  public:

    QgsMeshCalcUtils( QgsMeshLayer *layer,
                      const QStringList &usedGroupNames,
                      double startTime,
                      double endTime );

    Q_DECL_DEPRECATED QgsMeshCalcUtils( QgsMeshLayer *layer,
                                        const QStringList &usedGroupNames,
                                        const QgsInterval &relativeTime );

    QgsMeshCalcUtils( QgsMeshLayer *layer,
                      const QStringList &usedGroupNames,
                      const QStringList &usedGroupNamesForAggregate,
                      const QgsInterval &relativeTime,
                      const QgsInterval &startTime,
                      const QgsInterval &endTime );
 

    bool isValid() const;

    const QgsMeshLayer *layer() const;

    std::shared_ptr<const QgsMeshMemoryDatasetGroup> group( const QString &groupName ) const;

    void ones( QgsMeshMemoryDatasetGroup &group1 ) const;

    void nodata( QgsMeshMemoryDatasetGroup &group1 ) const;

    std::shared_ptr<QgsMeshMemoryDataset> number( double val, double time ) const;

    void copy( QgsMeshMemoryDatasetGroup &group1, const QString &groupName, bool forAggregate = false ) const;

    std::shared_ptr<QgsMeshMemoryDataset> copy( std::shared_ptr<const QgsMeshMemoryDataset> dataset0 ) const;

    void transferDatasets( QgsMeshMemoryDatasetGroup &group1, QgsMeshMemoryDatasetGroup &group2 ) const;

    void expand( QgsMeshMemoryDatasetGroup &group1,
                 const QgsMeshMemoryDatasetGroup &group2 ) const;

    void number( QgsMeshMemoryDatasetGroup &group1, double val ) const;

    void addIf( QgsMeshMemoryDatasetGroup &trueGroup,
                const QgsMeshMemoryDatasetGroup &falseGroup,
                const QgsMeshMemoryDatasetGroup &condition ) const;

    void filter( QgsMeshMemoryDatasetGroup &group1, const QgsRectangle &extent ) const;

    void filter( QgsMeshMemoryDatasetGroup &group1, const QgsGeometry &mask ) const;

    void logicalNot( QgsMeshMemoryDatasetGroup &group1 ) const;

    void changeSign( QgsMeshMemoryDatasetGroup &group1 ) const;

    void abs( QgsMeshMemoryDatasetGroup &group1 ) const;

    void sumAggregated( QgsMeshMemoryDatasetGroup &group1 ) const;

    void minimumAggregated( QgsMeshMemoryDatasetGroup &group1 ) const;

    void maximumAggregated( QgsMeshMemoryDatasetGroup &group1 ) const;

    void averageAggregated( QgsMeshMemoryDatasetGroup &group1 ) const;

    void add( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void subtract( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void multiply( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void divide( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void power( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void equal( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void notEqual( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void greaterThan( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void lesserThan( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void lesserEqual( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void greaterEqual( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void logicalAnd( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void logicalOr( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void minimum( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void maximum( QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    static QgsMeshDatasetGroupMetadata::DataType determineResultDataType( QgsMeshLayer *layer, const QStringList &usedGroupNames );

    QgsMeshDatasetGroupMetadata::DataType outputType() const;
 
  private:
    double ffilter( double val1, double filter ) const;
    double fadd( double val1, double val2 ) const;
    double fsubtract( double val1, double val2 ) const;
    double fmultiply( double val1, double val2 ) const;
    double fdivide( double val1, double val2 ) const;
    double fpower( double val1, double val2 ) const;
    double fequal( double val1, double val2 ) const;
    double fnotEqual( double val1, double val2 ) const;
    double fgreaterThan( double val1, double val2 ) const;
    double flesserThan( double val1, double val2 ) const;
    double flesserEqual( double val1, double val2 ) const;
    double fgreaterEqual( double val1, double val2 ) const;
    double flogicalAnd( double val1, double val2 ) const;
    double flogicalOr( double val1, double val2 ) const;
    double flogicalNot( double val1 ) const;
    double fchangeSign( double val1 ) const;
    double fmin( double val1, double val2 ) const;
    double fmax( double val1, double val2 ) const;
    double fabs( double val1 ) const;
    double fsumAggregated( QVector<double> &vals ) const;
    double fminimumAggregated( QVector<double> &vals ) const;
    double fmaximumAggregated( QVector<double> &vals ) const;
    double faverageAggregated( QVector<double> &vals ) const;

    std::shared_ptr<QgsMeshMemoryDatasetGroup> createMemoryDatasetGroup( const QString &datasetGroupName,
        const QgsInterval &relativeTime = QgsInterval(),
        const QgsInterval &startTime = QgsInterval(),
        const QgsInterval &endTime = QgsInterval() ) const;

    std::shared_ptr<const QgsMeshMemoryDatasetGroup> group( const QString &groupName, bool isAggregate ) const;

    std::shared_ptr<QgsMeshMemoryDataset> createMemoryDataset( const QgsMeshMemoryDatasetGroup &grp ) const;

    std::shared_ptr<QgsMeshMemoryDataset> createMemoryDataset( const QgsMeshDatasetIndex &datasetIndex ) const;

    std::shared_ptr<QgsMeshMemoryDataset> createMemoryDataset( const QgsMeshDatasetGroupMetadata::DataType type ) const;

    std::shared_ptr<QgsMeshMemoryDataset> canditateDataset( QgsMeshMemoryDatasetGroup &group,
        int datasetIndex ) const;

    std::shared_ptr<const QgsMeshMemoryDataset> constCandidateDataset( const QgsMeshMemoryDatasetGroup &group,
        int datasetIndex ) const;

    int datasetCount( const QgsMeshMemoryDatasetGroup &group1, const QgsMeshMemoryDatasetGroup &group2 ) const;

    void activate( std::shared_ptr<QgsMeshMemoryDataset> dataset,
                   std::shared_ptr<const QgsMeshMemoryDataset> refDataset = nullptr ) const;

    void activate( QgsMeshMemoryDatasetGroup &group ) const;

    void populateSpatialFilter( QgsMeshMemoryDatasetGroup &filter, const QgsRectangle &extent ) const; // create a filter from extent

    void populateMaskFilter( QgsMeshMemoryDatasetGroup &filter, const QgsGeometry &mask ) const; // create a filter from mask

    void func1( QgsMeshMemoryDatasetGroup &group,
                std::function<double( double )> func ) const;

    void func2( QgsMeshMemoryDatasetGroup &group1,
                const QgsMeshMemoryDatasetGroup &group2,
                std::function<double( double, double )> func ) const;

    void funcAggr( QgsMeshMemoryDatasetGroup &group1,
                   std::function<double( QVector<double>& )> func ) const;
 
    const QgsTriangularMesh *triangularMesh() const;
    const QgsMesh *nativeMesh() const;
    void updateMesh() const;
 
    QgsMeshLayer *mMeshLayer; 
    bool mIsValid; 
    QgsMeshDatasetGroupMetadata::DataType mOutputType = QgsMeshDatasetGroupMetadata::DataType::DataOnFaces; 
    QVector<double> mTimes;
    QMap < QString, std::shared_ptr<QgsMeshMemoryDatasetGroup> > mDatasetGroupMap; 
    QMap < QString, std::shared_ptr<QgsMeshMemoryDatasetGroup> > mDatasetGroupMapForAggregate; 
 
    bool mIgnoreTime = false; // with virtual datasetgroup, we only consider the current time step, except for aggregate function where we don't care about time value
};

 
#endif // QGSMESHCALCUTILS_H