qgsmeshlayer.h

Go to the documentation of this file.

/***************************************************************************
                         qgsmeshlayer.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 QGSMESHLAYER_H
#define QGSMESHLAYER_H
 
#include <memory>
 
#include "qgis_core.h"
#include "qgsabstractprofilesource.h"
#include "qgscoordinatetransform.h"
#include "qgsinterval.h"
#include "qgsmaplayer.h"
#include "qgsmeshdataprovider.h"
#include "qgsmeshrenderersettings.h"
#include "qgsmeshsimplificationsettings.h"
#include "qgsmeshtimesettings.h"
 
#include <QString>
 
using namespace Qt::StringLiterals;
 
class QgsMapLayerRenderer;
struct QgsMeshLayerRendererCache;
class QgsSymbol;
class QgsTriangularMesh;
class QgsRenderContext;
struct QgsMesh;
class QgsMesh3DAveragingMethod;
class QgsMeshLayerTemporalProperties;
class QgsMeshDatasetGroupStore;
class QgsMeshEditor;
class QgsMeshEditingError;
class QgsMeshLayerElevationProperties;
class QgsAbstractMeshLayerLabeling;

class CORE_EXPORT QgsMeshLayer : public QgsMapLayer, public QgsAbstractProfileSource
{
    Q_OBJECT
  public:
    struct LayerOptions
    {
        explicit LayerOptions( const QgsCoordinateTransformContext &transformContext = QgsCoordinateTransformContext() )
          : transformContext( transformContext )
        {}

        QgsCoordinateTransformContext transformContext;

        bool loadDefaultStyle = true;

        bool skipCrsValidation = false;
    };

    explicit QgsMeshLayer(
      const QString &path = QString(), const QString &baseName = QString(), const QString &providerLib = u"mesh_memory"_s, const QgsMeshLayer::LayerOptions &options = QgsMeshLayer::LayerOptions()
    );
 
    ~QgsMeshLayer() override;
 
    QgsMeshLayer( const QgsMeshLayer &rhs ) = delete;
    QgsMeshLayer &operator=( QgsMeshLayer const &rhs ) = delete;
 
#ifdef SIP_RUN
    // clang-format off
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = u"<QgsMeshLayer: '%1' (%2)>"_s.arg( sipCpp->name(), sipCpp->dataProvider() ? sipCpp->dataProvider()->name() : u"Invalid"_s );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
// clang-format on
#endif
 
      QgsMeshDataProvider *dataProvider() override;
    const QgsMeshDataProvider *dataProvider() const override SIP_SKIP;
    QgsMeshLayer *clone() const override SIP_FACTORY;
    QgsRectangle extent() const override;
    QgsMapLayerRenderer *createMapRenderer( QgsRenderContext &rendererContext ) override SIP_FACTORY;
    QgsAbstractProfileSource *profileSource() override { return this; }
    QString profileSourceId() const override { return id(); }
    QString profileSourceName() const override { return name(); }
    QgsAbstractProfileGenerator *createProfileGenerator( const QgsProfileRequest &request ) override SIP_FACTORY;
    bool readSymbology( const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories ) override;
    bool writeSymbology( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories ) const override;
    bool writeStyle( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context, StyleCategories categories = AllStyleCategories ) const override;
    bool readStyle( const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, StyleCategories categories = AllStyleCategories ) override;
    QString encodedSource( const QString &source, const QgsReadWriteContext &context ) const override;
    QString decodedSource( const QString &source, const QString &provider, const QgsReadWriteContext &context ) const override;
    bool readXml( const QDomNode &layer_node, QgsReadWriteContext &context ) override;
    bool writeXml( QDomNode &layer_node, QDomDocument &doc, const QgsReadWriteContext &context ) const override;
    QgsMapLayerTemporalProperties *temporalProperties() override;
    QgsMapLayerElevationProperties *elevationProperties() override;
    void reload() override;
    QStringList subLayers() const override;
    QString htmlMetadata() const override;
    bool isEditable() const override;
    bool supportsEditing() const override;
    QString loadDefaultStyle( bool &resultFlag SIP_OUT ) final;

    bool addDatasets( const QString &path, const QDateTime &defaultReferenceTime = QDateTime() );

    bool removeDatasets( const QString &name );

    bool addDatasets( QgsMeshDatasetGroup *datasetGroup SIP_TRANSFER );

    bool saveDataset( const QString &path, int datasetGroupIndex, QString driver );

    QgsMesh *nativeMesh() SIP_SKIP;

    const QgsMesh *nativeMesh() const SIP_SKIP;

    QgsTriangularMesh *triangularMesh( double minimumTriangleSize = 0 ) const SIP_SKIP;

    int triangularMeshLevelOfDetailCount() const SIP_SKIP;

    QgsTriangularMesh *triangularMeshByLodIndex( int lodIndex ) const SIP_SKIP;

    void updateTriangularMesh( const QgsCoordinateTransform &transform = QgsCoordinateTransform() );

    QgsMeshLayerRendererCache *rendererCache() SIP_SKIP;

    QgsMeshRendererSettings rendererSettings() const;

    void setRendererSettings( const QgsMeshRendererSettings &settings, const bool repaint = true );

    void invalidateRendererCache();

    QgsMeshTimeSettings timeSettings() const;

    void setTimeSettings( const QgsMeshTimeSettings &settings );

    QgsMeshSimplificationSettings meshSimplificationSettings() const SIP_SKIP;

    void setMeshSimplificationSettings( const QgsMeshSimplificationSettings &meshSimplificationSettings ) SIP_SKIP;

    QString formatTime( double hours );

    int datasetGroupCount() const;

    int extraDatasetGroupCount() const;

    QList<int> datasetGroupsIndexes() const;

    QList<int> enabledDatasetGroupsIndexes() const;

    QgsMeshDatasetGroupMetadata datasetGroupMetadata( const QgsMeshDatasetIndex &index ) const;

    int datasetCount( const QgsMeshDatasetIndex &index ) const;

    QgsMeshDatasetMetadata datasetMetadata( const QgsMeshDatasetIndex &index ) const;

    QgsMeshDatasetValue datasetValue( const QgsMeshDatasetIndex &index, int valueIndex ) const;

    QgsMeshDataBlock datasetValues( const QgsMeshDatasetIndex &index, int valueIndex, int count ) const;

    QgsMesh3DDataBlock dataset3dValues( const QgsMeshDatasetIndex &index, int faceIndex, int count ) const;

    bool isFaceActive( const QgsMeshDatasetIndex &index, int faceIndex ) const;

    QgsMeshDataBlock areFacesActive( const QgsMeshDatasetIndex &index, int faceIndex, int count ) const;

    QgsMeshDatasetValue datasetValue( const QgsMeshDatasetIndex &index, const QgsPointXY &point, double searchRadius = 0 ) const;

    QgsMesh3DDataBlock dataset3dValue( const QgsMeshDatasetIndex &index, const QgsPointXY &point ) const;

    QgsMeshDatasetValue dataset1dValue( const QgsMeshDatasetIndex &index, const QgsPointXY &point, double searchRadius ) const;

    QgsMeshDatasetIndex datasetIndexAtTime( const QgsDateTimeRange &timeRange, int datasetGroupIndex ) const;

    QgsMeshDatasetIndex datasetIndexAtRelativeTime( const QgsInterval &relativeTime, int datasetGroupIndex ) const;

    QList<QgsMeshDatasetIndex> datasetIndexInRelativeTimeInterval( const QgsInterval &startRelativeTime, const QgsInterval &endRelativeTime, int datasetGroupIndex ) const;

    QgsMeshDatasetIndex activeScalarDatasetAtTime( const QgsDateTimeRange &timeRange, int group = -1 ) const;

    QgsMeshDatasetIndex activeVectorDatasetAtTime( const QgsDateTimeRange &timeRange, int group = -1 ) const;

    void setStaticScalarDatasetIndex( const QgsMeshDatasetIndex &staticScalarDatasetIndex );

    void setStaticVectorDatasetIndex( const QgsMeshDatasetIndex &staticVectorDatasetIndex );

    QgsMeshDatasetIndex staticScalarDatasetIndex( int group = -1 ) const;

    QgsMeshDatasetIndex staticVectorDatasetIndex( int group = -1 ) const;

    void setReferenceTime( const QDateTime &referenceTime );

    void setTemporalMatchingMethod( const QgsMeshDataProviderTemporalCapabilities::MatchingTemporalDatasetMethod &matchingMethod );

    QgsPointXY snapOnElement( QgsMesh::ElementType elementType, const QgsPointXY &point, double searchRadius );

    int closestElement( QgsMesh::ElementType elementType, const QgsPointXY &point, double searchRadius, QgsPointXY &projectedPoint SIP_OUT ) const;

    QList<int> selectVerticesByExpression( QgsExpression expression );

    QList<int> selectFacesByExpression( QgsExpression expression );

    QgsMeshDatasetGroupTreeItem *datasetGroupTreeRootItem() const;

    void setDatasetGroupTreeRootItem( QgsMeshDatasetGroupTreeItem *rootItem );

    void resetDatasetGroupTreeItem();

    QgsInterval firstValidTimeStep() const;

    QgsInterval datasetRelativeTime( const QgsMeshDatasetIndex &index );

    qint64 datasetRelativeTimeInMilliseconds( const QgsMeshDatasetIndex &index );

    Q_DECL_DEPRECATED bool startFrameEditing( const QgsCoordinateTransform &transform );

    bool startFrameEditing( const QgsCoordinateTransform &transform, QgsMeshEditingError &error SIP_OUT, bool fixErrors );
 

    bool commitFrameEditing( const QgsCoordinateTransform &transform, bool continueEditing = true );

    bool rollBackFrameEditing( const QgsCoordinateTransform &transform, bool continueEditing = true );

    void stopFrameEditing( const QgsCoordinateTransform &transform );

    bool reindex( const QgsCoordinateTransform &transform, bool renumber );

    QgsMeshEditor *meshEditor();

    bool isModified() const override;

    bool contains( const QgsMesh::ElementType &type ) const;

    int meshVertexCount() const;

    int meshFaceCount() const;

    int meshEdgeCount() const;

    bool labelsEnabled() const;

    void setLabelsEnabled( bool enabled );

    const QgsAbstractMeshLayerLabeling *labeling() const SIP_SKIP { return mLabeling.get(); }

    QgsAbstractMeshLayerLabeling *labeling() { return mLabeling.get(); }

    void setLabeling( QgsAbstractMeshLayerLabeling *labeling SIP_TRANSFER );

    bool minimumMaximumActiveScalarDataset( const QgsRectangle &extent, const QgsMeshDatasetIndex &datasetIndex, double &min SIP_OUT, double &max SIP_OUT );

    QgsMeshDatasetIndex activeScalarDatasetIndex( QgsRenderContext &rendererContext );

    bool datasetsPathUnique( const QString &path );

    QStringList extraDatasetUris() const { return mExtraDatasetUri; }
 
    using QgsMapLayer::loadNamedStyle;
    QString loadNamedStyle(
      const QString &uri, bool &resultFlag SIP_OUT, QgsMapLayer::StyleCategories categories = QgsMapLayer::AllStyleCategories, Qgis::LoadStyleFlags flags = Qgis::LoadStyleFlags()
    ) override;
 
  public slots:

    void setTransformContext( const QgsCoordinateTransformContext &transformContext ) override;
 
  signals:

    void activeScalarDatasetGroupChanged( int index );

    void activeVectorDatasetGroupChanged( int index );

    void timeSettingsChanged();

    void reloaded();
 
  private: // Private methods
    bool isReadOnly() const override { return true; }

    bool setDataProvider( QString const &provider, const QgsDataProvider::ProviderOptions &options, Qgis::DataProviderReadFlags flags = Qgis::DataProviderReadFlags() );
#ifdef SIP_RUN
    QgsMeshLayer( const QgsMeshLayer &rhs );
#endif
 
    void fillNativeMesh();
    void assignDefaultStyleToDatasetGroup( int groupIndex );
    void createSimplifiedMeshes();
    int levelsOfDetailsIndex( double partOfMeshInView ) const;
 
    bool hasSimplifiedMeshes() const;

    void applyClassificationOnScalarSettings( const QgsMeshDatasetGroupMetadata &meta, QgsMeshRendererScalarSettings &scalarSettings ) const;
 
  private slots:
    void onDatasetGroupsAdded( const QList<int> &datasetGroupIndexes );
    void onMeshEdited();
 
  private:
    std::unique_ptr<QgsMeshDataProvider> mDataProvider;

    QStringList mExtraDatasetUri;
 
    std::unique_ptr<QgsMeshDatasetGroupStore> mDatasetGroupStore;

    std::unique_ptr<QgsMesh> mNativeMesh;

    std::vector<std::unique_ptr<QgsTriangularMesh>> mTriangularMeshes;

    std::unique_ptr<QgsMeshLayerRendererCache> mRendererCache;

    QgsMeshRendererSettings mRendererSettings;

    QgsMeshTimeSettings mTimeSettings;

    QgsMeshSimplificationSettings mSimplificationSettings;
 
    QgsMeshLayerTemporalProperties *mTemporalProperties = nullptr;
    QgsMeshLayerElevationProperties *mElevationProperties = nullptr;

    Qgis::TemporalUnit mTemporalUnit = Qgis::TemporalUnit::Hours;
 
    int mStaticScalarDatasetIndex = 0;
    int mStaticVectorDatasetIndex = 0;
 
    QgsMeshEditor *mMeshEditor = nullptr;

    bool mLabelsEnabled = false;

    std::unique_ptr<QgsAbstractMeshLayerLabeling> mLabeling;

    int closestEdge( const QgsPointXY &point, double searchRadius, QgsPointXY &projectedPoint ) const;

    int closestVertex( const QgsPointXY &point, double searchRadius, QgsPointXY &projectedPoint ) const;

    int closestFace( const QgsPointXY &point, double searchRadius, QgsPointXY &projectedPoint ) const;
 
    void updateActiveDatasetGroups();
 
    QgsMeshRendererSettings accordSymbologyWithGroupName( const QgsMeshRendererSettings &settings, const QMap<QString, int> &nameToIndex );
    void checkSymbologyConsistency();
 
    void setDataSourcePrivate( const QString &dataSource, const QString &baseName, const QString &provider, const QgsDataProvider::ProviderOptions &options, Qgis::DataProviderReadFlags flags ) final;
};
 
#endif //QGSMESHLAYER_H