Branch data     Line data    Source code

       1                 :            : /***************************************************************************
       2                 :            :                          qgsmeshrenderersettings.h
       3                 :            :                          -------------------------
       4                 :            :     begin                : May 2018
       5                 :            :     copyright            : (C) 2018 by Peter Petrik
       6                 :            :     email                : zilolv at gmail dot com
       7                 :            :  ***************************************************************************/
       8                 :            : 
       9                 :            : /***************************************************************************
      10                 :            :  *                                                                         *
      11                 :            :  *   This program is free software; you can redistribute it and/or modify  *
      12                 :            :  *   it under the terms of the GNU General Public License as published by  *
      13                 :            :  *   the Free Software Foundation; either version 2 of the License, or     *
      14                 :            :  *   (at your option) any later version.                                   *
      15                 :            :  *                                                                         *
      16                 :            :  ***************************************************************************/
      17                 :            : 
      18                 :            : #ifndef QGSMESHRENDERERSETTINGS_H
      19                 :            : #define QGSMESHRENDERERSETTINGS_H
      20                 :            : 
      21                 :            : #include <QColor>
      22                 :            : #include <QDomElement>
      23                 :            : #include <limits>
      24                 :            : 
      25                 :            : #include "qgis_core.h"
      26                 :            : #include "qgis.h"
      27                 :            : #include "qgscolorrampshader.h"
      28                 :            : #include "qgsmeshdataprovider.h"
      29                 :            : #include "qgsmesh3daveraging.h"
      30                 :            : #include "qgsinterpolatedlinerenderer.h"
      31                 :            : 
      32                 :            : /**
      33                 :            :  * \ingroup core
      34                 :            :  *
      35                 :            :  * \brief Represents a mesh renderer settings for mesh object
      36                 :            :  *
      37                 :            :  * \note The API is considered EXPERIMENTAL and can be changed without a notice
      38                 :            :  *
      39                 :            :  * \since QGIS 3.2
      40                 :            :  */
      41                 :          0 : class CORE_EXPORT QgsMeshRendererMeshSettings
      42                 :            : {
      43                 :            :   public:
      44                 :            :     //! Returns whether mesh structure rendering is enabled
      45                 :            :     bool isEnabled() const;
      46                 :            :     //! Sets whether mesh structure rendering is enabled
      47                 :            :     void setEnabled( bool enabled );
      48                 :            : 
      49                 :            :     //! Returns line width used for rendering (in millimeters)
      50                 :            :     double lineWidth() const;
      51                 :            :     //! Sets line width used for rendering (in millimeters)
      52                 :            :     void setLineWidth( double lineWidth );
      53                 :            : 
      54                 :            :     //! Returns color used for rendering
      55                 :            :     QColor color() const;
      56                 :            :     //! Sets color used for rendering of the mesh
      57                 :            :     void setColor( const QColor &color );
      58                 :            : 
      59                 :            :     /**
      60                 :            :      * Returns units of the width of the mesh frame
      61                 :            :      *
      62                 :            :      * \since QGIS 3.14
      63                 :            :      */
      64                 :            :     QgsUnitTypes::RenderUnit lineWidthUnit() const;
      65                 :            : 
      66                 :            :     /**
      67                 :            :      * Sets units of the width of the mesh frame
      68                 :            :      *
      69                 :            :      * \since QGIS 3.14
      70                 :            :      */
      71                 :            :     void setLineWidthUnit( const QgsUnitTypes::RenderUnit &lineWidthUnit );
      72                 :            : 
      73                 :            :     //! Writes configuration to a new DOM element
      74                 :            :     QDomElement writeXml( QDomDocument &doc ) const;
      75                 :            :     //! Reads configuration from the given DOM element
      76                 :            :     void readXml( const QDomElement &elem );
      77                 :            : 
      78                 :            :   private:
      79                 :          0 :     bool mEnabled = false;
      80                 :          0 :     double mLineWidth = DEFAULT_LINE_WIDTH;
      81                 :          0 :     QgsUnitTypes::RenderUnit mLineWidthUnit = QgsUnitTypes::RenderMillimeters;
      82                 :          0 :     QColor mColor = Qt::black;
      83                 :            : };
      84                 :            : 
      85                 :            : /**
      86                 :            :  * \ingroup core
      87                 :            :  *
      88                 :            :  * \brief Represents a mesh renderer settings for scalar datasets
      89                 :            :  *
      90                 :            :  * \note The API is considered EXPERIMENTAL and can be changed without a notice
      91                 :            :  *
      92                 :            :  * \since QGIS 3.2
      93                 :            :  */
      94                 :          0 : class CORE_EXPORT QgsMeshRendererScalarSettings
      95                 :            : {
      96                 :            :   public:
      97                 :            : 
      98                 :            :     /**
      99                 :            :      * Resampling of value from dataset
     100                 :            :      *
     101                 :            :      * - for vertices : does a resampling from values defined on surrounding faces
     102                 :            :      * - for faces : does a resampling from values defined on surrounding vertices
     103                 :            :      * - for edges : not supported.
     104                 :            :      */
     105                 :            :     enum DataResamplingMethod
     106                 :            :     {
     107                 :            : 
     108                 :            :       /**
     109                 :            :        * Does not use resampling
     110                 :            :        */
     111                 :            :       None = 0,
     112                 :            : 
     113                 :            :       /**
     114                 :            :        * Does a simple average of values defined for all surrounding faces/vertices
     115                 :            :        */
     116                 :            :       NeighbourAverage,
     117                 :            :     };
     118                 :            : 
     119                 :            :     //! Returns color ramp shader function
     120                 :            :     QgsColorRampShader colorRampShader() const;
     121                 :            :     //! Sets color ramp shader function
     122                 :            :     void setColorRampShader( const QgsColorRampShader &shader );
     123                 :            : 
     124                 :            :     //! Returns min value used for creation of the color ramp shader
     125                 :            :     double classificationMinimum() const;
     126                 :            :     //! Returns max value used for creation of the color ramp shader
     127                 :            :     double classificationMaximum() const;
     128                 :            :     //! Sets min/max values used for creation of the color ramp shader
     129                 :            :     void setClassificationMinimumMaximum( double minimum, double maximum );
     130                 :            : 
     131                 :            :     //! Returns opacity
     132                 :            :     double opacity() const;
     133                 :            :     //! Sets opacity
     134                 :            :     void setOpacity( double opacity );
     135                 :            : 
     136                 :            :     /**
     137                 :            :      * Returns the type of interpolation to use to
     138                 :            :      * convert face defined datasets to
     139                 :            :      * values on vertices
     140                 :            :      *
     141                 :            :      * \since QGIS 3.12
     142                 :            :      */
     143                 :            :     DataResamplingMethod dataResamplingMethod() const;
     144                 :            : 
     145                 :            :     /**
     146                 :            :      * Sets data interpolation method
     147                 :            :      *
     148                 :            :      * \since QGIS 3.12
     149                 :            :      */
     150                 :            :     void setDataResamplingMethod( const DataResamplingMethod &dataResamplingMethod );
     151                 :            : 
     152                 :            :     /**
     153                 :            :      * Returns the stroke width used to render edges scalar dataset
     154                 :            :      *
     155                 :            :      * \since QGIS 3.14
     156                 :            :      */
     157                 :            :     QgsInterpolatedLineWidth edgeStrokeWidth() const;
     158                 :            : 
     159                 :            :     /**
     160                 :            :      * Sets the stroke width used to render edges scalar dataset
     161                 :            :      *
     162                 :            :      * \since QGIS 3.14
     163                 :            :      */
     164                 :            :     void setEdgeStrokeWidth( const QgsInterpolatedLineWidth &strokeWidth );
     165                 :            : 
     166                 :            :     /**
     167                 :            :     *Returns the stroke width unit used to render edges scalar dataset
     168                 :            :     *
     169                 :            :     * \since QGIS 3.14
     170                 :            :     */
     171                 :            :     QgsUnitTypes::RenderUnit edgeStrokeWidthUnit() const;
     172                 :            : 
     173                 :            :     /**
     174                 :            :      * Sets the stroke width unit used to render edges scalar dataset
     175                 :            :      *
     176                 :            :      * \since QGIS 3.14
     177                 :            :      */
     178                 :            :     void setEdgeStrokeWidthUnit( const QgsUnitTypes::RenderUnit &edgeStrokeWidthUnit );
     179                 :            : 
     180                 :            :     //! Writes configuration to a new DOM element
     181                 :            :     QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context = QgsReadWriteContext() ) const;
     182                 :            :     //! Reads configuration from the given DOM element
     183                 :            :     void readXml( const QDomElement &elem, const QgsReadWriteContext &context = QgsReadWriteContext() );
     184                 :            : 
     185                 :            :   private:
     186                 :            :     QgsColorRampShader mColorRampShader;
     187                 :          0 :     DataResamplingMethod mDataResamplingMethod = DataResamplingMethod::None;
     188                 :          0 :     double mClassificationMinimum = 0;
     189                 :          0 :     double mClassificationMaximum = 0;
     190                 :          0 :     double mOpacity = 1;
     191                 :            : 
     192                 :            :     QgsInterpolatedLineWidth mEdgeStrokeWidth;
     193                 :          0 :     QgsUnitTypes::RenderUnit mEdgeStrokeWidthUnit = QgsUnitTypes::RenderMillimeters;
     194                 :            : };
     195                 :            : 
     196                 :            : /**
     197                 :            :  * \ingroup core
     198                 :            :  *
     199                 :            :  * \brief Represents a mesh renderer settings for vector datasets displayed with arrows
     200                 :            :  *
     201                 :            :  * \note The API is considered EXPERIMENTAL and can be changed without a notice
     202                 :            :  *
     203                 :            :  * \since QGIS 3.12
     204                 :            :  */
     205                 :          0 : class CORE_EXPORT QgsMeshRendererVectorArrowSettings
     206                 :            : {
     207                 :            :   public:
     208                 :            : 
     209                 :            :     //! Algorithm how to transform vector magnitude to length of arrow on the device in pixels
     210                 :            :     enum ArrowScalingMethod
     211                 :            :     {
     212                 :            : 
     213                 :            :       /**
     214                 :            :        * Scale vector magnitude linearly to fit in range of vectorFilterMin() and vectorFilterMax()
     215                 :            :        */
     216                 :            :       MinMax = 0,
     217                 :            : 
     218                 :            :       /**
     219                 :            :        * Scale vector magnitude by factor scaleFactor()
     220                 :            :        */
     221                 :            :       Scaled,
     222                 :            : 
     223                 :            :       /**
     224                 :            :        * Use fixed length fixedShaftLength() regardless of vector's magnitude
     225                 :            :        */
     226                 :            :       Fixed
     227                 :            :     };
     228                 :            : 
     229                 :            :     //! Returns method used for drawing arrows
     230                 :            :     QgsMeshRendererVectorArrowSettings::ArrowScalingMethod shaftLengthMethod() const;
     231                 :            :     //! Sets method used for drawing arrows
     232                 :            :     void setShaftLengthMethod( ArrowScalingMethod shaftLengthMethod );
     233                 :            : 
     234                 :            :     /**
     235                 :            :      * Returns mininimum shaft length (in millimeters)
     236                 :            :      *
     237                 :            :      * Only for QgsMeshRendererVectorSettings::ArrowScalingMethod::MinMax
     238                 :            :      */
     239                 :            :     double minShaftLength() const;
     240                 :            : 
     241                 :            :     /**
     242                 :            :      * Sets mininimum shaft length (in millimeters)
     243                 :            :      *
     244                 :            :      * Only for QgsMeshRendererVectorSettings::ArrowScalingMethod::MinMax
     245                 :            :      */
     246                 :            :     void setMinShaftLength( double minShaftLength );
     247                 :            : 
     248                 :            :     /**
     249                 :            :      * Returns maximum shaft length (in millimeters)
     250                 :            :      *
     251                 :            :      * Only for QgsMeshRendererVectorSettings::ArrowScalingMethod::MinMax
     252                 :            :      */
     253                 :            :     double maxShaftLength() const;
     254                 :            : 
     255                 :            :     /**
     256                 :            :      * Sets maximum shaft length (in millimeters)
     257                 :            :      *
     258                 :            :      * Only for QgsMeshRendererVectorSettings::ArrowScalingMethod::MinMax
     259                 :            :      */
     260                 :            :     void setMaxShaftLength( double maxShaftLength );
     261                 :            : 
     262                 :            :     /**
     263                 :            :      * Returns scale factor
     264                 :            :      *
     265                 :            :      * Only for QgsMeshRendererVectorSettings::ArrowScalingMethod::Scaled
     266                 :            :      */
     267                 :            :     double scaleFactor() const;
     268                 :            : 
     269                 :            :     /**
     270                 :            :      * Sets scale factor
     271                 :            :      *
     272                 :            :      * Only for QgsMeshRendererVectorSettings::ArrowScalingMethod::Scaled
     273                 :            :      */
     274                 :            :     void setScaleFactor( double scaleFactor );
     275                 :            : 
     276                 :            :     /**
     277                 :            :      * Returns fixed arrow length (in millimeters)
     278                 :            :      *
     279                 :            :      * Only for QgsMeshRendererVectorSettings::ArrowScalingMethod::Fixed
     280                 :            :      */
     281                 :            :     double fixedShaftLength() const;
     282                 :            : 
     283                 :            :     /**
     284                 :            :      * Sets fixed length  (in millimeters)
     285                 :            :      *
     286                 :            :      * Only for QgsMeshRendererVectorSettings::ArrowScalingMethod::Fixed
     287                 :            :      */
     288                 :            :     void setFixedShaftLength( double fixedShaftLength );
     289                 :            : 
     290                 :            :     //! Returns ratio of the head width of the arrow (range 0-1)
     291                 :            :     double arrowHeadWidthRatio() const;
     292                 :            :     //! Sets ratio of the head width of the arrow (range 0-1)
     293                 :            :     void setArrowHeadWidthRatio( double arrowHeadWidthRatio );
     294                 :            : 
     295                 :            :     //! Returns ratio of the head length of the arrow (range 0-1)
     296                 :            :     double arrowHeadLengthRatio() const;
     297                 :            :     //! Sets ratio of the head length of the arrow (range 0-1)
     298                 :            :     void setArrowHeadLengthRatio( double arrowHeadLengthRatio );
     299                 :            : 
     300                 :            :     //! Writes configuration to a new DOM element
     301                 :            :     QDomElement writeXml( QDomDocument &doc ) const;
     302                 :            :     //! Reads configuration from the given DOM element
     303                 :            :     void readXml( const QDomElement &elem );
     304                 :            : 
     305                 :            :   private:
     306                 :          0 :     QgsMeshRendererVectorArrowSettings::ArrowScalingMethod mShaftLengthMethod = QgsMeshRendererVectorArrowSettings::ArrowScalingMethod::MinMax;
     307                 :          0 :     double mMinShaftLength = 0.8; //in millimeters
     308                 :          0 :     double mMaxShaftLength = 10; //in millimeters
     309                 :          0 :     double mScaleFactor = 10;
     310                 :          0 :     double mFixedShaftLength = 20; //in millimeters
     311                 :          0 :     double mArrowHeadWidthRatio = 0.15;
     312                 :          0 :     double mArrowHeadLengthRatio = 0.40;
     313                 :            : };
     314                 :            : 
     315                 :            : /**
     316                 :            :  * \ingroup core
     317                 :            :  *
     318                 :            :  * \brief Represents a streamline renderer settings for vector datasets displayed by streamlines
     319                 :            :  *
     320                 :            :  * \note The API is considered EXPERIMENTAL and can be changed without a notice
     321                 :            :  *
     322                 :            :  * \since QGIS 3.12
     323                 :            :  */
     324                 :          0 : class CORE_EXPORT QgsMeshRendererVectorStreamlineSettings
     325                 :            : {
     326                 :            :   public:
     327                 :            :     //! Method used to define start points that are used to draw streamlines
     328                 :            :     enum SeedingStartPointsMethod
     329                 :            :     {
     330                 :            : 
     331                 :            :       /**
     332                 :            :        * Seeds start points on the vertices mesh or user regular grid
     333                 :            :        */
     334                 :            :       MeshGridded = 0,
     335                 :            : 
     336                 :            :       /**
     337                 :            :        * Seeds start points randomly on the mesh
     338                 :            :        */
     339                 :            :       Random
     340                 :            :     };
     341                 :            : 
     342                 :            :     //! Returns the method used for seeding start points of strealines
     343                 :            :     SeedingStartPointsMethod seedingMethod() const;
     344                 :            :     //! Sets the method used for seeding start points of strealines
     345                 :            :     void setSeedingMethod( const SeedingStartPointsMethod &seedingMethod );
     346                 :            :     //! Returns the density used for seeding start points
     347                 :            :     double seedingDensity() const;
     348                 :            :     //! Sets the density used for seeding start points
     349                 :            :     void setSeedingDensity( double seedingDensity );
     350                 :            :     //! Reads configuration from the given DOM element
     351                 :            :     void readXml( const QDomElement &elem );
     352                 :            :     //! Writes configuration to a new DOM element
     353                 :            :     QDomElement writeXml( QDomDocument &doc ) const;
     354                 :            : 
     355                 :            :   private:
     356                 :            : 
     357                 :          0 :     QgsMeshRendererVectorStreamlineSettings::SeedingStartPointsMethod mSeedingMethod = MeshGridded;
     358                 :          0 :     double mSeedingDensity = 0.15;
     359                 :            : };
     360                 :            : 
     361                 :            : /**
     362                 :            :  * \ingroup core
     363                 :            :  *
     364                 :            :  * \brief Represents a trace renderer settings for vector datasets displayed by particle traces
     365                 :            :  *
     366                 :            :  * \note The API is considered EXPERIMENTAL and can be changed without a notice
     367                 :            :  *
     368                 :            :  * \since QGIS 3.12
     369                 :            :  */
     370                 :          0 : class CORE_EXPORT QgsMeshRendererVectorTracesSettings
     371                 :            : {
     372                 :            :   public:
     373                 :            : 
     374                 :            :     //! Returns the maximum tail length
     375                 :            :     double maximumTailLength() const;
     376                 :            :     //! Sets the maximums tail length
     377                 :            :     void setMaximumTailLength( double maximumTailLength );
     378                 :            :     //! Returns particles count
     379                 :            :     int particlesCount() const;
     380                 :            :     //! Sets particles count
     381                 :            :     void setParticlesCount( int value );
     382                 :            :     //! Returns the maximum tail length unit
     383                 :            :     QgsUnitTypes::RenderUnit maximumTailLengthUnit() const;
     384                 :            :     //! Sets the maximum tail length unit
     385                 :            :     void setMaximumTailLengthUnit( const QgsUnitTypes::RenderUnit &maximumTailLengthUnit );
     386                 :            : 
     387                 :            :     //! Reads configuration from the given DOM element
     388                 :            :     void readXml( const QDomElement &elem );
     389                 :            :     //! Writes configuration to a new DOM element
     390                 :            :     QDomElement writeXml( QDomDocument &doc ) const;
     391                 :            : 
     392                 :            : 
     393                 :            : 
     394                 :            :   private:
     395                 :          0 :     int mParticlesCount = 1000;
     396                 :          0 :     double mMaximumTailLength = 100;
     397                 :          0 :     QgsUnitTypes::RenderUnit mMaximumTailLengthUnit = QgsUnitTypes::RenderMillimeters;
     398                 :            : 
     399                 :            : };
     400                 :            : 
     401                 :            : /**
     402                 :            :  * \ingroup core
     403                 :            :  *
     404                 :            :  * \brief Represents a renderer settings for vector datasets
     405                 :            :  *
     406                 :            :  * \note The API is considered EXPERIMENTAL and can be changed without a notice
     407                 :            :  *
     408                 :            :  * \since QGIS 3.2
     409                 :            :  */
     410                 :          0 : class CORE_EXPORT QgsMeshRendererVectorSettings
     411                 :            : {
     412                 :            :   public:
     413                 :            : 
     414                 :            :     /**
     415                 :            :      * Defines the symbology of vector rendering
     416                 :            :      * \since QGIS 3.12
     417                 :            :      */
     418                 :            :     enum Symbology
     419                 :            :     {
     420                 :            :       //! Displaying vector dataset with arrows
     421                 :            :       Arrows = 0,
     422                 :            :       //! Displaying vector dataset with streamlines
     423                 :            :       Streamlines,
     424                 :            :       //! Displaying vector dataset with particle traces
     425                 :            :       Traces
     426                 :            :     };
     427                 :            : 
     428                 :            :     //! Returns line width of the arrow (in millimeters)
     429                 :            :     double lineWidth() const;
     430                 :            :     //! Sets line width of the arrow in pixels (in millimeters)
     431                 :            :     void setLineWidth( double lineWidth );
     432                 :            : 
     433                 :            :     //! Returns color used for drawing arrows
     434                 :            :     QColor color() const;
     435                 :            :     //! Sets color used for drawing arrows
     436                 :            :     void setColor( const QColor &color );
     437                 :            : 
     438                 :            :     /**
     439                 :            :      * Returns filter value for vector magnitudes.
     440                 :            :      *
     441                 :            :      * If magnitude of the vector is lower than this value, the vector is not
     442                 :            :      * drawn. -1 represents that filtering is not active.
     443                 :            :      */
     444                 :            :     double filterMin() const;
     445                 :            : 
     446                 :            :     /**
     447                 :            :      * Sets filter value for vector magnitudes.
     448                 :            :      * \see filterMin()
     449                 :            :      */
     450                 :            :     void setFilterMin( double filterMin );
     451                 :            : 
     452                 :            :     /**
     453                 :            :      * Returns filter value for vector magnitudes.
     454                 :            :      *
     455                 :            :      * If magnitude of the vector is higher than this value, the vector is not
     456                 :            :      * drawn. -1 represents that filtering is not active.
     457                 :            :      */
     458                 :            :     double filterMax() const;
     459                 :            : 
     460                 :            :     /**
     461                 :            :      * Sets filter value for vector magnitudes.
     462                 :            :      * \see filterMax()
     463                 :            :      */
     464                 :            :     void setFilterMax( double filterMax );
     465                 :            : 
     466                 :            :     //! Returns whether vectors are drawn on user-defined grid
     467                 :            :     bool isOnUserDefinedGrid() const;
     468                 :            :     //! Toggles drawing of vectors on user defined grid
     469                 :            :     void setOnUserDefinedGrid( bool enabled );
     470                 :            :     //! Returns width in pixels of user grid cell
     471                 :            :     int userGridCellWidth() const;
     472                 :            :     //! Sets width of user grid cell (in pixels)
     473                 :            :     void setUserGridCellWidth( int width );
     474                 :            :     //! Returns height in pixels of user grid cell
     475                 :            :     int userGridCellHeight() const;
     476                 :            :     //! Sets height of user grid cell (in pixels)
     477                 :            :     void setUserGridCellHeight( int height );
     478                 :            : 
     479                 :            :     /**
     480                 :            :     * Returns the displaying method used to render vector datasets
     481                 :            :     * \since QGIS 3.12
     482                 :            :     */
     483                 :            :     Symbology symbology() const;
     484                 :            : 
     485                 :            :     /**
     486                 :            :      * Sets the displaying method used to render vector datasets
     487                 :            :      * \since QGIS 3.12
     488                 :            :      */
     489                 :            :     void setSymbology( const Symbology &symbology );
     490                 :            : 
     491                 :            :     /**
     492                 :            :      * Returns the coloring method used to render vector datasets
     493                 :            :      * \since QGIS 3.14
     494                 :            :      */
     495                 :            :     QgsInterpolatedLineColor::ColoringMethod coloringMethod() const;
     496                 :            : 
     497                 :            :     /**
     498                 :            :      * Sets the coloring method used to render vector datasets
     499                 :            :      * \since QGIS 3.14
     500                 :            :      */
     501                 :            :     void setColoringMethod( const QgsInterpolatedLineColor::ColoringMethod &coloringMethod );
     502                 :            : 
     503                 :            :     /**
     504                 :            :      * Sets the color ramp shader used to render vector datasets
     505                 :            :      * \since QGIS 3.14
     506                 :            :      */
     507                 :            :     QgsColorRampShader colorRampShader() const;
     508                 :            : 
     509                 :            :     /**
     510                 :            :      * Returns the color ramp shader used to render vector datasets
     511                 :            :      * \since QGIS 3.14
     512                 :            :      */
     513                 :            :     void setColorRampShader( const QgsColorRampShader &colorRampShader );
     514                 :            : 
     515                 :            :     /**
     516                 :            :      * Returns the stroke coloring used to render vector datasets
     517                 :            :      * \since QGIS 3.14
     518                 :            :      */
     519                 :            :     QgsInterpolatedLineColor vectorStrokeColoring() const;
     520                 :            : 
     521                 :            :     /**
     522                 :            :     * Returns settings for vector rendered with arrows
     523                 :            :     * \since QGIS 3.12
     524                 :            :     */
     525                 :            :     QgsMeshRendererVectorArrowSettings arrowSettings() const;
     526                 :            : 
     527                 :            :     /**
     528                 :            :      * Sets settings for vector rendered with arrows
     529                 :            :      * \since QGIS 3.12
     530                 :            :      */
     531                 :            :     void setArrowsSettings( const QgsMeshRendererVectorArrowSettings &arrowSettings );
     532                 :            : 
     533                 :            :     /**
     534                 :            :      * Returns settings for vector rendered with streamlines
     535                 :            :      * \since QGIS 3.12
     536                 :            :      */
     537                 :            :     QgsMeshRendererVectorStreamlineSettings streamLinesSettings() const;
     538                 :            : 
     539                 :            :     /**
     540                 :            :      * Sets settings for vector rendered with streamlines
     541                 :            :      * \since QGIS 3.12
     542                 :            :      */
     543                 :            :     void setStreamLinesSettings( const QgsMeshRendererVectorStreamlineSettings &streamLinesSettings );
     544                 :            : 
     545                 :            :     /**
     546                 :            :      * Returns settings for vector rendered with traces
     547                 :            :      * \since QGIS 3.12
     548                 :            :      */
     549                 :            :     QgsMeshRendererVectorTracesSettings tracesSettings() const;
     550                 :            : 
     551                 :            :     /**
     552                 :            :      * Sets settings for vector rendered with traces
     553                 :            :      * \since QGIS 3.12
     554                 :            :      */
     555                 :            :     void setTracesSettings( const QgsMeshRendererVectorTracesSettings &tracesSettings );
     556                 :            : 
     557                 :            :     //! Writes configuration to a new DOM element
     558                 :            :     QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context = QgsReadWriteContext() ) const;
     559                 :            :     //! Reads configuration from the given DOM element
     560                 :            :     void readXml( const QDomElement &elem, const QgsReadWriteContext &context = QgsReadWriteContext() );
     561                 :            : 
     562                 :            :   private:
     563                 :            : 
     564                 :          0 :     Symbology mDisplayingMethod = Arrows;
     565                 :            : 
     566                 :          0 :     double mLineWidth = DEFAULT_LINE_WIDTH; //in millimeters
     567                 :            :     QgsColorRampShader mColorRampShader;
     568                 :          0 :     QColor mColor = Qt::black;
     569                 :          0 :     QgsInterpolatedLineColor::ColoringMethod mColoringMethod = QgsInterpolatedLineColor::SingleColor;
     570                 :          0 :     double mFilterMin = -1; //disabled
     571                 :          0 :     double mFilterMax = -1; //disabled
     572                 :          0 :     int mUserGridCellWidth = 10; // in pixels
     573                 :          0 :     int mUserGridCellHeight = 10; // in pixels
     574                 :          0 :     bool mOnUserDefinedGrid = false;
     575                 :            : 
     576                 :            :     QgsMeshRendererVectorArrowSettings mArrowsSettings;
     577                 :            :     QgsMeshRendererVectorStreamlineSettings mStreamLinesSettings;
     578                 :            :     QgsMeshRendererVectorTracesSettings mTracesSettings;
     579                 :            : };
     580                 :            : 
     581                 :            : /**
     582                 :            :  * \ingroup core
     583                 :            :  *
     584                 :            :  * \brief Represents all mesh renderer settings
     585                 :            :  *
     586                 :            :  * \note The API is considered EXPERIMENTAL and can be changed without a notice
     587                 :            :  *
     588                 :            :  * \since QGIS 3.4
     589                 :            :  */
     590                 :          0 : class CORE_EXPORT QgsMeshRendererSettings
     591                 :            : {
     592                 :            :   public:
     593                 :            : 
     594                 :            :     /**
     595                 :            :      * Constructs renderer with default single layer averaging method
     596                 :            :      */
     597                 :            :     QgsMeshRendererSettings();
     598                 :            :     //! Destructor
     599                 :            :     ~QgsMeshRendererSettings();
     600                 :            : 
     601                 :            :     //! Returns native mesh renderer settings
     602                 :          0 :     QgsMeshRendererMeshSettings nativeMeshSettings() const { return mRendererNativeMeshSettings; }
     603                 :            :     //! Sets new native mesh  renderer settings, triggers repaint
     604                 :          0 :     void setNativeMeshSettings( const QgsMeshRendererMeshSettings &settings ) { mRendererNativeMeshSettings = settings; }
     605                 :            : 
     606                 :            :     //! Returns triangular mesh renderer settings
     607                 :          0 :     QgsMeshRendererMeshSettings triangularMeshSettings() const { return mRendererTriangularMeshSettings; }
     608                 :            :     //! Sets new triangular mesh renderer settings
     609                 :            :     void setTriangularMeshSettings( const QgsMeshRendererMeshSettings &settings ) { mRendererTriangularMeshSettings = settings; }
     610                 :            : 
     611                 :            :     /**
     612                 :            :      * Returns edge mesh renderer settings
     613                 :            :      * \since QGIS 3.14
     614                 :            :      */
     615                 :          0 :     QgsMeshRendererMeshSettings edgeMeshSettings() const { return mRendererEdgeMeshSettings; }
     616                 :            : 
     617                 :            :     /**
     618                 :            :      * Sets new edge mesh renderer settings
     619                 :            :      * \since QGIS 3.14
     620                 :            :      */
     621                 :            :     void setEdgeMeshSettings( const QgsMeshRendererMeshSettings &settings ) { mRendererEdgeMeshSettings = settings; }
     622                 :            : 
     623                 :            :     //! Returns renderer settings
     624                 :          0 :     QgsMeshRendererScalarSettings scalarSettings( int groupIndex ) const { return mRendererScalarSettings.value( groupIndex ); }
     625                 :            :     //! Sets new renderer settings
     626                 :          0 :     void setScalarSettings( int groupIndex, const QgsMeshRendererScalarSettings &settings ) { mRendererScalarSettings[groupIndex] = settings; }
     627                 :            : 
     628                 :            :     //! Returns renderer settings
     629                 :          0 :     QgsMeshRendererVectorSettings vectorSettings( int groupIndex ) const { return mRendererVectorSettings.value( groupIndex ); }
     630                 :            :     //! Sets new renderer settings
     631                 :          0 :     void setVectorSettings( int groupIndex, const QgsMeshRendererVectorSettings &settings ) { mRendererVectorSettings[groupIndex] = settings; }
     632                 :            : 
     633                 :            :     /**
     634                 :            :      * Returns averaging method for conversion of 3d stacked mesh data to 2d data
     635                 :            :      *
     636                 :            :      * Caller does not own the resulting pointer
     637                 :            :      */
     638                 :            :     QgsMesh3dAveragingMethod *averagingMethod() const;
     639                 :            : 
     640                 :            :     /**
     641                 :            :      * Sets averaging method for conversion of 3d stacked mesh data to 2d data
     642                 :            :      *
     643                 :            :      * Ownership of the method is not transferred.
     644                 :            :      */
     645                 :            :     void setAveragingMethod( QgsMesh3dAveragingMethod *method );
     646                 :            : 
     647                 :            :     //! Writes configuration to a new DOM element
     648                 :            :     QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context = QgsReadWriteContext() ) const;
     649                 :            :     //! Reads configuration from the given DOM element
     650                 :            :     void readXml( const QDomElement &elem, const QgsReadWriteContext &context = QgsReadWriteContext() );
     651                 :            : 
     652                 :            :     /**
     653                 :            :      * Returns the active scalar dataset group
     654                 :            :      * \since QGIS 3.14
     655                 :            :      */
     656                 :            :     int activeScalarDatasetGroup() const;
     657                 :            : 
     658                 :            :     /**
     659                 :            :      * Sets the active scalar dataset group
     660                 :            :      * \since QGIS 3.14
     661                 :            :      */
     662                 :            :     void setActiveScalarDatasetGroup( int activeScalarDatasetGroup );
     663                 :            : 
     664                 :            :     /**
     665                 :            :      * Returns the active vector dataset group
     666                 :            :      * \since QGIS 3.14
     667                 :            :      */
     668                 :            :     int activeVectorDatasetGroup() const;
     669                 :            : 
     670                 :            :     /**
     671                 :            :      * Sets the active vector dataset group
     672                 :            :      * \since QGIS 3.14
     673                 :            :      */
     674                 :            :     void setActiveVectorDatasetGroup( int activeVectorDatasetGroup );
     675                 :            : 
     676                 :            :   private:
     677                 :            :     QgsMeshRendererMeshSettings mRendererNativeMeshSettings;
     678                 :            :     QgsMeshRendererMeshSettings mRendererTriangularMeshSettings;
     679                 :            :     QgsMeshRendererMeshSettings mRendererEdgeMeshSettings;
     680                 :            : 
     681                 :            :     QHash<int, QgsMeshRendererScalarSettings> mRendererScalarSettings;  //!< Per-group scalar settings
     682                 :            :     QHash<int, QgsMeshRendererVectorSettings> mRendererVectorSettings;  //!< Per-group vector settings
     683                 :            : 
     684                 :            :     //! index of active scalar dataset group
     685                 :            :     int mActiveScalarDatasetGroup = -1;
     686                 :            : 
     687                 :            :     //! index of active vector dataset group
     688                 :            :     int mActiveVectorDatasetGroup = -1;
     689                 :            : 
     690                 :            :     //! Averaging method to get 2D datasets from 3D stacked mesh datasets
     691                 :            :     std::shared_ptr<QgsMesh3dAveragingMethod> mAveragingMethod;
     692                 :            : };
     693                 :            : 
     694                 :            : #endif //QGSMESHRENDERERSETTINGS_H