qgsmeshrenderersettings.h

Go to the documentation of this file.

/***************************************************************************
                         qgsmeshrenderersettings.h
                         -------------------------
    begin                : May 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 QGSMESHRENDERERSETTINGS_H
#define QGSMESHRENDERERSETTINGS_H

#include <QColor>
#include <QDomElement>
#include <limits>

#include "qgis_core.h"
#include "qgis.h"
#include "qgscolorrampshader.h"
#include "qgsmeshdataprovider.h"
#include "qgsmesh3daveraging.h"

class CORE_EXPORT QgsMeshRendererMeshSettings
{
  public:
    bool isEnabled() const;
    void setEnabled( bool enabled );

    double lineWidth() const;
    void setLineWidth( double lineWidth );

    QColor color() const;
    void setColor( const QColor &color );

    QDomElement writeXml( QDomDocument &doc ) const;
    void readXml( const QDomElement &elem );

  private:
    bool mEnabled = false;
    double mLineWidth = DEFAULT_LINE_WIDTH;
    QColor mColor = Qt::black;
};

class CORE_EXPORT QgsMeshRendererScalarSettings
{
  public:
    enum DataInterpolationMethod
    {

      None = 0,

      NeighbourAverage,
    };

    QgsColorRampShader colorRampShader() const;
    void setColorRampShader( const QgsColorRampShader &shader );

    double classificationMinimum() const;
    double classificationMaximum() const;
    void setClassificationMinimumMaximum( double minimum, double maximum );

    double opacity() const;
    void setOpacity( double opacity );

    DataInterpolationMethod dataInterpolationMethod() const;

    void setDataInterpolationMethod( const DataInterpolationMethod &dataInterpolationMethod );

    QDomElement writeXml( QDomDocument &doc ) const;
    void readXml( const QDomElement &elem );

  private:
    QgsColorRampShader mColorRampShader;
    DataInterpolationMethod mDataInterpolationMethod = DataInterpolationMethod::None;
    double mClassificationMinimum = 0;
    double mClassificationMaximum = 0;
    double mOpacity = 1;

};

class CORE_EXPORT QgsMeshRendererVectorArrowSettings
{
  public:

    enum ArrowScalingMethod
    {

      MinMax = 0,

      Scaled,

      Fixed
    };

    QgsMeshRendererVectorArrowSettings::ArrowScalingMethod shaftLengthMethod() const;
    void setShaftLengthMethod( ArrowScalingMethod shaftLengthMethod );

    double minShaftLength() const;

    void setMinShaftLength( double minShaftLength );

    double maxShaftLength() const;

    void setMaxShaftLength( double maxShaftLength );

    double scaleFactor() const;

    void setScaleFactor( double scaleFactor );

    double fixedShaftLength() const;

    void setFixedShaftLength( double fixedShaftLength );

    double arrowHeadWidthRatio() const;
    void setArrowHeadWidthRatio( double arrowHeadWidthRatio );

    double arrowHeadLengthRatio() const;
    void setArrowHeadLengthRatio( double arrowHeadLengthRatio );

    QDomElement writeXml( QDomDocument &doc ) const;
    void readXml( const QDomElement &elem );

  private:
    QgsMeshRendererVectorArrowSettings::ArrowScalingMethod mShaftLengthMethod = QgsMeshRendererVectorArrowSettings::ArrowScalingMethod::MinMax;
    double mMinShaftLength = 0.8; //in millimeters
    double mMaxShaftLength = 10; //in millimeters
    double mScaleFactor = 10;
    double mFixedShaftLength = 20; //in millimeters
    double mArrowHeadWidthRatio = 0.15;
    double mArrowHeadLengthRatio = 0.40;
};

class CORE_EXPORT QgsMeshRendererVectorStreamlineSettings
{
  public:
    enum SeedingStartPointsMethod
    {

      MeshGridded = 0,

      Random,
    };

    SeedingStartPointsMethod seedingMethod() const;
    void setSeedingMethod( const SeedingStartPointsMethod &seedingMethod );
    double seedingDensity() const;
    void setSeedingDensity( double seedingDensity );
    void readXml( const QDomElement &elem );
    QDomElement writeXml( QDomDocument &doc ) const;

  private:

    QgsMeshRendererVectorStreamlineSettings::SeedingStartPointsMethod mSeedingMethod = MeshGridded;
    double mSeedingDensity = 0.15;
};

class CORE_EXPORT QgsMeshRendererVectorTracesSettings
{
  public:

    double maximumTailLength() const;
    void setMaximumTailLength( double maximumTailLength );
    int particlesCount() const;
    void setParticlesCount( int value );
    QgsUnitTypes::RenderUnit maximumTailLengthUnit() const;
    void setMaximumTailLengthUnit( const QgsUnitTypes::RenderUnit &maximumTailLengthUnit );

    void readXml( const QDomElement &elem );
    QDomElement writeXml( QDomDocument &doc ) const;



  private:
    int mParticlesCount = 1000;
    double mMaximumTailLength = 100;
    QgsUnitTypes::RenderUnit mMaximumTailLengthUnit = QgsUnitTypes::RenderMillimeters;

};

class CORE_EXPORT QgsMeshRendererVectorSettings
{
  public:

    enum Symbology
    {
      Arrows = 0,
      Streamlines,
      Traces
    };


    double lineWidth() const;
    void setLineWidth( double lineWidth );

    QColor color() const;
    void setColor( const QColor &color );

    double filterMin() const;

    void setFilterMin( double filterMin );

    double filterMax() const;

    void setFilterMax( double filterMax );

    bool isOnUserDefinedGrid() const;
    void setOnUserDefinedGrid( bool enabled );
    int userGridCellWidth() const;
    void setUserGridCellWidth( int width );
    int userGridCellHeight() const;
    void setUserGridCellHeight( int height );

    Symbology symbology() const;

    void setSymbology( const Symbology &symbology );

    QgsMeshRendererVectorArrowSettings arrowSettings() const;

    void setArrowsSettings( const QgsMeshRendererVectorArrowSettings &arrowSettings );

    QgsMeshRendererVectorStreamlineSettings streamLinesSettings() const;

    void setStreamLinesSettings( const QgsMeshRendererVectorStreamlineSettings &streamLinesSettings );

    QgsMeshRendererVectorTracesSettings tracesSettings() const;

    void setTracesSettings( const QgsMeshRendererVectorTracesSettings &tracesSettings );

    QDomElement writeXml( QDomDocument &doc ) const;
    void readXml( const QDomElement &elem );


  private:

    Symbology mDisplayingMethod = Arrows;

    double mLineWidth = DEFAULT_LINE_WIDTH; //in millimeters
    QColor mColor = Qt::black;
    double mFilterMin = -1; //disabled
    double mFilterMax = -1; //disabled
    int mUserGridCellWidth = 10; // in pixels
    int mUserGridCellHeight = 10; // in pixels
    bool mOnUserDefinedGrid = false;

    QgsMeshRendererVectorArrowSettings mArrowsSettings;
    QgsMeshRendererVectorStreamlineSettings mStreamLinesSettings;
    QgsMeshRendererVectorTracesSettings mTracesSettings;
};

class CORE_EXPORT QgsMeshRendererSettings
{
  public:

    QgsMeshRendererSettings();
    ~QgsMeshRendererSettings();

    QgsMeshRendererMeshSettings nativeMeshSettings() const { return mRendererNativeMeshSettings; }
    void setNativeMeshSettings( const QgsMeshRendererMeshSettings &settings ) { mRendererNativeMeshSettings = settings; }

    QgsMeshRendererMeshSettings triangularMeshSettings() const { return mRendererTriangularMeshSettings; }
    void setTriangularMeshSettings( const QgsMeshRendererMeshSettings &settings ) { mRendererTriangularMeshSettings = settings; }

    QgsMeshRendererScalarSettings scalarSettings( int groupIndex ) const { return mRendererScalarSettings.value( groupIndex ); }
    void setScalarSettings( int groupIndex, const QgsMeshRendererScalarSettings &settings ) { mRendererScalarSettings[groupIndex] = settings; }

    QgsMeshRendererVectorSettings vectorSettings( int groupIndex ) const { return mRendererVectorSettings.value( groupIndex ); }
    void setVectorSettings( int groupIndex, const QgsMeshRendererVectorSettings &settings ) { mRendererVectorSettings[groupIndex] = settings; }

    QgsMesh3dAveragingMethod *averagingMethod() const;

    void setAveragingMethod( QgsMesh3dAveragingMethod *method );

    QgsMeshDatasetIndex activeScalarDataset() const { return mActiveScalarDataset; }
    void setActiveScalarDataset( QgsMeshDatasetIndex index = QgsMeshDatasetIndex() ) { mActiveScalarDataset = index; }

    QgsMeshDatasetIndex activeVectorDataset() const { return mActiveVectorDataset; }
    void setActiveVectorDataset( QgsMeshDatasetIndex index = QgsMeshDatasetIndex() ) { mActiveVectorDataset = index; }

    QDomElement writeXml( QDomDocument &doc ) const;
    void readXml( const QDomElement &elem );

  private:
    QgsMeshRendererMeshSettings mRendererNativeMeshSettings;
    QgsMeshRendererMeshSettings mRendererTriangularMeshSettings;

    QHash<int, QgsMeshRendererScalarSettings> mRendererScalarSettings;  
    QHash<int, QgsMeshRendererVectorSettings> mRendererVectorSettings;  

    QgsMeshDatasetIndex mActiveScalarDataset;

    QgsMeshDatasetIndex mActiveVectorDataset;

    std::shared_ptr<QgsMesh3dAveragingMethod> mAveragingMethod;
};

#endif //QGSMESHRENDERERSETTINGS_H