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 "qgis.h"
#include "qgis_core.h"
#include "qgscolorrampshader.h"
#include "qgsinterpolatedlinerenderer.h"
#include "qgsmesh3daveraging.h"
#include "qgsvectorfieldsettings.h"
 
#include <QColor>
#include <QDomElement>

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 QgsVectorFieldArrowSettings
{
    // exists for backwards compatibility only
};

class CORE_EXPORT QgsMeshRendererVectorStreamlineSettings : public QgsVectorFieldStreamlineSettings
{
    // exists for backwards compatibility only
};

class CORE_EXPORT QgsMeshRendererVectorTracesSettings : public QgsVectorFieldTracesSettings
{
    // exists for backwards compatibility only
};

class CORE_EXPORT QgsMeshRendererVectorWindBarbSettings : public QgsVectorFieldWindBarbSettings
{
    // exists for backwards compatibility only
};

class CORE_EXPORT QgsMeshRendererVectorSettings : public QgsVectorFieldSettings
{
    // exists for backwards compatibility only
};

class CORE_EXPORT QgsMeshRendererSettings
{
  public:
    QgsMeshRendererSettings();
    QgsMeshRendererSettings( const QgsMeshRendererSettings &other );
    SIP_SKIP QgsMeshRendererSettings( QgsMeshRendererSettings &&other );
 
    QgsMeshRendererSettings &operator=( const QgsMeshRendererSettings &other );
    QgsMeshRendererSettings &operator=( QgsMeshRendererSettings &&other );
 
    ~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 ); }

    QgsVectorFieldSettings vectorSettings( int groupIndex ) const { return mRendererVectorSettings.value( groupIndex ); }
    void setVectorSettings( int groupIndex, const QgsVectorFieldSettings &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, QgsVectorFieldSettings> mRendererVectorSettings;        

    int mActiveScalarDatasetGroup = -1;

    int mActiveVectorDatasetGroup = -1;

    std::shared_ptr<QgsMesh3DAveragingMethod> mAveragingMethod;
};
 
#endif //QGSMESHRENDERERSETTINGS_H