Branch data Line data Source code
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 : :
18 : : #include "qgsmeshrenderersettings.h"
19 : : #include "qgssymbollayerutils.h"
20 : : #include "qgsunittypes.h"
21 : :
22 : 0 : bool QgsMeshRendererMeshSettings::isEnabled() const
23 : : {
24 : 0 : return mEnabled;
25 : : }
26 : :
27 : 0 : void QgsMeshRendererMeshSettings::setEnabled( bool on )
28 : : {
29 : 0 : mEnabled = on;
30 : 0 : }
31 : :
32 : 0 : double QgsMeshRendererMeshSettings::lineWidth() const
33 : : {
34 : 0 : return mLineWidth;
35 : : }
36 : :
37 : 0 : void QgsMeshRendererMeshSettings::setLineWidth( double lineWidth )
38 : : {
39 : 0 : mLineWidth = lineWidth;
40 : 0 : }
41 : :
42 : 0 : QColor QgsMeshRendererMeshSettings::color() const
43 : : {
44 : 0 : return mColor;
45 : : }
46 : :
47 : 0 : void QgsMeshRendererMeshSettings::setColor( const QColor &color )
48 : : {
49 : 0 : mColor = color;
50 : 0 : }
51 : :
52 : 0 : QgsUnitTypes::RenderUnit QgsMeshRendererMeshSettings::lineWidthUnit() const
53 : : {
54 : 0 : return mLineWidthUnit;
55 : : }
56 : :
57 : 0 : void QgsMeshRendererMeshSettings::setLineWidthUnit( const QgsUnitTypes::RenderUnit &lineWidthUnit )
58 : : {
59 : 0 : mLineWidthUnit = lineWidthUnit;
60 : 0 : }
61 : :
62 : 0 : QDomElement QgsMeshRendererMeshSettings::writeXml( QDomDocument &doc ) const
63 : : {
64 : 0 : QDomElement elem = doc.createElement( QStringLiteral( "mesh-settings" ) );
65 : 0 : elem.setAttribute( QStringLiteral( "enabled" ), mEnabled ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
66 : 0 : elem.setAttribute( QStringLiteral( "line-width" ), mLineWidth );
67 : 0 : elem.setAttribute( QStringLiteral( "color" ), QgsSymbolLayerUtils::encodeColor( mColor ) );
68 : 0 : elem.setAttribute( QStringLiteral( "line-width-unit" ), QgsUnitTypes::encodeUnit( mLineWidthUnit ) );
69 : 0 : return elem;
70 : 0 : }
71 : :
72 : 0 : void QgsMeshRendererMeshSettings::readXml( const QDomElement &elem )
73 : : {
74 : 0 : mEnabled = elem.attribute( QStringLiteral( "enabled" ) ).toInt();
75 : 0 : mLineWidth = elem.attribute( QStringLiteral( "line-width" ) ).toDouble();
76 : 0 : mColor = QgsSymbolLayerUtils::decodeColor( elem.attribute( QStringLiteral( "color" ) ) );
77 : 0 : mLineWidthUnit = QgsUnitTypes::decodeRenderUnit( elem.attribute( QStringLiteral( "line-width-unit" ) ) );
78 : 0 : }
79 : : // ---------------------------------------------------------------------
80 : :
81 : 0 : QgsColorRampShader QgsMeshRendererScalarSettings::colorRampShader() const
82 : : {
83 : 0 : return mColorRampShader;
84 : : }
85 : :
86 : 0 : void QgsMeshRendererScalarSettings::setColorRampShader( const QgsColorRampShader &shader )
87 : : {
88 : 0 : mColorRampShader = shader;
89 : 0 : }
90 : :
91 : 0 : double QgsMeshRendererScalarSettings::classificationMinimum() const { return mClassificationMinimum; }
92 : :
93 : 0 : double QgsMeshRendererScalarSettings::classificationMaximum() const { return mClassificationMaximum; }
94 : :
95 : 0 : void QgsMeshRendererScalarSettings::setClassificationMinimumMaximum( double minimum, double maximum )
96 : : {
97 : 0 : mClassificationMinimum = minimum;
98 : 0 : mClassificationMaximum = maximum;
99 : 0 : }
100 : :
101 : 0 : double QgsMeshRendererScalarSettings::opacity() const { return mOpacity; }
102 : :
103 : 0 : void QgsMeshRendererScalarSettings::setOpacity( double opacity ) { mOpacity = opacity; }
104 : :
105 : 0 : QgsMeshRendererScalarSettings::DataResamplingMethod QgsMeshRendererScalarSettings::dataResamplingMethod() const
106 : : {
107 : 0 : return mDataResamplingMethod;
108 : : }
109 : :
110 : 0 : void QgsMeshRendererScalarSettings::setDataResamplingMethod( const QgsMeshRendererScalarSettings::DataResamplingMethod &dataInterpolationMethod )
111 : : {
112 : 0 : mDataResamplingMethod = dataInterpolationMethod;
113 : 0 : }
114 : :
115 : 0 : QDomElement QgsMeshRendererScalarSettings::writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const
116 : : {
117 : 0 : QDomElement elem = doc.createElement( QStringLiteral( "scalar-settings" ) );
118 : 0 : elem.setAttribute( QStringLiteral( "min-val" ), mClassificationMinimum );
119 : 0 : elem.setAttribute( QStringLiteral( "max-val" ), mClassificationMaximum );
120 : 0 : elem.setAttribute( QStringLiteral( "opacity" ), mOpacity );
121 : :
122 : 0 : QString methodTxt;
123 : 0 : switch ( mDataResamplingMethod )
124 : : {
125 : : case None:
126 : 0 : methodTxt = QStringLiteral( "none" );
127 : 0 : break;
128 : : case NeighbourAverage:
129 : 0 : methodTxt = QStringLiteral( "neighbour-average" );
130 : 0 : break;
131 : : }
132 : 0 : elem.setAttribute( QStringLiteral( "interpolation-method" ), methodTxt );
133 : 0 : QDomElement elemShader = mColorRampShader.writeXml( doc, context );
134 : 0 : elem.appendChild( elemShader );
135 : :
136 : 0 : QDomElement elemEdge = doc.createElement( QStringLiteral( "edge-settings" ) );
137 : 0 : elemEdge.appendChild( mEdgeStrokeWidth.writeXml( doc, context ) );
138 : 0 : elemEdge.setAttribute( QStringLiteral( "stroke-width-unit" ), mEdgeStrokeWidthUnit );
139 : 0 : elem.appendChild( elemEdge );
140 : :
141 : 0 : return elem;
142 : 0 : }
143 : :
144 : 0 : void QgsMeshRendererScalarSettings::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
145 : : {
146 : 0 : mClassificationMinimum = elem.attribute( QStringLiteral( "min-val" ) ).toDouble();
147 : 0 : mClassificationMaximum = elem.attribute( QStringLiteral( "max-val" ) ).toDouble();
148 : 0 : mOpacity = elem.attribute( QStringLiteral( "opacity" ) ).toDouble();
149 : :
150 : 0 : QString methodTxt = elem.attribute( QStringLiteral( "interpolation-method" ) );
151 : 0 : if ( QStringLiteral( "neighbour-average" ) == methodTxt )
152 : : {
153 : 0 : mDataResamplingMethod = DataResamplingMethod::NeighbourAverage;
154 : 0 : }
155 : : else
156 : : {
157 : 0 : mDataResamplingMethod = DataResamplingMethod::None;
158 : : }
159 : 0 : QDomElement elemShader = elem.firstChildElement( QStringLiteral( "colorrampshader" ) );
160 : 0 : mColorRampShader.readXml( elemShader, context );
161 : :
162 : 0 : QDomElement elemEdge = elem.firstChildElement( QStringLiteral( "edge-settings" ) );
163 : 0 : QDomElement elemEdgeStrokeWidth = elemEdge.firstChildElement( QStringLiteral( "mesh-stroke-width" ) );
164 : 0 : mEdgeStrokeWidth.readXml( elemEdgeStrokeWidth, context );
165 : 0 : mEdgeStrokeWidthUnit = static_cast<QgsUnitTypes::RenderUnit>(
166 : 0 : elemEdge.attribute( QStringLiteral( "stroke-width-unit" ) ).toInt() );
167 : 0 : }
168 : :
169 : 0 : QgsInterpolatedLineWidth QgsMeshRendererScalarSettings::edgeStrokeWidth() const
170 : : {
171 : 0 : return mEdgeStrokeWidth;
172 : : }
173 : :
174 : 0 : void QgsMeshRendererScalarSettings::setEdgeStrokeWidth( const QgsInterpolatedLineWidth &strokeWidth )
175 : : {
176 : 0 : mEdgeStrokeWidth = strokeWidth;
177 : 0 : }
178 : :
179 : 0 : QgsUnitTypes::RenderUnit QgsMeshRendererScalarSettings::edgeStrokeWidthUnit() const
180 : : {
181 : 0 : return mEdgeStrokeWidthUnit;
182 : : }
183 : :
184 : 0 : void QgsMeshRendererScalarSettings::setEdgeStrokeWidthUnit( const QgsUnitTypes::RenderUnit &edgeStrokeWidthUnit )
185 : : {
186 : 0 : mEdgeStrokeWidthUnit = edgeStrokeWidthUnit;
187 : 0 : }
188 : :
189 : : // ---------------------------------------------------------------------
190 : :
191 : 0 : double QgsMeshRendererVectorSettings::lineWidth() const
192 : : {
193 : 0 : return mLineWidth;
194 : : }
195 : :
196 : 0 : void QgsMeshRendererVectorSettings::setLineWidth( double lineWidth )
197 : : {
198 : 0 : mLineWidth = lineWidth;
199 : 0 : }
200 : :
201 : 0 : QColor QgsMeshRendererVectorSettings::color() const
202 : : {
203 : 0 : return mColor;
204 : : }
205 : :
206 : 0 : void QgsMeshRendererVectorSettings::setColor( const QColor &vectorColor )
207 : : {
208 : 0 : mColor = vectorColor;
209 : 0 : }
210 : :
211 : 0 : double QgsMeshRendererVectorSettings::filterMin() const
212 : : {
213 : 0 : return mFilterMin;
214 : : }
215 : :
216 : 0 : void QgsMeshRendererVectorSettings::setFilterMin( double vectorFilterMin )
217 : : {
218 : 0 : mFilterMin = vectorFilterMin;
219 : 0 : }
220 : :
221 : 0 : double QgsMeshRendererVectorSettings::filterMax() const
222 : : {
223 : 0 : return mFilterMax;
224 : : }
225 : :
226 : 0 : void QgsMeshRendererVectorSettings::setFilterMax( double vectorFilterMax )
227 : : {
228 : 0 : mFilterMax = vectorFilterMax;
229 : 0 : }
230 : :
231 : 0 : bool QgsMeshRendererVectorSettings::isOnUserDefinedGrid() const
232 : : {
233 : 0 : return mOnUserDefinedGrid;
234 : : }
235 : :
236 : 0 : void QgsMeshRendererVectorSettings::setOnUserDefinedGrid( bool enabled )
237 : : {
238 : 0 : mOnUserDefinedGrid = enabled;
239 : 0 : }
240 : :
241 : 0 : int QgsMeshRendererVectorSettings::userGridCellWidth() const
242 : : {
243 : 0 : return mUserGridCellWidth;
244 : : }
245 : :
246 : 0 : void QgsMeshRendererVectorSettings::setUserGridCellWidth( int width )
247 : : {
248 : 0 : mUserGridCellWidth = width;
249 : 0 : }
250 : :
251 : 0 : int QgsMeshRendererVectorSettings::userGridCellHeight() const
252 : : {
253 : 0 : return mUserGridCellHeight;
254 : : }
255 : :
256 : 0 : void QgsMeshRendererVectorSettings::setUserGridCellHeight( int height )
257 : : {
258 : 0 : mUserGridCellHeight = height;
259 : 0 : }
260 : :
261 : 0 : QgsMeshRendererVectorArrowSettings::ArrowScalingMethod QgsMeshRendererVectorArrowSettings::shaftLengthMethod() const
262 : : {
263 : 0 : return mShaftLengthMethod;
264 : : }
265 : :
266 : 0 : void QgsMeshRendererVectorArrowSettings::setShaftLengthMethod( QgsMeshRendererVectorArrowSettings::ArrowScalingMethod shaftLengthMethod )
267 : : {
268 : 0 : mShaftLengthMethod = shaftLengthMethod;
269 : 0 : }
270 : :
271 : 0 : double QgsMeshRendererVectorArrowSettings::minShaftLength() const
272 : : {
273 : 0 : return mMinShaftLength;
274 : : }
275 : :
276 : 0 : void QgsMeshRendererVectorArrowSettings::setMinShaftLength( double minShaftLength )
277 : : {
278 : 0 : mMinShaftLength = minShaftLength;
279 : 0 : }
280 : :
281 : 0 : double QgsMeshRendererVectorArrowSettings::maxShaftLength() const
282 : : {
283 : 0 : return mMaxShaftLength;
284 : : }
285 : :
286 : 0 : void QgsMeshRendererVectorArrowSettings::setMaxShaftLength( double maxShaftLength )
287 : : {
288 : 0 : mMaxShaftLength = maxShaftLength;
289 : 0 : }
290 : :
291 : 0 : double QgsMeshRendererVectorArrowSettings::scaleFactor() const
292 : : {
293 : 0 : return mScaleFactor;
294 : : }
295 : :
296 : 0 : void QgsMeshRendererVectorArrowSettings::setScaleFactor( double scaleFactor )
297 : : {
298 : 0 : mScaleFactor = scaleFactor;
299 : 0 : }
300 : :
301 : 0 : double QgsMeshRendererVectorArrowSettings::fixedShaftLength() const
302 : : {
303 : 0 : return mFixedShaftLength;
304 : : }
305 : :
306 : 0 : void QgsMeshRendererVectorArrowSettings::setFixedShaftLength( double fixedShaftLength )
307 : : {
308 : 0 : mFixedShaftLength = fixedShaftLength;
309 : 0 : }
310 : :
311 : 0 : double QgsMeshRendererVectorArrowSettings::arrowHeadWidthRatio() const
312 : : {
313 : 0 : return mArrowHeadWidthRatio;
314 : : }
315 : :
316 : 0 : void QgsMeshRendererVectorArrowSettings::setArrowHeadWidthRatio( double vectorHeadWidthRatio )
317 : : {
318 : 0 : mArrowHeadWidthRatio = vectorHeadWidthRatio;
319 : 0 : }
320 : :
321 : 0 : double QgsMeshRendererVectorArrowSettings::arrowHeadLengthRatio() const
322 : : {
323 : 0 : return mArrowHeadLengthRatio;
324 : : }
325 : :
326 : 0 : void QgsMeshRendererVectorArrowSettings::setArrowHeadLengthRatio( double vectorHeadLengthRatio )
327 : : {
328 : 0 : mArrowHeadLengthRatio = vectorHeadLengthRatio;
329 : 0 : }
330 : :
331 : 0 : QDomElement QgsMeshRendererVectorArrowSettings::writeXml( QDomDocument &doc ) const
332 : : {
333 : 0 : QDomElement elem = doc.createElement( QStringLiteral( "vector-arrow-settings" ) );
334 : 0 : elem.setAttribute( QStringLiteral( "arrow-head-width-ratio" ), mArrowHeadWidthRatio );
335 : 0 : elem.setAttribute( QStringLiteral( "arrow-head-length-ratio" ), mArrowHeadLengthRatio );
336 : :
337 : 0 : QDomElement elemShaft = doc.createElement( QStringLiteral( "shaft-length" ) );
338 : 0 : QString methodTxt;
339 : 0 : switch ( mShaftLengthMethod )
340 : : {
341 : : case MinMax:
342 : 0 : methodTxt = QStringLiteral( "minmax" );
343 : 0 : elemShaft.setAttribute( QStringLiteral( "min" ), mMinShaftLength );
344 : 0 : elemShaft.setAttribute( QStringLiteral( "max" ), mMaxShaftLength );
345 : 0 : break;
346 : : case Scaled:
347 : 0 : methodTxt = QStringLiteral( "scaled" );
348 : 0 : elemShaft.setAttribute( QStringLiteral( "scale-factor" ), mScaleFactor );
349 : 0 : break;
350 : : case Fixed:
351 : 0 : methodTxt = QStringLiteral( "fixed" ) ;
352 : 0 : elemShaft.setAttribute( QStringLiteral( "fixed-length" ), mFixedShaftLength );
353 : 0 : break;
354 : : }
355 : 0 : elemShaft.setAttribute( QStringLiteral( "method" ), methodTxt );
356 : 0 : elem.appendChild( elemShaft );
357 : 0 : return elem;
358 : 0 : }
359 : :
360 : 0 : void QgsMeshRendererVectorArrowSettings::readXml( const QDomElement &elem )
361 : : {
362 : 0 : mArrowHeadWidthRatio = elem.attribute( QStringLiteral( "arrow-head-width-ratio" ) ).toDouble();
363 : 0 : mArrowHeadLengthRatio = elem.attribute( QStringLiteral( "arrow-head-length-ratio" ) ).toDouble();
364 : :
365 : 0 : QDomElement elemShaft = elem.firstChildElement( QStringLiteral( "shaft-length" ) );
366 : 0 : QString methodTxt = elemShaft.attribute( QStringLiteral( "method" ) );
367 : 0 : if ( QStringLiteral( "minmax" ) == methodTxt )
368 : : {
369 : 0 : mShaftLengthMethod = MinMax;
370 : 0 : mMinShaftLength = elemShaft.attribute( QStringLiteral( "min" ) ).toDouble();
371 : 0 : mMaxShaftLength = elemShaft.attribute( QStringLiteral( "max" ) ).toDouble();
372 : 0 : }
373 : 0 : else if ( QStringLiteral( "scaled" ) == methodTxt )
374 : : {
375 : 0 : mShaftLengthMethod = Scaled;
376 : 0 : mScaleFactor = elemShaft.attribute( QStringLiteral( "scale-factor" ) ).toDouble();
377 : 0 : }
378 : : else // fixed
379 : : {
380 : 0 : mShaftLengthMethod = Fixed;
381 : 0 : mFixedShaftLength = elemShaft.attribute( QStringLiteral( "fixed-length" ) ).toDouble();
382 : : }
383 : 0 : }
384 : :
385 : : // ---------------------------------------------------------------------
386 : :
387 : 0 : QgsMeshRendererSettings::QgsMeshRendererSettings()
388 : 0 : : mAveragingMethod( new QgsMeshMultiLevelsAveragingMethod() )
389 : : {
390 : 0 : }
391 : :
392 : 0 : QgsMeshRendererSettings::~QgsMeshRendererSettings() = default;
393 : :
394 : 0 : QgsMesh3dAveragingMethod *QgsMeshRendererSettings::averagingMethod() const
395 : : {
396 : 0 : return mAveragingMethod.get();
397 : : }
398 : :
399 : 0 : void QgsMeshRendererSettings::setAveragingMethod( QgsMesh3dAveragingMethod *method )
400 : : {
401 : 0 : if ( method )
402 : 0 : mAveragingMethod.reset( method->clone() );
403 : : else
404 : 0 : mAveragingMethod.reset();
405 : 0 : }
406 : :
407 : 0 : QDomElement QgsMeshRendererSettings::writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const
408 : : {
409 : 0 : QDomElement elem = doc.createElement( QStringLiteral( "mesh-renderer-settings" ) );
410 : :
411 : 0 : QDomElement elemActiveDatasetGroup = doc.createElement( QStringLiteral( "active-dataset-group" ) );
412 : 0 : elemActiveDatasetGroup.setAttribute( QStringLiteral( "scalar" ), mActiveScalarDatasetGroup );
413 : 0 : elemActiveDatasetGroup.setAttribute( QStringLiteral( "vector" ), mActiveVectorDatasetGroup );
414 : 0 : elem.appendChild( elemActiveDatasetGroup );
415 : :
416 : 0 : for ( int groupIndex : mRendererScalarSettings.keys() )
417 : : {
418 : 0 : const QgsMeshRendererScalarSettings &scalarSettings = mRendererScalarSettings[groupIndex];
419 : 0 : QDomElement elemScalar = scalarSettings.writeXml( doc, context );
420 : 0 : elemScalar.setAttribute( QStringLiteral( "group" ), groupIndex );
421 : 0 : elem.appendChild( elemScalar );
422 : 0 : }
423 : :
424 : 0 : for ( int groupIndex : mRendererVectorSettings.keys() )
425 : : {
426 : 0 : const QgsMeshRendererVectorSettings &vectorSettings = mRendererVectorSettings[groupIndex];
427 : 0 : QDomElement elemVector = vectorSettings.writeXml( doc, context );
428 : 0 : elemVector.setAttribute( QStringLiteral( "group" ), groupIndex );
429 : 0 : elem.appendChild( elemVector );
430 : 0 : }
431 : :
432 : 0 : QDomElement elemNativeMesh = mRendererNativeMeshSettings.writeXml( doc );
433 : 0 : elemNativeMesh.setTagName( QStringLiteral( "mesh-settings-native" ) );
434 : 0 : elem.appendChild( elemNativeMesh );
435 : :
436 : 0 : QDomElement elemEdgeMesh = mRendererEdgeMeshSettings.writeXml( doc );
437 : 0 : elemEdgeMesh.setTagName( QStringLiteral( "mesh-settings-edge" ) );
438 : 0 : elem.appendChild( elemEdgeMesh );
439 : :
440 : 0 : QDomElement elemTriangularMesh = mRendererTriangularMeshSettings.writeXml( doc );
441 : 0 : elemTriangularMesh.setTagName( QStringLiteral( "mesh-settings-triangular" ) );
442 : 0 : elem.appendChild( elemTriangularMesh );
443 : :
444 : 0 : if ( mAveragingMethod )
445 : : {
446 : 0 : QDomElement elemAveraging = doc.createElement( QStringLiteral( "averaging-3d" ) );
447 : 0 : elemAveraging.setAttribute( QStringLiteral( "method" ), QString::number( mAveragingMethod->method() ) ) ;
448 : 0 : QDomElement elemAveragingParams = mAveragingMethod->writeXml( doc );
449 : 0 : elemAveraging.appendChild( elemAveragingParams );
450 : 0 : elem.appendChild( elemAveraging );
451 : 0 : }
452 : :
453 : 0 : return elem;
454 : 0 : }
455 : :
456 : 0 : void QgsMeshRendererSettings::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
457 : : {
458 : 0 : mRendererScalarSettings.clear();
459 : 0 : mRendererVectorSettings.clear();
460 : 0 : mAveragingMethod.reset();
461 : :
462 : 0 : QDomElement elemActiveDataset = elem.firstChildElement( QStringLiteral( "active-dataset-group" ) );
463 : 0 : if ( elemActiveDataset.hasAttribute( QStringLiteral( "scalar" ) ) )
464 : 0 : mActiveScalarDatasetGroup = elemActiveDataset.attribute( QStringLiteral( "scalar" ) ).toInt();
465 : :
466 : 0 : if ( elemActiveDataset.hasAttribute( QStringLiteral( "vector" ) ) )
467 : 0 : mActiveVectorDatasetGroup = elemActiveDataset.attribute( QStringLiteral( "vector" ) ).toInt();
468 : :
469 : 0 : QDomElement elemScalar = elem.firstChildElement( QStringLiteral( "scalar-settings" ) );
470 : 0 : while ( !elemScalar.isNull() )
471 : : {
472 : 0 : int groupIndex = elemScalar.attribute( QStringLiteral( "group" ) ).toInt();
473 : 0 : QgsMeshRendererScalarSettings scalarSettings;
474 : 0 : scalarSettings.readXml( elemScalar, context );
475 : 0 : mRendererScalarSettings.insert( groupIndex, scalarSettings );
476 : :
477 : 0 : elemScalar = elemScalar.nextSiblingElement( QStringLiteral( "scalar-settings" ) );
478 : 0 : }
479 : :
480 : 0 : QDomElement elemVector = elem.firstChildElement( QStringLiteral( "vector-settings" ) );
481 : 0 : while ( !elemVector.isNull() )
482 : : {
483 : 0 : int groupIndex = elemVector.attribute( QStringLiteral( "group" ) ).toInt();
484 : 0 : QgsMeshRendererVectorSettings vectorSettings;
485 : 0 : vectorSettings.readXml( elemVector, context );
486 : 0 : mRendererVectorSettings.insert( groupIndex, vectorSettings );
487 : :
488 : 0 : elemVector = elemVector.nextSiblingElement( QStringLiteral( "vector-settings" ) );
489 : 0 : }
490 : :
491 : 0 : QDomElement elemNativeMesh = elem.firstChildElement( QStringLiteral( "mesh-settings-native" ) );
492 : 0 : mRendererNativeMeshSettings.readXml( elemNativeMesh );
493 : :
494 : 0 : QDomElement elemEdgeMesh = elem.firstChildElement( QStringLiteral( "mesh-settings-edge" ) );
495 : 0 : mRendererEdgeMeshSettings.readXml( elemEdgeMesh );
496 : :
497 : 0 : QDomElement elemTriangularMesh = elem.firstChildElement( QStringLiteral( "mesh-settings-triangular" ) );
498 : 0 : mRendererTriangularMeshSettings.readXml( elemTriangularMesh );
499 : :
500 : 0 : QDomElement elemAveraging = elem.firstChildElement( QStringLiteral( "averaging-3d" ) );
501 : 0 : if ( !elemAveraging.isNull() )
502 : : {
503 : 0 : mAveragingMethod.reset( QgsMesh3dAveragingMethod::createFromXml( elemAveraging ) );
504 : 0 : }
505 : 0 : }
506 : :
507 : 0 : int QgsMeshRendererSettings::activeScalarDatasetGroup() const
508 : : {
509 : 0 : return mActiveScalarDatasetGroup;
510 : : }
511 : :
512 : 0 : void QgsMeshRendererSettings::setActiveScalarDatasetGroup( int activeScalarDatasetGroup )
513 : : {
514 : 0 : mActiveScalarDatasetGroup = activeScalarDatasetGroup;
515 : 0 : }
516 : :
517 : 0 : int QgsMeshRendererSettings::activeVectorDatasetGroup() const
518 : : {
519 : 0 : return mActiveVectorDatasetGroup;
520 : : }
521 : :
522 : 0 : void QgsMeshRendererSettings::setActiveVectorDatasetGroup( int activeVectorDatasetGroup )
523 : : {
524 : 0 : mActiveVectorDatasetGroup = activeVectorDatasetGroup;
525 : 0 : }
526 : :
527 : 0 : QgsMeshRendererVectorStreamlineSettings::SeedingStartPointsMethod QgsMeshRendererVectorStreamlineSettings::seedingMethod() const
528 : : {
529 : 0 : return mSeedingMethod;
530 : : }
531 : :
532 : 0 : void QgsMeshRendererVectorStreamlineSettings::setSeedingMethod( const SeedingStartPointsMethod &seedingMethod )
533 : : {
534 : 0 : mSeedingMethod = seedingMethod;
535 : 0 : }
536 : :
537 : 0 : double QgsMeshRendererVectorStreamlineSettings::seedingDensity() const
538 : : {
539 : 0 : return mSeedingDensity;
540 : : }
541 : :
542 : 0 : void QgsMeshRendererVectorStreamlineSettings::setSeedingDensity( double seedingDensity )
543 : : {
544 : 0 : mSeedingDensity = seedingDensity;
545 : 0 : }
546 : :
547 : 0 : QDomElement QgsMeshRendererVectorStreamlineSettings::writeXml( QDomDocument &doc ) const
548 : : {
549 : 0 : QDomElement elem = doc.createElement( QStringLiteral( "vector-streamline-settings" ) );
550 : :
551 : 0 : elem.setAttribute( QStringLiteral( "seeding-method" ), mSeedingMethod );
552 : 0 : elem.setAttribute( QStringLiteral( "seeding-density" ), mSeedingDensity );
553 : :
554 : 0 : return elem;
555 : 0 : }
556 : :
557 : 0 : void QgsMeshRendererVectorStreamlineSettings::readXml( const QDomElement &elem )
558 : : {
559 : 0 : mSeedingMethod =
560 : : static_cast<QgsMeshRendererVectorStreamlineSettings::SeedingStartPointsMethod>(
561 : 0 : elem.attribute( QStringLiteral( "seeding-method" ) ).toInt() );
562 : 0 : mSeedingDensity = elem.attribute( QStringLiteral( "seeding-density" ) ).toDouble();
563 : 0 : }
564 : :
565 : 0 : QgsMeshRendererVectorSettings::Symbology QgsMeshRendererVectorSettings::symbology() const
566 : : {
567 : 0 : return mDisplayingMethod;
568 : : }
569 : :
570 : 0 : void QgsMeshRendererVectorSettings::setSymbology( const Symbology &displayingMethod )
571 : : {
572 : 0 : mDisplayingMethod = displayingMethod;
573 : 0 : }
574 : :
575 : 0 : QgsMeshRendererVectorArrowSettings QgsMeshRendererVectorSettings::arrowSettings() const
576 : : {
577 : 0 : return mArrowsSettings;
578 : : }
579 : :
580 : 0 : void QgsMeshRendererVectorSettings::setArrowsSettings( const QgsMeshRendererVectorArrowSettings &arrowSettings )
581 : : {
582 : 0 : mArrowsSettings = arrowSettings;
583 : 0 : }
584 : :
585 : 0 : QgsMeshRendererVectorStreamlineSettings QgsMeshRendererVectorSettings::streamLinesSettings() const
586 : : {
587 : 0 : return mStreamLinesSettings;
588 : : }
589 : :
590 : 0 : void QgsMeshRendererVectorSettings::setStreamLinesSettings( const QgsMeshRendererVectorStreamlineSettings &streamLinesSettings )
591 : : {
592 : 0 : mStreamLinesSettings = streamLinesSettings;
593 : 0 : }
594 : :
595 : 0 : QDomElement QgsMeshRendererVectorSettings::writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const
596 : : {
597 : 0 : QDomElement elem = doc.createElement( QStringLiteral( "vector-settings" ) );
598 : 0 : elem.setAttribute( QStringLiteral( "symbology" ), mDisplayingMethod );
599 : :
600 : 0 : elem.setAttribute( QStringLiteral( "line-width" ), mLineWidth );
601 : 0 : elem.setAttribute( QStringLiteral( "coloring-method" ), coloringMethod() );
602 : 0 : elem.setAttribute( QStringLiteral( "color" ), QgsSymbolLayerUtils::encodeColor( mColor ) );
603 : 0 : QDomElement elemShader = mColorRampShader.writeXml( doc, context );
604 : 0 : elem.appendChild( elemShader );
605 : 0 : elem.setAttribute( QStringLiteral( "filter-min" ), mFilterMin );
606 : 0 : elem.setAttribute( QStringLiteral( "filter-max" ), mFilterMax );
607 : :
608 : 0 : elem.setAttribute( QStringLiteral( "user-grid-enabled" ), mOnUserDefinedGrid ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
609 : 0 : elem.setAttribute( QStringLiteral( "user-grid-width" ), mUserGridCellWidth );
610 : 0 : elem.setAttribute( QStringLiteral( "user-grid-height" ), mUserGridCellHeight );
611 : :
612 : 0 : elem.appendChild( mArrowsSettings.writeXml( doc ) );
613 : 0 : elem.appendChild( mStreamLinesSettings.writeXml( doc ) );
614 : 0 : elem.appendChild( mTracesSettings.writeXml( doc ) );
615 : :
616 : 0 : return elem;
617 : 0 : }
618 : :
619 : 0 : void QgsMeshRendererVectorSettings::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
620 : : {
621 : 0 : mDisplayingMethod = static_cast<QgsMeshRendererVectorSettings::Symbology>(
622 : 0 : elem.attribute( QStringLiteral( "symbology" ) ).toInt() );
623 : :
624 : 0 : mLineWidth = elem.attribute( QStringLiteral( "line-width" ) ).toDouble();
625 : 0 : mColoringMethod = static_cast<QgsInterpolatedLineColor::ColoringMethod>(
626 : 0 : elem.attribute( QStringLiteral( "coloring-method" ) ).toInt() );
627 : 0 : mColor = QgsSymbolLayerUtils::decodeColor( elem.attribute( QStringLiteral( "color" ) ) );
628 : 0 : mColorRampShader.readXml( elem.firstChildElement( "colorrampshader" ), context );
629 : 0 : mFilterMin = elem.attribute( QStringLiteral( "filter-min" ) ).toDouble();
630 : 0 : mFilterMax = elem.attribute( QStringLiteral( "filter-max" ) ).toDouble();
631 : :
632 : 0 : mOnUserDefinedGrid = elem.attribute( QStringLiteral( "user-grid-enabled" ) ).toInt(); //bool
633 : 0 : mUserGridCellWidth = elem.attribute( QStringLiteral( "user-grid-width" ) ).toInt();
634 : 0 : mUserGridCellHeight = elem.attribute( QStringLiteral( "user-grid-height" ) ).toInt();
635 : :
636 : 0 : QDomElement elemVector = elem.firstChildElement( QStringLiteral( "vector-arrow-settings" ) );
637 : 0 : if ( ! elemVector.isNull() )
638 : 0 : mArrowsSettings.readXml( elemVector );
639 : :
640 : 0 : QDomElement elemStreamLine = elem.firstChildElement( QStringLiteral( "vector-streamline-settings" ) );
641 : 0 : if ( ! elemStreamLine.isNull() )
642 : 0 : mStreamLinesSettings.readXml( elemStreamLine );
643 : :
644 : 0 : QDomElement elemTraces = elem.firstChildElement( QStringLiteral( "vector-traces-settings" ) );
645 : 0 : if ( ! elemTraces.isNull() )
646 : 0 : mTracesSettings.readXml( elemTraces );
647 : 0 : }
648 : :
649 : 0 : QgsInterpolatedLineColor::ColoringMethod QgsMeshRendererVectorSettings::coloringMethod() const
650 : : {
651 : 0 : return mColoringMethod;
652 : : }
653 : :
654 : 0 : void QgsMeshRendererVectorSettings::setColoringMethod( const QgsInterpolatedLineColor::ColoringMethod &coloringMethod )
655 : : {
656 : 0 : mColoringMethod = coloringMethod;
657 : 0 : }
658 : :
659 : 0 : QgsColorRampShader QgsMeshRendererVectorSettings::colorRampShader() const
660 : : {
661 : 0 : return mColorRampShader;
662 : : }
663 : :
664 : 0 : void QgsMeshRendererVectorSettings::setColorRampShader( const QgsColorRampShader &colorRampShader )
665 : : {
666 : 0 : mColorRampShader = colorRampShader;
667 : 0 : }
668 : :
669 : 0 : QgsInterpolatedLineColor QgsMeshRendererVectorSettings::vectorStrokeColoring() const
670 : : {
671 : 0 : QgsInterpolatedLineColor strokeColoring;
672 : 0 : switch ( mColoringMethod )
673 : : {
674 : : case QgsInterpolatedLineColor::SingleColor:
675 : 0 : strokeColoring = QgsInterpolatedLineColor( mColor );
676 : 0 : break;
677 : : case QgsInterpolatedLineColor::ColorRamp:
678 : 0 : strokeColoring = QgsInterpolatedLineColor( mColorRampShader );
679 : 0 : break;
680 : : }
681 : :
682 : 0 : return strokeColoring;
683 : 0 : }
684 : :
685 : 0 : QgsMeshRendererVectorTracesSettings QgsMeshRendererVectorSettings::tracesSettings() const
686 : : {
687 : 0 : return mTracesSettings;
688 : 0 : }
689 : :
690 : 0 : void QgsMeshRendererVectorSettings::setTracesSettings( const QgsMeshRendererVectorTracesSettings &tracesSettings )
691 : : {
692 : 0 : mTracesSettings = tracesSettings;
693 : 0 : }
694 : :
695 : 0 : void QgsMeshRendererVectorTracesSettings::readXml( const QDomElement &elem )
696 : : {
697 : 0 : mMaximumTailLength = elem.attribute( QStringLiteral( "maximum-tail-length" ) ).toInt();
698 : 0 : mMaximumTailLengthUnit = static_cast<QgsUnitTypes::RenderUnit>(
699 : 0 : elem.attribute( QStringLiteral( "maximum-tail-length-unit" ) ).toInt() );
700 : 0 : mParticlesCount = elem.attribute( QStringLiteral( "particles-count" ) ).toInt();
701 : 0 : }
702 : :
703 : 0 : QDomElement QgsMeshRendererVectorTracesSettings::writeXml( QDomDocument &doc ) const
704 : : {
705 : 0 : QDomElement elem = doc.createElement( QStringLiteral( "vector-traces-settings" ) );
706 : 0 : elem.setAttribute( QStringLiteral( "maximum-tail-length" ), mMaximumTailLength );
707 : 0 : elem.setAttribute( QStringLiteral( "maximum-tail-length-unit" ), mMaximumTailLengthUnit );
708 : 0 : elem.setAttribute( QStringLiteral( "particles-count" ), mParticlesCount );
709 : :
710 : 0 : return elem;
711 : 0 : }
712 : :
713 : 0 : QgsUnitTypes::RenderUnit QgsMeshRendererVectorTracesSettings::maximumTailLengthUnit() const
714 : : {
715 : 0 : return mMaximumTailLengthUnit;
716 : : }
717 : :
718 : 0 : void QgsMeshRendererVectorTracesSettings::setMaximumTailLengthUnit( const QgsUnitTypes::RenderUnit &maximumTailLengthUnit )
719 : : {
720 : 0 : mMaximumTailLengthUnit = maximumTailLengthUnit;
721 : 0 : }
722 : :
723 : 0 : double QgsMeshRendererVectorTracesSettings::maximumTailLength() const
724 : : {
725 : 0 : return mMaximumTailLength;
726 : : }
727 : :
728 : 0 : void QgsMeshRendererVectorTracesSettings::setMaximumTailLength( double maximumTailLength )
729 : : {
730 : 0 : mMaximumTailLength = maximumTailLength;
731 : 0 : }
732 : :
733 : 0 : int QgsMeshRendererVectorTracesSettings::particlesCount() const
734 : : {
735 : 0 : return mParticlesCount;
736 : : }
737 : :
738 : 0 : void QgsMeshRendererVectorTracesSettings::setParticlesCount( int value )
739 : : {
740 : 0 : mParticlesCount = value;
741 : 0 : }
742 : :
|
