QGIS API Documentation  3.23.0-Master (eb871beae0)
qgsmeshrenderersettings.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsmeshrenderersettings.cpp
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 
19 #include "qgssymbollayerutils.h"
20 #include "qgsunittypes.h"
21 
23 {
24  return mEnabled;
25 }
26 
28 {
29  mEnabled = on;
30 }
31 
33 {
34  return mLineWidth;
35 }
36 
38 {
39  mLineWidth = lineWidth;
40 }
41 
43 {
44  return mColor;
45 }
46 
47 void QgsMeshRendererMeshSettings::setColor( const QColor &color )
48 {
49  mColor = color;
50 }
51 
53 {
54  return mLineWidthUnit;
55 }
56 
58 {
59  mLineWidthUnit = lineWidthUnit;
60 }
61 
62 QDomElement QgsMeshRendererMeshSettings::writeXml( QDomDocument &doc ) const
63 {
64  QDomElement elem = doc.createElement( QStringLiteral( "mesh-settings" ) );
65  elem.setAttribute( QStringLiteral( "enabled" ), mEnabled ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
66  elem.setAttribute( QStringLiteral( "line-width" ), mLineWidth );
67  elem.setAttribute( QStringLiteral( "color" ), QgsSymbolLayerUtils::encodeColor( mColor ) );
68  elem.setAttribute( QStringLiteral( "line-width-unit" ), QgsUnitTypes::encodeUnit( mLineWidthUnit ) );
69  return elem;
70 }
71 
72 void QgsMeshRendererMeshSettings::readXml( const QDomElement &elem )
73 {
74  mEnabled = elem.attribute( QStringLiteral( "enabled" ) ).toInt();
75  mLineWidth = elem.attribute( QStringLiteral( "line-width" ) ).toDouble();
76  mColor = QgsSymbolLayerUtils::decodeColor( elem.attribute( QStringLiteral( "color" ) ) );
77  mLineWidthUnit = QgsUnitTypes::decodeRenderUnit( elem.attribute( QStringLiteral( "line-width-unit" ) ) );
78 }
79 // ---------------------------------------------------------------------
80 
82 {
83  return mColorRampShader;
84 }
85 
87 {
88  mColorRampShader = shader;
89 }
90 
91 double QgsMeshRendererScalarSettings::classificationMinimum() const { return mClassificationMinimum; }
92 
93 double QgsMeshRendererScalarSettings::classificationMaximum() const { return mClassificationMaximum; }
94 
96 {
97  mClassificationMinimum = minimum;
98  mClassificationMaximum = maximum;
99 }
100 
101 double QgsMeshRendererScalarSettings::opacity() const { return mOpacity; }
102 
103 void QgsMeshRendererScalarSettings::setOpacity( double opacity ) { mOpacity = opacity; }
104 
106 {
107  return mDataResamplingMethod;
108 }
109 
111 {
112  mDataResamplingMethod = dataInterpolationMethod;
113 }
114 
115 QDomElement QgsMeshRendererScalarSettings::writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const
116 {
117  QDomElement elem = doc.createElement( QStringLiteral( "scalar-settings" ) );
118  elem.setAttribute( QStringLiteral( "min-val" ), mClassificationMinimum );
119  elem.setAttribute( QStringLiteral( "max-val" ), mClassificationMaximum );
120  elem.setAttribute( QStringLiteral( "opacity" ), mOpacity );
121 
122  QString methodTxt;
123  switch ( mDataResamplingMethod )
124  {
125  case None:
126  methodTxt = QStringLiteral( "none" );
127  break;
128  case NeighbourAverage:
129  methodTxt = QStringLiteral( "neighbour-average" );
130  break;
131  }
132  elem.setAttribute( QStringLiteral( "interpolation-method" ), methodTxt );
133  const QDomElement elemShader = mColorRampShader.writeXml( doc, context );
134  elem.appendChild( elemShader );
135 
136  QDomElement elemEdge = doc.createElement( QStringLiteral( "edge-settings" ) );
137  elemEdge.appendChild( mEdgeStrokeWidth.writeXml( doc, context ) );
138  elemEdge.setAttribute( QStringLiteral( "stroke-width-unit" ), mEdgeStrokeWidthUnit );
139  elem.appendChild( elemEdge );
140 
141  return elem;
142 }
143 
144 void QgsMeshRendererScalarSettings::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
145 {
146  mClassificationMinimum = elem.attribute( QStringLiteral( "min-val" ) ).toDouble();
147  mClassificationMaximum = elem.attribute( QStringLiteral( "max-val" ) ).toDouble();
148  mOpacity = elem.attribute( QStringLiteral( "opacity" ) ).toDouble();
149 
150  const QString methodTxt = elem.attribute( QStringLiteral( "interpolation-method" ) );
151  if ( QStringLiteral( "neighbour-average" ) == methodTxt )
152  {
153  mDataResamplingMethod = DataResamplingMethod::NeighbourAverage;
154  }
155  else
156  {
157  mDataResamplingMethod = DataResamplingMethod::None;
158  }
159  const QDomElement elemShader = elem.firstChildElement( QStringLiteral( "colorrampshader" ) );
160  mColorRampShader.readXml( elemShader, context );
161 
162  const QDomElement elemEdge = elem.firstChildElement( QStringLiteral( "edge-settings" ) );
163  const QDomElement elemEdgeStrokeWidth = elemEdge.firstChildElement( QStringLiteral( "mesh-stroke-width" ) );
164  mEdgeStrokeWidth.readXml( elemEdgeStrokeWidth, context );
165  mEdgeStrokeWidthUnit = static_cast<QgsUnitTypes::RenderUnit>(
166  elemEdge.attribute( QStringLiteral( "stroke-width-unit" ) ).toInt() );
167 }
168 
170 {
171  return mEdgeStrokeWidth;
172 }
173 
175 {
176  mEdgeStrokeWidth = strokeWidth;
177 }
178 
180 {
181  return mEdgeStrokeWidthUnit;
182 }
183 
185 {
186  mEdgeStrokeWidthUnit = edgeStrokeWidthUnit;
187 }
188 
189 // ---------------------------------------------------------------------
190 
192 {
193  return mLineWidth;
194 }
195 
197 {
198  mLineWidth = lineWidth;
199 }
200 
202 {
203  return mColor;
204 }
205 
206 void QgsMeshRendererVectorSettings::setColor( const QColor &vectorColor )
207 {
208  mColor = vectorColor;
209 }
210 
212 {
213  return mFilterMin;
214 }
215 
216 void QgsMeshRendererVectorSettings::setFilterMin( double vectorFilterMin )
217 {
218  mFilterMin = vectorFilterMin;
219 }
220 
222 {
223  return mFilterMax;
224 }
225 
226 void QgsMeshRendererVectorSettings::setFilterMax( double vectorFilterMax )
227 {
228  mFilterMax = vectorFilterMax;
229 }
230 
232 {
233  return mOnUserDefinedGrid;
234 }
235 
237 {
238  mOnUserDefinedGrid = enabled;
239 }
240 
242 {
243  return mUserGridCellWidth;
244 }
245 
247 {
248  mUserGridCellWidth = width;
249 }
250 
252 {
253  return mUserGridCellHeight;
254 }
255 
257 {
258  mUserGridCellHeight = height;
259 }
260 
262 {
263  return mShaftLengthMethod;
264 }
265 
267 {
268  mShaftLengthMethod = shaftLengthMethod;
269 }
270 
272 {
273  return mMinShaftLength;
274 }
275 
277 {
278  mMinShaftLength = minShaftLength;
279 }
280 
282 {
283  return mMaxShaftLength;
284 }
285 
287 {
288  mMaxShaftLength = maxShaftLength;
289 }
290 
292 {
293  return mScaleFactor;
294 }
295 
297 {
298  mScaleFactor = scaleFactor;
299 }
300 
302 {
303  return mFixedShaftLength;
304 }
305 
307 {
308  mFixedShaftLength = fixedShaftLength;
309 }
310 
312 {
313  return mArrowHeadWidthRatio;
314 }
315 
317 {
318  mArrowHeadWidthRatio = vectorHeadWidthRatio;
319 }
320 
322 {
323  return mArrowHeadLengthRatio;
324 }
325 
327 {
328  mArrowHeadLengthRatio = vectorHeadLengthRatio;
329 }
330 
331 QDomElement QgsMeshRendererVectorArrowSettings::writeXml( QDomDocument &doc ) const
332 {
333  QDomElement elem = doc.createElement( QStringLiteral( "vector-arrow-settings" ) );
334  elem.setAttribute( QStringLiteral( "arrow-head-width-ratio" ), mArrowHeadWidthRatio );
335  elem.setAttribute( QStringLiteral( "arrow-head-length-ratio" ), mArrowHeadLengthRatio );
336 
337  QDomElement elemShaft = doc.createElement( QStringLiteral( "shaft-length" ) );
338  QString methodTxt;
339  switch ( mShaftLengthMethod )
340  {
341  case MinMax:
342  methodTxt = QStringLiteral( "minmax" );
343  elemShaft.setAttribute( QStringLiteral( "min" ), mMinShaftLength );
344  elemShaft.setAttribute( QStringLiteral( "max" ), mMaxShaftLength );
345  break;
346  case Scaled:
347  methodTxt = QStringLiteral( "scaled" );
348  elemShaft.setAttribute( QStringLiteral( "scale-factor" ), mScaleFactor );
349  break;
350  case Fixed:
351  methodTxt = QStringLiteral( "fixed" ) ;
352  elemShaft.setAttribute( QStringLiteral( "fixed-length" ), mFixedShaftLength );
353  break;
354  }
355  elemShaft.setAttribute( QStringLiteral( "method" ), methodTxt );
356  elem.appendChild( elemShaft );
357  return elem;
358 }
359 
360 void QgsMeshRendererVectorArrowSettings::readXml( const QDomElement &elem )
361 {
362  mArrowHeadWidthRatio = elem.attribute( QStringLiteral( "arrow-head-width-ratio" ) ).toDouble();
363  mArrowHeadLengthRatio = elem.attribute( QStringLiteral( "arrow-head-length-ratio" ) ).toDouble();
364 
365  const QDomElement elemShaft = elem.firstChildElement( QStringLiteral( "shaft-length" ) );
366  const QString methodTxt = elemShaft.attribute( QStringLiteral( "method" ) );
367  if ( QStringLiteral( "minmax" ) == methodTxt )
368  {
369  mShaftLengthMethod = MinMax;
370  mMinShaftLength = elemShaft.attribute( QStringLiteral( "min" ) ).toDouble();
371  mMaxShaftLength = elemShaft.attribute( QStringLiteral( "max" ) ).toDouble();
372  }
373  else if ( QStringLiteral( "scaled" ) == methodTxt )
374  {
375  mShaftLengthMethod = Scaled;
376  mScaleFactor = elemShaft.attribute( QStringLiteral( "scale-factor" ) ).toDouble();
377  }
378  else // fixed
379  {
380  mShaftLengthMethod = Fixed;
381  mFixedShaftLength = elemShaft.attribute( QStringLiteral( "fixed-length" ) ).toDouble();
382  }
383 }
384 
385 // ---------------------------------------------------------------------
386 
388  : mAveragingMethod( new QgsMeshMultiLevelsAveragingMethod() )
389 {
390 }
391 
393 
395 {
396  return mAveragingMethod.get();
397 }
398 
400 {
401  if ( method )
402  mAveragingMethod.reset( method->clone() );
403  else
404  mAveragingMethod.reset();
405 }
406 
407 QDomElement QgsMeshRendererSettings::writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const
408 {
409  QDomElement elem = doc.createElement( QStringLiteral( "mesh-renderer-settings" ) );
410 
411  QDomElement elemActiveDatasetGroup = doc.createElement( QStringLiteral( "active-dataset-group" ) );
412  elemActiveDatasetGroup.setAttribute( QStringLiteral( "scalar" ), mActiveScalarDatasetGroup );
413  elemActiveDatasetGroup.setAttribute( QStringLiteral( "vector" ), mActiveVectorDatasetGroup );
414  elem.appendChild( elemActiveDatasetGroup );
415 
416  for ( const int groupIndex : mRendererScalarSettings.keys() )
417  {
418  const QgsMeshRendererScalarSettings &scalarSettings = mRendererScalarSettings[groupIndex];
419  QDomElement elemScalar = scalarSettings.writeXml( doc, context );
420  elemScalar.setAttribute( QStringLiteral( "group" ), groupIndex );
421  elem.appendChild( elemScalar );
422  }
423 
424  for ( const int groupIndex : mRendererVectorSettings.keys() )
425  {
426  const QgsMeshRendererVectorSettings &vectorSettings = mRendererVectorSettings[groupIndex];
427  QDomElement elemVector = vectorSettings.writeXml( doc, context );
428  elemVector.setAttribute( QStringLiteral( "group" ), groupIndex );
429  elem.appendChild( elemVector );
430  }
431 
432  QDomElement elemNativeMesh = mRendererNativeMeshSettings.writeXml( doc );
433  elemNativeMesh.setTagName( QStringLiteral( "mesh-settings-native" ) );
434  elem.appendChild( elemNativeMesh );
435 
436  QDomElement elemEdgeMesh = mRendererEdgeMeshSettings.writeXml( doc );
437  elemEdgeMesh.setTagName( QStringLiteral( "mesh-settings-edge" ) );
438  elem.appendChild( elemEdgeMesh );
439 
440  QDomElement elemTriangularMesh = mRendererTriangularMeshSettings.writeXml( doc );
441  elemTriangularMesh.setTagName( QStringLiteral( "mesh-settings-triangular" ) );
442  elem.appendChild( elemTriangularMesh );
443 
444  if ( mAveragingMethod )
445  {
446  QDomElement elemAveraging = doc.createElement( QStringLiteral( "averaging-3d" ) );
447  elemAveraging.setAttribute( QStringLiteral( "method" ), QString::number( mAveragingMethod->method() ) ) ;
448  const QDomElement elemAveragingParams = mAveragingMethod->writeXml( doc );
449  elemAveraging.appendChild( elemAveragingParams );
450  elem.appendChild( elemAveraging );
451  }
452 
453  return elem;
454 }
455 
456 void QgsMeshRendererSettings::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
457 {
458  mRendererScalarSettings.clear();
459  mRendererVectorSettings.clear();
460  mAveragingMethod.reset();
461 
462  const QDomElement elemActiveDataset = elem.firstChildElement( QStringLiteral( "active-dataset-group" ) );
463  if ( elemActiveDataset.hasAttribute( QStringLiteral( "scalar" ) ) )
464  mActiveScalarDatasetGroup = elemActiveDataset.attribute( QStringLiteral( "scalar" ) ).toInt();
465 
466  if ( elemActiveDataset.hasAttribute( QStringLiteral( "vector" ) ) )
467  mActiveVectorDatasetGroup = elemActiveDataset.attribute( QStringLiteral( "vector" ) ).toInt();
468 
469  QDomElement elemScalar = elem.firstChildElement( QStringLiteral( "scalar-settings" ) );
470  while ( !elemScalar.isNull() )
471  {
472  const int groupIndex = elemScalar.attribute( QStringLiteral( "group" ) ).toInt();
474  scalarSettings.readXml( elemScalar, context );
475  mRendererScalarSettings.insert( groupIndex, scalarSettings );
476 
477  elemScalar = elemScalar.nextSiblingElement( QStringLiteral( "scalar-settings" ) );
478  }
479 
480  QDomElement elemVector = elem.firstChildElement( QStringLiteral( "vector-settings" ) );
481  while ( !elemVector.isNull() )
482  {
483  const int groupIndex = elemVector.attribute( QStringLiteral( "group" ) ).toInt();
485  vectorSettings.readXml( elemVector, context );
486  mRendererVectorSettings.insert( groupIndex, vectorSettings );
487 
488  elemVector = elemVector.nextSiblingElement( QStringLiteral( "vector-settings" ) );
489  }
490 
491  const QDomElement elemNativeMesh = elem.firstChildElement( QStringLiteral( "mesh-settings-native" ) );
492  mRendererNativeMeshSettings.readXml( elemNativeMesh );
493 
494  const QDomElement elemEdgeMesh = elem.firstChildElement( QStringLiteral( "mesh-settings-edge" ) );
495  mRendererEdgeMeshSettings.readXml( elemEdgeMesh );
496 
497  const QDomElement elemTriangularMesh = elem.firstChildElement( QStringLiteral( "mesh-settings-triangular" ) );
498  mRendererTriangularMeshSettings.readXml( elemTriangularMesh );
499 
500  const QDomElement elemAveraging = elem.firstChildElement( QStringLiteral( "averaging-3d" ) );
501  if ( !elemAveraging.isNull() )
502  {
503  mAveragingMethod.reset( QgsMesh3dAveragingMethod::createFromXml( elemAveraging ) );
504  }
505 }
506 
508 {
509  return mActiveScalarDatasetGroup;
510 }
511 
512 void QgsMeshRendererSettings::setActiveScalarDatasetGroup( int activeScalarDatasetGroup )
513 {
514  mActiveScalarDatasetGroup = activeScalarDatasetGroup;
515 }
516 
518 {
519  return mActiveVectorDatasetGroup;
520 }
521 
522 void QgsMeshRendererSettings::setActiveVectorDatasetGroup( int activeVectorDatasetGroup )
523 {
524  mActiveVectorDatasetGroup = activeVectorDatasetGroup;
525 }
526 
528 {
529  return mSeedingMethod;
530 }
531 
533 {
534  mSeedingMethod = seedingMethod;
535 }
536 
538 {
539  return mSeedingDensity;
540 }
541 
543 {
544  mSeedingDensity = seedingDensity;
545 }
546 
547 QDomElement QgsMeshRendererVectorStreamlineSettings::writeXml( QDomDocument &doc ) const
548 {
549  QDomElement elem = doc.createElement( QStringLiteral( "vector-streamline-settings" ) );
550 
551  elem.setAttribute( QStringLiteral( "seeding-method" ), mSeedingMethod );
552  elem.setAttribute( QStringLiteral( "seeding-density" ), mSeedingDensity );
553 
554  return elem;
555 }
556 
558 {
559  mSeedingMethod =
561  elem.attribute( QStringLiteral( "seeding-method" ) ).toInt() );
562  mSeedingDensity = elem.attribute( QStringLiteral( "seeding-density" ) ).toDouble();
563 }
564 
566 {
567  return mDisplayingMethod;
568 }
569 
571 {
572  mDisplayingMethod = displayingMethod;
573 }
574 
576 {
577  return mArrowsSettings;
578 }
579 
581 {
582  mArrowsSettings = arrowSettings;
583 }
584 
586 {
587  return mStreamLinesSettings;
588 }
589 
591 {
592  mStreamLinesSettings = streamLinesSettings;
593 }
594 
595 QDomElement QgsMeshRendererVectorSettings::writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const
596 {
597  QDomElement elem = doc.createElement( QStringLiteral( "vector-settings" ) );
598  elem.setAttribute( QStringLiteral( "symbology" ), mDisplayingMethod );
599 
600  elem.setAttribute( QStringLiteral( "line-width" ), mLineWidth );
601  elem.setAttribute( QStringLiteral( "coloring-method" ), coloringMethod() );
602  elem.setAttribute( QStringLiteral( "color" ), QgsSymbolLayerUtils::encodeColor( mColor ) );
603  const QDomElement elemShader = mColorRampShader.writeXml( doc, context );
604  elem.appendChild( elemShader );
605  elem.setAttribute( QStringLiteral( "filter-min" ), mFilterMin );
606  elem.setAttribute( QStringLiteral( "filter-max" ), mFilterMax );
607 
608  elem.setAttribute( QStringLiteral( "user-grid-enabled" ), mOnUserDefinedGrid ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
609  elem.setAttribute( QStringLiteral( "user-grid-width" ), mUserGridCellWidth );
610  elem.setAttribute( QStringLiteral( "user-grid-height" ), mUserGridCellHeight );
611 
612  elem.appendChild( mArrowsSettings.writeXml( doc ) );
613  elem.appendChild( mStreamLinesSettings.writeXml( doc ) );
614  elem.appendChild( mTracesSettings.writeXml( doc ) );
615 
616  return elem;
617 }
618 
619 void QgsMeshRendererVectorSettings::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
620 {
621  mDisplayingMethod = static_cast<QgsMeshRendererVectorSettings::Symbology>(
622  elem.attribute( QStringLiteral( "symbology" ) ).toInt() );
623 
624  mLineWidth = elem.attribute( QStringLiteral( "line-width" ) ).toDouble();
625  mColoringMethod = static_cast<QgsInterpolatedLineColor::ColoringMethod>(
626  elem.attribute( QStringLiteral( "coloring-method" ) ).toInt() );
627  mColor = QgsSymbolLayerUtils::decodeColor( elem.attribute( QStringLiteral( "color" ) ) );
628  mColorRampShader.readXml( elem.firstChildElement( "colorrampshader" ), context );
629  mFilterMin = elem.attribute( QStringLiteral( "filter-min" ) ).toDouble();
630  mFilterMax = elem.attribute( QStringLiteral( "filter-max" ) ).toDouble();
631 
632  mOnUserDefinedGrid = elem.attribute( QStringLiteral( "user-grid-enabled" ) ).toInt(); //bool
633  mUserGridCellWidth = elem.attribute( QStringLiteral( "user-grid-width" ) ).toInt();
634  mUserGridCellHeight = elem.attribute( QStringLiteral( "user-grid-height" ) ).toInt();
635 
636  const QDomElement elemVector = elem.firstChildElement( QStringLiteral( "vector-arrow-settings" ) );
637  if ( ! elemVector.isNull() )
638  mArrowsSettings.readXml( elemVector );
639 
640  const QDomElement elemStreamLine = elem.firstChildElement( QStringLiteral( "vector-streamline-settings" ) );
641  if ( ! elemStreamLine.isNull() )
642  mStreamLinesSettings.readXml( elemStreamLine );
643 
644  const QDomElement elemTraces = elem.firstChildElement( QStringLiteral( "vector-traces-settings" ) );
645  if ( ! elemTraces.isNull() )
646  mTracesSettings.readXml( elemTraces );
647 }
648 
650 {
651  return mColoringMethod;
652 }
653 
655 {
656  mColoringMethod = coloringMethod;
657 }
658 
660 {
661  return mColorRampShader;
662 }
663 
665 {
666  mColorRampShader = colorRampShader;
667 }
668 
670 {
671  QgsInterpolatedLineColor strokeColoring;
672  switch ( mColoringMethod )
673  {
675  strokeColoring = QgsInterpolatedLineColor( mColor );
676  break;
678  strokeColoring = QgsInterpolatedLineColor( mColorRampShader );
679  break;
680  }
681 
682  return strokeColoring;
683 }
684 
686 {
687  return mTracesSettings;
688 }
689 
691 {
692  mTracesSettings = tracesSettings;
693 }
694 
695 void QgsMeshRendererVectorTracesSettings::readXml( const QDomElement &elem )
696 {
697  mMaximumTailLength = elem.attribute( QStringLiteral( "maximum-tail-length" ) ).toInt();
698  mMaximumTailLengthUnit = static_cast<QgsUnitTypes::RenderUnit>(
699  elem.attribute( QStringLiteral( "maximum-tail-length-unit" ) ).toInt() );
700  mParticlesCount = elem.attribute( QStringLiteral( "particles-count" ) ).toInt();
701 }
702 
703 QDomElement QgsMeshRendererVectorTracesSettings::writeXml( QDomDocument &doc ) const
704 {
705  QDomElement elem = doc.createElement( QStringLiteral( "vector-traces-settings" ) );
706  elem.setAttribute( QStringLiteral( "maximum-tail-length" ), mMaximumTailLength );
707  elem.setAttribute( QStringLiteral( "maximum-tail-length-unit" ), mMaximumTailLengthUnit );
708  elem.setAttribute( QStringLiteral( "particles-count" ), mParticlesCount );
709 
710  return elem;
711 }
712 
714 {
715  return mMaximumTailLengthUnit;
716 }
717 
719 {
720  mMaximumTailLengthUnit = maximumTailLengthUnit;
721 }
722 
724 {
725  return mMaximumTailLength;
726 }
727 
729 {
730  mMaximumTailLength = maximumTailLength;
731 }
732 
734 {
735  return mParticlesCount;
736 }
737 
739 {
740  mParticlesCount = value;
741 }
742 
743 bool QgsMeshRendererSettings::hasSettings( int datasetGroupIndex ) const
744 {
745  return mRendererScalarSettings.contains( datasetGroupIndex ) || mRendererVectorSettings.contains( datasetGroupIndex );
746 }
A ramp shader will color a raster pixel based on a list of values ranges in a ramp.
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context=QgsReadWriteContext()) const
Writes configuration to a new DOM element.
void readXml(const QDomElement &elem, const QgsReadWriteContext &context=QgsReadWriteContext())
Reads configuration from the given DOM element.
Class defining color to render mesh datasets.
ColoringMethod
Defines how the color is defined.
@ ColorRamp
Render with a color ramp.
@ SingleColor
Render with a single color.
Represents a width than can vary depending on values.
void readXml(const QDomElement &elem, const QgsReadWriteContext &context)
Reads configuration from the given DOM element.
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context) const
Writes configuration to a new DOM element.
Abstract class to interpolate 3d stacked mesh data to 2d data.
virtual QgsMesh3dAveragingMethod * clone() const =0
Clone the instance.
static QgsMesh3dAveragingMethod * createFromXml(const QDomElement &elem)
Creates the instance from XML by calling readXml of derived classes.
Multi level averaging method specifies limits of vertical layers from the top layer down or reversed.
void setEnabled(bool enabled)
Sets whether mesh structure rendering is enabled.
void setLineWidthUnit(const QgsUnitTypes::RenderUnit &lineWidthUnit)
Sets units of the width of the mesh frame.
QColor color() const
Returns color used for rendering.
QDomElement writeXml(QDomDocument &doc) const
Writes configuration to a new DOM element.
QgsUnitTypes::RenderUnit lineWidthUnit() const
Returns units of the width of the mesh frame.
double lineWidth() const
Returns line width used for rendering (in millimeters)
void setLineWidth(double lineWidth)
Sets line width used for rendering (in millimeters)
void readXml(const QDomElement &elem)
Reads configuration from the given DOM element.
bool isEnabled() const
Returns whether mesh structure rendering is enabled.
void setColor(const QColor &color)
Sets color used for rendering of the mesh.
Represents a mesh renderer settings for scalar datasets.
void setClassificationMinimumMaximum(double minimum, double maximum)
Sets min/max values used for creation of the color ramp shader.
double opacity() const
Returns opacity.
void readXml(const QDomElement &elem, const QgsReadWriteContext &context=QgsReadWriteContext())
Reads configuration from the given DOM element.
void setColorRampShader(const QgsColorRampShader &shader)
Sets color ramp shader function.
QgsColorRampShader colorRampShader() const
Returns color ramp shader function.
double classificationMinimum() const
Returns min value used for creation of the color ramp shader.
void setOpacity(double opacity)
Sets opacity.
DataResamplingMethod
Resampling of value from dataset.
@ NeighbourAverage
Does a simple average of values defined for all surrounding faces/vertices.
DataResamplingMethod dataResamplingMethod() const
Returns the type of interpolation to use to convert face defined datasets to values on vertices.
void setEdgeStrokeWidthUnit(const QgsUnitTypes::RenderUnit &edgeStrokeWidthUnit)
Sets the stroke width unit used to render edges scalar dataset.
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context=QgsReadWriteContext()) const
Writes configuration to a new DOM element.
void setEdgeStrokeWidth(const QgsInterpolatedLineWidth &strokeWidth)
Sets the stroke width used to render edges scalar dataset.
double classificationMaximum() const
Returns max value used for creation of the color ramp shader.
QgsUnitTypes::RenderUnit edgeStrokeWidthUnit() const
Returns the stroke width unit used to render edges scalar dataset.
QgsInterpolatedLineWidth edgeStrokeWidth() const
Returns the stroke width used to render edges scalar dataset.
void setDataResamplingMethod(const DataResamplingMethod &dataResamplingMethod)
Sets data interpolation method.
void setActiveVectorDatasetGroup(int activeVectorDatasetGroup)
Sets the active vector dataset group.
QgsMeshRendererScalarSettings scalarSettings(int groupIndex) const
Returns renderer settings.
int activeVectorDatasetGroup() const
Returns the active vector dataset group.
bool hasSettings(int datasetGroupIndex) const
Returns whether the group with index has render settings (scalar or vector)
int activeScalarDatasetGroup() const
Returns the active scalar dataset group.
QgsMesh3dAveragingMethod * averagingMethod() const
Returns averaging method for conversion of 3d stacked mesh data to 2d data.
QgsMeshRendererVectorSettings vectorSettings(int groupIndex) const
Returns renderer settings.
void setActiveScalarDatasetGroup(int activeScalarDatasetGroup)
Sets the active scalar dataset group.
void readXml(const QDomElement &elem, const QgsReadWriteContext &context=QgsReadWriteContext())
Reads configuration from the given DOM element.
QgsMeshRendererSettings()
Constructs renderer with default single layer averaging method.
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context=QgsReadWriteContext()) const
Writes configuration to a new DOM element.
void setAveragingMethod(QgsMesh3dAveragingMethod *method)
Sets averaging method for conversion of 3d stacked mesh data to 2d data.
~QgsMeshRendererSettings()
Destructor.
Represents a mesh renderer settings for vector datasets displayed with arrows.
void setFixedShaftLength(double fixedShaftLength)
Sets fixed length (in millimeters)
void setMaxShaftLength(double maxShaftLength)
Sets maximum shaft length (in millimeters)
QgsMeshRendererVectorArrowSettings::ArrowScalingMethod shaftLengthMethod() const
Returns method used for drawing arrows.
void setMinShaftLength(double minShaftLength)
Sets mininimum shaft length (in millimeters)
double fixedShaftLength() const
Returns fixed arrow length (in millimeters)
void setArrowHeadWidthRatio(double arrowHeadWidthRatio)
Sets ratio of the head width of the arrow (range 0-1)
double scaleFactor() const
Returns scale factor.
double maxShaftLength() const
Returns maximum shaft length (in millimeters)
double arrowHeadWidthRatio() const
Returns ratio of the head width of the arrow (range 0-1)
void setArrowHeadLengthRatio(double arrowHeadLengthRatio)
Sets ratio of the head length of the arrow (range 0-1)
void readXml(const QDomElement &elem)
Reads configuration from the given DOM element.
void setScaleFactor(double scaleFactor)
Sets scale factor.
void setShaftLengthMethod(ArrowScalingMethod shaftLengthMethod)
Sets method used for drawing arrows.
ArrowScalingMethod
Algorithm how to transform vector magnitude to length of arrow on the device in pixels.
@ Scaled
Scale vector magnitude by factor scaleFactor()
@ MinMax
Scale vector magnitude linearly to fit in range of vectorFilterMin() and vectorFilterMax()
@ Fixed
Use fixed length fixedShaftLength() regardless of vector's magnitude.
double minShaftLength() const
Returns mininimum shaft length (in millimeters)
QDomElement writeXml(QDomDocument &doc) const
Writes configuration to a new DOM element.
double arrowHeadLengthRatio() const
Returns ratio of the head length of the arrow (range 0-1)
Represents a renderer settings for vector datasets.
void setColorRampShader(const QgsColorRampShader &colorRampShader)
Returns the color ramp shader used to render vector datasets.
void setStreamLinesSettings(const QgsMeshRendererVectorStreamlineSettings &streamLinesSettings)
Sets settings for vector rendered with streamlines.
int userGridCellWidth() const
Returns width in pixels of user grid cell.
void setArrowsSettings(const QgsMeshRendererVectorArrowSettings &arrowSettings)
Sets settings for vector rendered with arrows.
void setUserGridCellWidth(int width)
Sets width of user grid cell (in pixels)
void setColor(const QColor &color)
Sets color used for drawing arrows.
QgsMeshRendererVectorTracesSettings tracesSettings() const
Returns settings for vector rendered with traces.
QColor color() const
Returns color used for drawing arrows.
int userGridCellHeight() const
Returns height in pixels of user grid cell.
void setOnUserDefinedGrid(bool enabled)
Toggles drawing of vectors on user defined grid.
double lineWidth() const
Returns line width of the arrow (in millimeters)
Symbology
Defines the symbology of vector rendering.
void setUserGridCellHeight(int height)
Sets height of user grid cell (in pixels)
Symbology symbology() const
Returns the displaying method used to render vector datasets.
double filterMax() const
Returns filter value for vector magnitudes.
QgsColorRampShader colorRampShader() const
Sets the color ramp shader used to render vector datasets.
void setSymbology(const Symbology &symbology)
Sets the displaying method used to render vector datasets.
void setFilterMin(double filterMin)
Sets filter value for vector magnitudes.
QgsMeshRendererVectorArrowSettings arrowSettings() const
Returns settings for vector rendered with arrows.
void setFilterMax(double filterMax)
Sets filter value for vector magnitudes.
QgsInterpolatedLineColor vectorStrokeColoring() const
Returns the stroke coloring used to render vector datasets.
void setTracesSettings(const QgsMeshRendererVectorTracesSettings &tracesSettings)
Sets settings for vector rendered with traces.
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context=QgsReadWriteContext()) const
Writes configuration to a new DOM element.
void setColoringMethod(const QgsInterpolatedLineColor::ColoringMethod &coloringMethod)
Sets the coloring method used to render vector datasets.
QgsInterpolatedLineColor::ColoringMethod coloringMethod() const
Returns the coloring method used to render vector datasets.
void readXml(const QDomElement &elem, const QgsReadWriteContext &context=QgsReadWriteContext())
Reads configuration from the given DOM element.
void setLineWidth(double lineWidth)
Sets line width of the arrow in pixels (in millimeters)
bool isOnUserDefinedGrid() const
Returns whether vectors are drawn on user-defined grid.
double filterMin() const
Returns filter value for vector magnitudes.
QgsMeshRendererVectorStreamlineSettings streamLinesSettings() const
Returns settings for vector rendered with streamlines.
Represents a streamline renderer settings for vector datasets displayed by streamlines.
void setSeedingDensity(double seedingDensity)
Sets the density used for seeding start points.
SeedingStartPointsMethod seedingMethod() const
Returns the method used for seeding start points of strealines.
void setSeedingMethod(const SeedingStartPointsMethod &seedingMethod)
Sets the method used for seeding start points of strealines.
QDomElement writeXml(QDomDocument &doc) const
Writes configuration to a new DOM element.
SeedingStartPointsMethod
Method used to define start points that are used to draw streamlines.
void readXml(const QDomElement &elem)
Reads configuration from the given DOM element.
double seedingDensity() const
Returns the density used for seeding start points.
Represents a trace renderer settings for vector datasets displayed by particle traces.
void setMaximumTailLength(double maximumTailLength)
Sets the maximums tail length.
QDomElement writeXml(QDomDocument &doc) const
Writes configuration to a new DOM element.
void readXml(const QDomElement &elem)
Reads configuration from the given DOM element.
double maximumTailLength() const
Returns the maximum tail length.
QgsUnitTypes::RenderUnit maximumTailLengthUnit() const
Returns the maximum tail length unit.
int particlesCount() const
Returns particles count.
void setParticlesCount(int value)
Sets particles count.
void setMaximumTailLengthUnit(const QgsUnitTypes::RenderUnit &maximumTailLengthUnit)
Sets the maximum tail length unit.
The class is used as a container of context for various read/write operations on other objects.
static QColor decodeColor(const QString &str)
static QString encodeColor(const QColor &color)
static Q_INVOKABLE QString encodeUnit(QgsUnitTypes::DistanceUnit unit)
Encodes a distance unit to a string.
static Q_INVOKABLE QgsUnitTypes::RenderUnit decodeRenderUnit(const QString &string, bool *ok=nullptr)
Decodes a render unit from a string.
RenderUnit
Rendering size units.
Definition: qgsunittypes.h:168