QGIS API Documentation 3.29.0-Master (19d7edcfed)
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
47void QgsMeshRendererMeshSettings::setColor( const QColor &color )
48{
49 mColor = color;
50}
51
53{
54 return mLineWidthUnit;
55}
56
58{
59 mLineWidthUnit = lineWidthUnit;
60}
61
62QDomElement 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
72void 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
91double QgsMeshRendererScalarSettings::classificationMinimum() const { return mClassificationMinimum; }
92
93double QgsMeshRendererScalarSettings::classificationMaximum() const { return mClassificationMaximum; }
94
96{
97 mClassificationMinimum = minimum;
98 mClassificationMaximum = maximum;
99}
100
101double QgsMeshRendererScalarSettings::opacity() const { return mOpacity; }
102
103void QgsMeshRendererScalarSettings::setOpacity( double opacity ) { mOpacity = opacity; }
104
106{
107 return mDataResamplingMethod;
108}
109
111{
112 mDataResamplingMethod = dataInterpolationMethod;
113}
114
115QDomElement 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
144void 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
206void QgsMeshRendererVectorSettings::setColor( const QColor &vectorColor )
207{
208 mColor = vectorColor;
209}
210
212{
213 return mFilterMin;
214}
215
217{
218 mFilterMin = vectorFilterMin;
219}
220
222{
223 return mFilterMax;
224}
225
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
331QDomElement 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
360void 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 QgsMeshSigmaAveragingMethod() )
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
407QDomElement 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 ( auto groupIndex = mRendererScalarSettings.keyBegin(); groupIndex != mRendererScalarSettings.keyEnd(); groupIndex++ )
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 ( auto groupIndex = mRendererVectorSettings.keyBegin(); groupIndex != mRendererVectorSettings.keyEnd(); groupIndex++ )
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
456void 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
513{
514 mActiveScalarDatasetGroup = activeScalarDatasetGroup;
515}
516
518{
519 return mActiveVectorDatasetGroup;
520}
521
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
547QDomElement 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
595QDomElement 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
619void 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
695void 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
703QDomElement 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
743bool 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.
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.
Sigma averages over the values between 0 (bed level) and 1 (surface).
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