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 "qgis_core.h"
#include "qgis.h"
#include "qgscolorrampshader.h"
#include "qgsmesh3daveraging.h"
#include "qgsinterpolatedlinerenderer.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 );
 
    Qgis::RenderUnit lineWidthUnit() const;
 
    void setLineWidthUnit( Qgis::RenderUnit lineWidthUnit );
 
    QDomElement writeXml( QDomDocument &doc ) const;
    void readXml( const QDomElement &elem );
 
  private:
    bool mEnabled = false;
    double mLineWidth = Qgis::DEFAULT_LINE_WIDTH;
    Qgis::RenderUnit mLineWidthUnit = Qgis::RenderUnit::Millimeters;
    QColor mColor = Qt::black;
};
 
class CORE_EXPORT QgsMeshRendererScalarSettings
{
  public:
 
    enum DataResamplingMethod
    {
 
      NoResampling = 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 );
 
    DataResamplingMethod dataResamplingMethod() const;
 
    void setDataResamplingMethod( const DataResamplingMethod &dataResamplingMethod );
 
    QgsInterpolatedLineWidth edgeStrokeWidth() const;
 
    void setEdgeStrokeWidth( const QgsInterpolatedLineWidth &strokeWidth );
 
    Qgis::RenderUnit edgeStrokeWidthUnit() const;
 
    void setEdgeStrokeWidthUnit( Qgis::RenderUnit edgeStrokeWidthUnit );
 
    void setLimits( Qgis::MeshRangeLimit limits ) { mRangeLimit = limits; }
 
    Qgis::MeshRangeLimit limits() const { return mRangeLimit; }
 
    void setExtent( Qgis::MeshRangeExtent extent ) { mRangeExtent = extent; }
 
    Qgis::MeshRangeExtent extent() const { return mRangeExtent; }
 
    QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context = QgsReadWriteContext() ) const;
    void readXml( const QDomElement &elem, const QgsReadWriteContext &context = QgsReadWriteContext() );
 
  private:
    void updateShader();
 
    QgsColorRampShader mColorRampShader;
    DataResamplingMethod mDataResamplingMethod = DataResamplingMethod::NoResampling;
    double mClassificationMinimum = 0;
    double mClassificationMaximum = 0;
    double mOpacity = 1;
 
    QgsInterpolatedLineWidth mEdgeStrokeWidth;
    Qgis::RenderUnit mEdgeStrokeWidthUnit = Qgis::RenderUnit::Millimeters;
 
    Qgis::MeshRangeExtent mRangeExtent = Qgis::MeshRangeExtent::WholeMesh;
    Qgis::MeshRangeLimit mRangeLimit = Qgis::MeshRangeLimit::NotSet;
};
 
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 );
    Qgis::RenderUnit maximumTailLengthUnit() const;
    void setMaximumTailLengthUnit( Qgis::RenderUnit maximumTailLengthUnit );
 
    void readXml( const QDomElement &elem );
    QDomElement writeXml( QDomDocument &doc ) const;
 
  private:
    int mParticlesCount = 1000;
    double mMaximumTailLength = 100;
    Qgis::RenderUnit mMaximumTailLengthUnit = Qgis::RenderUnit::Millimeters;
 
};
 
class CORE_EXPORT QgsMeshRendererVectorWindBarbSettings
{
  public:
    enum class WindSpeedUnit
    {
      MetersPerSecond = 0, 
      KilometersPerHour, 
      Knots, 
      MilesPerHour, 
      FeetPerSecond, 
      OtherUnit 
    };
 
    double magnitudeMultiplier() const;
 
    void setMagnitudeMultiplier( double magnitudeMultiplier );
 
    double shaftLength() const;
 
    void setShaftLength( double shaftLength );
 
    Qgis::RenderUnit shaftLengthUnits() const;
 
    void setShaftLengthUnits( Qgis::RenderUnit shaftLengthUnit );
 
    WindSpeedUnit magnitudeUnits() const;
 
    void setMagnitudeUnits( WindSpeedUnit units );
 
    QDomElement writeXml( QDomDocument &doc ) const;
    void readXml( const QDomElement &elem );
 
  private:
    double mShaftLength = 10;
    Qgis::RenderUnit mShaftLengthUnits = Qgis::RenderUnit::Millimeters;
    WindSpeedUnit mMagnitudeUnits = WindSpeedUnit::MetersPerSecond;
    double mMagnitudeMultiplier = 1;
};
 
class CORE_EXPORT QgsMeshRendererVectorSettings
{
  public:
 
    enum Symbology
    {
      Arrows = 0,
      Streamlines,
      Traces,
      WindBarbs
    };
 
    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 );
 
    QgsInterpolatedLineColor::ColoringMethod coloringMethod() const;
 
    void setColoringMethod( const QgsInterpolatedLineColor::ColoringMethod &coloringMethod );
 
    QgsColorRampShader colorRampShader() const;
 
    void setColorRampShader( const QgsColorRampShader &colorRampShader );
 
    QgsInterpolatedLineColor vectorStrokeColoring() const;
 
    QgsMeshRendererVectorArrowSettings arrowSettings() const;
 
    void setArrowsSettings( const QgsMeshRendererVectorArrowSettings &arrowSettings );
 
    QgsMeshRendererVectorStreamlineSettings streamLinesSettings() const;
 
    void setStreamLinesSettings( const QgsMeshRendererVectorStreamlineSettings &streamLinesSettings );
 
    QgsMeshRendererVectorTracesSettings tracesSettings() const;
 
    void setTracesSettings( const QgsMeshRendererVectorTracesSettings &tracesSettings );
 
    QgsMeshRendererVectorWindBarbSettings windBarbSettings() const;
 
    void setWindBarbSettings( const QgsMeshRendererVectorWindBarbSettings &windBarbSettings );
 
    QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context = QgsReadWriteContext() ) const;
    void readXml( const QDomElement &elem, const QgsReadWriteContext &context = QgsReadWriteContext() );
 
  private:
 
    Symbology mDisplayingMethod = Arrows;
 
    double mLineWidth = Qgis::DEFAULT_LINE_WIDTH; //in millimeters
    QgsColorRampShader mColorRampShader;
    QColor mColor = Qt::black;
    QgsInterpolatedLineColor::ColoringMethod mColoringMethod = QgsInterpolatedLineColor::SingleColor;
    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;
    QgsMeshRendererVectorWindBarbSettings mWindBarbSettings;
};
 
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; }
 
    QgsMeshRendererMeshSettings edgeMeshSettings() const { return mRendererEdgeMeshSettings; }
 
    void setEdgeMeshSettings( const QgsMeshRendererMeshSettings &settings ) { mRendererEdgeMeshSettings = settings; }
 
    QgsMeshRendererScalarSettings scalarSettings( int groupIndex ) const { return mRendererScalarSettings.value( groupIndex ); }
 
    void setScalarSettings( int groupIndex, const QgsMeshRendererScalarSettings &settings ) { mRendererScalarSettings[groupIndex] = settings; }
 
    bool hasScalarSettings( int groupIndex ) const {return mRendererScalarSettings.contains( groupIndex );}
 
    bool removeScalarSettings( int groupIndex )  {return mRendererScalarSettings.remove( groupIndex );}
 
    QgsMeshRendererVectorSettings vectorSettings( int groupIndex ) const { return mRendererVectorSettings.value( groupIndex ); }
    void setVectorSettings( int groupIndex, const QgsMeshRendererVectorSettings &settings ) { mRendererVectorSettings[groupIndex] = settings; }
 
    bool hasVectorSettings( int groupIndex ) const {return mRendererVectorSettings.contains( groupIndex );}
 
    bool removeVectorSettings( int groupIndex )  {return mRendererVectorSettings.remove( groupIndex );}
 
    QgsMesh3DAveragingMethod *averagingMethod() const;
 
    void setAveragingMethod( QgsMesh3DAveragingMethod *method );
 
    QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context = QgsReadWriteContext() ) const;
    void readXml( const QDomElement &elem, const QgsReadWriteContext &context = QgsReadWriteContext() );
 
    int activeScalarDatasetGroup() const;
 
    void setActiveScalarDatasetGroup( int activeScalarDatasetGroup );
 
    int activeVectorDatasetGroup() const;
 
    void setActiveVectorDatasetGroup( int activeVectorDatasetGroup );
 
    bool hasSettings( int datasetGroupIndex ) const;
 
  private:
    QgsMeshRendererMeshSettings mRendererNativeMeshSettings;
    QgsMeshRendererMeshSettings mRendererTriangularMeshSettings;
    QgsMeshRendererMeshSettings mRendererEdgeMeshSettings;
 
    QHash<int, QgsMeshRendererScalarSettings> mRendererScalarSettings;  
    QHash<int, QgsMeshRendererVectorSettings> mRendererVectorSettings;  
 
    int mActiveScalarDatasetGroup = -1;
 
    int mActiveVectorDatasetGroup = -1;
 
    std::shared_ptr<QgsMesh3DAveragingMethod> mAveragingMethod;
};
 
#endif //QGSMESHRENDERERSETTINGS_H