QGIS API Documentation 3.37.0-Master (fdefdf9c27f)
qgsrasterlayerelevationproperties.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsrasterlayerelevationproperties.cpp
3 ---------------
4 begin : February 2022
5 copyright : (C) 2022 by Nyall Dawson
6 email : nyall dot dawson 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 "qgsrasterlayerelevationproperties.h"
19#include "qgsrasterlayer.h"
20#include "qgslinesymbol.h"
21#include "qgsfillsymbol.h"
22#include "qgssymbollayerutils.h"
23#include "qgslinesymbollayer.h"
24#include "qgsfillsymbollayer.h"
25#include "qgsapplication.h"
26#include "qgscolorschemeregistry.h"
27#include "qgsexpressioncontextutils.h"
28
29QgsRasterLayerElevationProperties::QgsRasterLayerElevationProperties( QObject *parent )
30 : QgsMapLayerElevationProperties( parent )
31{
32 const QColor color = QgsApplication::colorSchemeRegistry()->fetchRandomStyleColor();
33 setDefaultProfileLineSymbol( color );
34 setDefaultProfileFillSymbol( color );
35}
36
37QgsRasterLayerElevationProperties::~QgsRasterLayerElevationProperties() = default;
38
39bool QgsRasterLayerElevationProperties::hasElevation() const
40{
41 return mEnabled;
42}
43
44QDomElement QgsRasterLayerElevationProperties::writeXml( QDomElement &parentElement, QDomDocument &document, const QgsReadWriteContext &context )
45{
46 QDomElement element = document.createElement( QStringLiteral( "elevation" ) );
47 element.setAttribute( QStringLiteral( "enabled" ), mEnabled ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
48 element.setAttribute( QStringLiteral( "mode" ), qgsEnumValueToKey( mMode ) );
49 element.setAttribute( QStringLiteral( "symbology" ), qgsEnumValueToKey( mSymbology ) );
50 if ( !std::isnan( mElevationLimit ) )
51 element.setAttribute( QStringLiteral( "elevationLimit" ), qgsDoubleToString( mElevationLimit ) );
52
53 writeCommonProperties( element, document, context );
54
55 switch ( mMode )
56 {
57 case Qgis::RasterElevationMode::FixedElevationRange:
58 element.setAttribute( QStringLiteral( "lower" ), qgsDoubleToString( mFixedRange.lower() ) );
59 element.setAttribute( QStringLiteral( "upper" ), qgsDoubleToString( mFixedRange.upper() ) );
60 element.setAttribute( QStringLiteral( "includeLower" ), mFixedRange.includeLower() ? "1" : "0" );
61 element.setAttribute( QStringLiteral( "includeUpper" ), mFixedRange.includeUpper() ? "1" : "0" );
62 break;
63
64 case Qgis::RasterElevationMode::FixedRangePerBand:
65 {
66 QDomElement ranges = document.createElement( QStringLiteral( "ranges" ) );
67 for ( auto it = mRangePerBand.constBegin(); it != mRangePerBand.constEnd(); ++it )
68 {
69 QDomElement range = document.createElement( QStringLiteral( "range" ) );
70 range.setAttribute( QStringLiteral( "band" ), it.key() );
71 range.setAttribute( QStringLiteral( "lower" ), qgsDoubleToString( it.value().lower() ) );
72 range.setAttribute( QStringLiteral( "upper" ), qgsDoubleToString( it.value().upper() ) );
73 range.setAttribute( QStringLiteral( "includeLower" ), it.value().includeLower() ? "1" : "0" );
74 range.setAttribute( QStringLiteral( "includeUpper" ), it.value().includeUpper() ? "1" : "0" );
75 ranges.appendChild( range );
76 }
77 element.appendChild( ranges );
78 break;
79 }
80
81 case Qgis::RasterElevationMode::DynamicRangePerBand:
82 break;
83
84 case Qgis::RasterElevationMode::RepresentsElevationSurface:
85 element.setAttribute( QStringLiteral( "band" ), mBandNumber );
86 break;
87 }
88
89 QDomElement profileLineSymbolElement = document.createElement( QStringLiteral( "profileLineSymbol" ) );
90 profileLineSymbolElement.appendChild( QgsSymbolLayerUtils::saveSymbol( QString(), mProfileLineSymbol.get(), document, context ) );
91 element.appendChild( profileLineSymbolElement );
92
93 QDomElement profileFillSymbolElement = document.createElement( QStringLiteral( "profileFillSymbol" ) );
94 profileFillSymbolElement.appendChild( QgsSymbolLayerUtils::saveSymbol( QString(), mProfileFillSymbol.get(), document, context ) );
95 element.appendChild( profileFillSymbolElement );
96
97 parentElement.appendChild( element );
98 return element;
99}
100
101bool QgsRasterLayerElevationProperties::readXml( const QDomElement &element, const QgsReadWriteContext &context )
102{
103 const QDomElement elevationElement = element.firstChildElement( QStringLiteral( "elevation" ) ).toElement();
104 mEnabled = elevationElement.attribute( QStringLiteral( "enabled" ), QStringLiteral( "0" ) ).toInt();
105 mMode = qgsEnumKeyToValue( elevationElement.attribute( QStringLiteral( "mode" ) ), Qgis::RasterElevationMode::RepresentsElevationSurface );
106 mSymbology = qgsEnumKeyToValue( elevationElement.attribute( QStringLiteral( "symbology" ) ), Qgis::ProfileSurfaceSymbology::Line );
107 if ( elevationElement.hasAttribute( QStringLiteral( "elevationLimit" ) ) )
108 mElevationLimit = elevationElement.attribute( QStringLiteral( "elevationLimit" ) ).toDouble();
109 else
110 mElevationLimit = std::numeric_limits< double >::quiet_NaN();
111
112 readCommonProperties( elevationElement, context );
113
114 switch ( mMode )
115 {
116 case Qgis::RasterElevationMode::FixedElevationRange:
117 {
118 const double lower = elevationElement.attribute( QStringLiteral( "lower" ) ).toDouble();
119 const double upper = elevationElement.attribute( QStringLiteral( "upper" ) ).toDouble();
120 const bool includeLower = elevationElement.attribute( QStringLiteral( "includeLower" ) ).toInt();
121 const bool includeUpper = elevationElement.attribute( QStringLiteral( "includeUpper" ) ).toInt();
122 mFixedRange = QgsDoubleRange( lower, upper, includeLower, includeUpper );
123 break;
124 }
125
126 case Qgis::RasterElevationMode::FixedRangePerBand:
127 {
128 mRangePerBand.clear();
129
130 const QDomNodeList ranges = elevationElement.firstChildElement( QStringLiteral( "ranges" ) ).childNodes();
131 for ( int i = 0; i < ranges.size(); ++i )
132 {
133 const QDomElement rangeElement = ranges.at( i ).toElement();
134 const int band = rangeElement.attribute( QStringLiteral( "band" ) ).toInt();
135 const double lower = rangeElement.attribute( QStringLiteral( "lower" ) ).toDouble();
136 const double upper = rangeElement.attribute( QStringLiteral( "upper" ) ).toDouble();
137 const bool includeLower = rangeElement.attribute( QStringLiteral( "includeLower" ) ).toInt();
138 const bool includeUpper = rangeElement.attribute( QStringLiteral( "includeUpper" ) ).toInt();
139 mRangePerBand.insert( band, QgsDoubleRange( lower, upper, includeLower, includeUpper ) );
140 }
141 break;
142 }
143
144 case Qgis::RasterElevationMode::DynamicRangePerBand:
145 break;
146
147 case Qgis::RasterElevationMode::RepresentsElevationSurface:
148 mBandNumber = elevationElement.attribute( QStringLiteral( "band" ), QStringLiteral( "1" ) ).toInt();
149 break;
150 }
151
152 const QColor defaultColor = QgsApplication::colorSchemeRegistry()->fetchRandomStyleColor();
153
154 const QDomElement profileLineSymbolElement = elevationElement.firstChildElement( QStringLiteral( "profileLineSymbol" ) ).firstChildElement( QStringLiteral( "symbol" ) );
155 mProfileLineSymbol.reset( QgsSymbolLayerUtils::loadSymbol< QgsLineSymbol >( profileLineSymbolElement, context ) );
156 if ( !mProfileLineSymbol )
157 setDefaultProfileLineSymbol( defaultColor );
158
159 const QDomElement profileFillSymbolElement = elevationElement.firstChildElement( QStringLiteral( "profileFillSymbol" ) ).firstChildElement( QStringLiteral( "symbol" ) );
160 mProfileFillSymbol.reset( QgsSymbolLayerUtils::loadSymbol< QgsFillSymbol >( profileFillSymbolElement, context ) );
161 if ( !mProfileFillSymbol )
162 setDefaultProfileFillSymbol( defaultColor );
163
164 return true;
165}
166
167QgsRasterLayerElevationProperties *QgsRasterLayerElevationProperties::clone() const
168{
169 std::unique_ptr< QgsRasterLayerElevationProperties > res = std::make_unique< QgsRasterLayerElevationProperties >( nullptr );
170 res->setEnabled( mEnabled );
171 res->setMode( mMode );
172 res->setProfileLineSymbol( mProfileLineSymbol->clone() );
173 res->setProfileFillSymbol( mProfileFillSymbol->clone() );
174 res->setProfileSymbology( mSymbology );
175 res->setElevationLimit( mElevationLimit );
176 res->setBandNumber( mBandNumber );
177 res->setFixedRange( mFixedRange );
178 res->setFixedRangePerBand( mRangePerBand );
179 res->copyCommonProperties( this );
180 return res.release();
181}
182
183QString QgsRasterLayerElevationProperties::htmlSummary() const
184{
185 QStringList properties;
186 switch ( mMode )
187 {
188 case Qgis::RasterElevationMode::FixedElevationRange:
189 properties << tr( "Elevation range: %1 to %2" ).arg( mFixedRange.lower() ).arg( mFixedRange.upper() );
190 break;
191
192 case Qgis::RasterElevationMode::FixedRangePerBand:
193 {
194 for ( auto it = mRangePerBand.constBegin(); it != mRangePerBand.constEnd(); ++it )
195 {
196 properties << tr( "Elevation for band %1: %2 to %3" ).arg( it.key() ).arg( it.value().lower() ).arg( it.value().upper() );
197 }
198 break;
199 }
200
201 case Qgis::RasterElevationMode::DynamicRangePerBand:
202 break;
203
204 case Qgis::RasterElevationMode::RepresentsElevationSurface:
205 properties << tr( "Elevation band: %1" ).arg( mBandNumber );
206 properties << tr( "Scale: %1" ).arg( mZScale );
207 properties << tr( "Offset: %1" ).arg( mZOffset );
208 break;
209 }
210
211 return QStringLiteral( "<li>%1</li>" ).arg( properties.join( QLatin1String( "</li><li>" ) ) );
212}
213
214bool QgsRasterLayerElevationProperties::isVisibleInZRange( const QgsDoubleRange &range, QgsMapLayer *layer ) const
215{
216 switch ( mMode )
217 {
218 case Qgis::RasterElevationMode::FixedElevationRange:
219 return mFixedRange.overlaps( range );
220
221 case Qgis::RasterElevationMode::FixedRangePerBand:
222 {
223 for ( auto it = mRangePerBand.constBegin(); it != mRangePerBand.constEnd(); ++it )
224 {
225 if ( it.value().overlaps( range ) )
226 return true;
227 }
228 return false;
229 }
230
231 case Qgis::RasterElevationMode::DynamicRangePerBand:
232 {
233 if ( QgsRasterLayer *rl = qobject_cast< QgsRasterLayer * >( layer ) )
234 {
235 QgsExpressionContext context;
236 context.appendScopes( QgsExpressionContextUtils::globalProjectLayerScopes( layer ) );
237 QgsExpressionContextScope *bandScope = new QgsExpressionContextScope();
238 bandScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "band" ), 1, true, false, tr( "Band number" ) ) );
239 bandScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "band_name" ), rl->dataProvider()->displayBandName( 1 ), true, false, tr( "Band name" ) ) );
240 bandScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "band_description" ), rl->dataProvider()->bandDescription( 1 ), true, false, tr( "Band description" ) ) );
241 context.appendScope( bandScope );
242
243 QgsProperty lowerProperty = mDataDefinedProperties.property( Property::RasterPerBandLowerElevation );
244 QgsProperty upperProperty = mDataDefinedProperties.property( Property::RasterPerBandUpperElevation );
245 lowerProperty.prepare( context );
246 upperProperty.prepare( context );
247 for ( int band = 1; band <= rl->bandCount(); ++band )
248 {
249 bandScope->setVariable( QStringLiteral( "band" ), band );
250 bandScope->setVariable( QStringLiteral( "band_name" ), rl->dataProvider()->displayBandName( band ) );
251 bandScope->setVariable( QStringLiteral( "band_description" ), rl->dataProvider()->bandDescription( band ) );
252
253 bool ok = false;
254 const double lower = lowerProperty.valueAsDouble( context, 0, &ok );
255 if ( !ok )
256 continue;
257 const double upper = upperProperty.valueAsDouble( context, 0, &ok );
258 if ( !ok )
259 continue;
260
261 if ( QgsDoubleRange( lower, upper ).overlaps( range ) )
262 return true;
263 }
264 }
265 return false;
266 }
267
268 case Qgis::RasterElevationMode::RepresentsElevationSurface:
269 // TODO -- test actual raster z range
270 return true;
271 }
272 BUILTIN_UNREACHABLE
273}
274
275QgsDoubleRange QgsRasterLayerElevationProperties::calculateZRange( QgsMapLayer *layer ) const
276{
277 switch ( mMode )
278 {
279 case Qgis::RasterElevationMode::FixedElevationRange:
280 return mFixedRange;
281
282 case Qgis::RasterElevationMode::FixedRangePerBand:
283 {
284 double lower = std::numeric_limits< double >::max();
285 double upper = std::numeric_limits< double >::min();
286 bool includeLower = true;
287 bool includeUpper = true;
288 for ( auto it = mRangePerBand.constBegin(); it != mRangePerBand.constEnd(); ++it )
289 {
290 if ( it.value().lower() < lower )
291 {
292 lower = it.value().lower();
293 includeLower = it.value().includeLower();
294 }
295 else if ( !includeLower && it.value().lower() == lower && it.value().includeLower() )
296 {
297 includeLower = true;
298 }
299 if ( it.value().upper() > upper )
300 {
301 upper = it.value().upper();
302 includeUpper = it.value().includeUpper();
303 }
304 else if ( !includeUpper && it.value().upper() == upper && it.value().includeUpper() )
305 {
306 includeUpper = true;
307 }
308 }
309 return QgsDoubleRange( lower, upper, includeLower, includeUpper );
310 }
311
312 case Qgis::RasterElevationMode::DynamicRangePerBand:
313 {
314 if ( QgsRasterLayer *rl = qobject_cast< QgsRasterLayer * >( layer ) )
315 {
316 QgsExpressionContext context;
317 context.appendScopes( QgsExpressionContextUtils::globalProjectLayerScopes( layer ) );
318 QgsExpressionContextScope *bandScope = new QgsExpressionContextScope();
319 bandScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "band" ), 1, true, false, tr( "Band number" ) ) );
320 bandScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "band_name" ), rl->dataProvider()->displayBandName( 1 ), true, false, tr( "Band name" ) ) );
321 bandScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "band_description" ), rl->dataProvider()->bandDescription( 1 ), true, false, tr( "Band description" ) ) );
322 context.appendScope( bandScope );
323
324 QgsProperty lowerProperty = mDataDefinedProperties.property( Property::RasterPerBandLowerElevation );
325 QgsProperty upperProperty = mDataDefinedProperties.property( Property::RasterPerBandUpperElevation );
326 lowerProperty.prepare( context );
327 upperProperty.prepare( context );
328 double minLower = std::numeric_limits<double>::max();
329 double maxUpper = std::numeric_limits<double>::lowest();
330 for ( int band = 1; band <= rl->bandCount(); ++band )
331 {
332 bandScope->setVariable( QStringLiteral( "band" ), band );
333 bandScope->setVariable( QStringLiteral( "band_name" ), rl->dataProvider()->displayBandName( band ) );
334 bandScope->setVariable( QStringLiteral( "band_description" ), rl->dataProvider()->bandDescription( band ) );
335
336 bool ok = false;
337 const double lower = lowerProperty.valueAsDouble( context, 0, &ok );
338 if ( !ok )
339 continue;
340 const double upper = upperProperty.valueAsDouble( context, 0, &ok );
341 if ( !ok )
342 continue;
343
344 minLower = std::min( minLower, lower );
345 maxUpper = std::max( maxUpper, upper );
346 }
347 return ( minLower == std::numeric_limits<double>::max() && maxUpper == std::numeric_limits<double>::lowest() ) ? QgsDoubleRange() : QgsDoubleRange( minLower, maxUpper );
348 }
349 return QgsDoubleRange();
350 }
351
352 case Qgis::RasterElevationMode::RepresentsElevationSurface:
353 // TODO -- determine actual z range from raster statistics
354 return QgsDoubleRange();
355 }
356 BUILTIN_UNREACHABLE
357}
358
359bool QgsRasterLayerElevationProperties::showByDefaultInElevationProfilePlots() const
360{
361 return mEnabled;
362}
363
364QgsMapLayerElevationProperties::Flags QgsRasterLayerElevationProperties::flags() const
365{
366 if ( mEnabled )
367 {
368 switch ( mMode )
369 {
370 case Qgis::RasterElevationMode::FixedElevationRange:
371 return QgsMapLayerElevationProperties::Flag::FlagDontInvalidateCachedRendersWhenRangeChanges;
372
373 case Qgis::RasterElevationMode::RepresentsElevationSurface:
374 case Qgis::RasterElevationMode::FixedRangePerBand:
375 case Qgis::RasterElevationMode::DynamicRangePerBand:
376 break;
377 }
378 }
379 return QgsMapLayerElevationProperties::Flags();
380}
381
382void QgsRasterLayerElevationProperties::setEnabled( bool enabled )
383{
384 if ( enabled == mEnabled )
385 return;
386
387 mEnabled = enabled;
388 emit changed();
389 emit profileGenerationPropertyChanged();
390}
391
392Qgis::RasterElevationMode QgsRasterLayerElevationProperties::mode() const
393{
394 return mMode;
395}
396
397void QgsRasterLayerElevationProperties::setMode( Qgis::RasterElevationMode mode )
398{
399 if ( mMode == mode )
400 return;
401
402 mMode = mode;
403 emit changed();
404}
405
406void QgsRasterLayerElevationProperties::setBandNumber( int band )
407{
408 if ( mBandNumber == band )
409 return;
410
411 mBandNumber = band;
412 emit changed();
413 emit profileGenerationPropertyChanged();
414}
415
416QgsDoubleRange QgsRasterLayerElevationProperties::elevationRangeForPixelValue( QgsRasterLayer *layer, int band, double pixelValue ) const
417{
418 if ( !mEnabled || std::isnan( pixelValue ) )
419 return QgsDoubleRange();
420
421 switch ( mMode )
422 {
423 case Qgis::RasterElevationMode::FixedElevationRange:
424 return mFixedRange;
425
426 case Qgis::RasterElevationMode::FixedRangePerBand:
427 {
428 auto it = mRangePerBand.constFind( band );
429 if ( it != mRangePerBand.constEnd() )
430 return it.value();
431 return QgsDoubleRange();
432 }
433
434 case Qgis::RasterElevationMode::DynamicRangePerBand:
435 {
436 if ( layer && band > 0 && band <= layer->bandCount() )
437 {
438 QgsExpressionContext context;
439 context.appendScopes( QgsExpressionContextUtils::globalProjectLayerScopes( layer ) );
440 QgsExpressionContextScope *bandScope = new QgsExpressionContextScope();
441 bandScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "band" ), band, true, false, tr( "Band number" ) ) );
442 bandScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "band_name" ), layer->dataProvider()->displayBandName( band ), true, false, tr( "Band name" ) ) );
443 bandScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "band_description" ), layer->dataProvider()->bandDescription( band ), true, false, tr( "Band description" ) ) );
444 context.appendScope( bandScope );
445
446 QgsProperty lowerProperty = mDataDefinedProperties.property( Property::RasterPerBandLowerElevation );
447 QgsProperty upperProperty = mDataDefinedProperties.property( Property::RasterPerBandUpperElevation );
448 lowerProperty.prepare( context );
449 upperProperty.prepare( context );
450
451 bool ok = false;
452 const double lower = lowerProperty.valueAsDouble( context, 0, &ok );
453 if ( !ok )
454 return QgsDoubleRange();
455 const double upper = upperProperty.valueAsDouble( context, 0, &ok );
456 if ( !ok )
457 return QgsDoubleRange();
458
459 return QgsDoubleRange( lower, upper );
460 }
461
462 return QgsDoubleRange();
463 }
464
465 case Qgis::RasterElevationMode::RepresentsElevationSurface:
466 {
467 if ( band != mBandNumber )
468 return QgsDoubleRange();
469
470 const double z = pixelValue * mZScale + mZOffset;
471 return QgsDoubleRange( z, z );
472 }
473 }
474 BUILTIN_UNREACHABLE
475}
476
477int QgsRasterLayerElevationProperties::bandForElevationRange( QgsRasterLayer *layer, const QgsDoubleRange &range ) const
478{
479 switch ( mMode )
480 {
481 case Qgis::RasterElevationMode::FixedElevationRange:
482 case Qgis::RasterElevationMode::RepresentsElevationSurface:
483 return -1;
484
485 case Qgis::RasterElevationMode::FixedRangePerBand:
486 {
487 // find the top-most band which matches the map range
488 int currentMatchingBand = -1;
489 QgsDoubleRange currentMatchingRange;
490 for ( auto it = mRangePerBand.constBegin(); it != mRangePerBand.constEnd(); ++it )
491 {
492 if ( it.value().overlaps( range ) )
493 {
494 if ( currentMatchingRange.isInfinite()
495 || ( it.value().includeUpper() && it.value().upper() >= currentMatchingRange.upper() )
496 || ( !currentMatchingRange.includeUpper() && it.value().upper() >= currentMatchingRange.upper() ) )
497 {
498 currentMatchingBand = it.key();
499 currentMatchingRange = it.value();
500 }
501 }
502 }
503 return currentMatchingBand;
504 }
505
506 case Qgis::RasterElevationMode::DynamicRangePerBand:
507 {
508 if ( layer )
509 {
510 QgsExpressionContext context;
511 context.appendScopes( QgsExpressionContextUtils::globalProjectLayerScopes( layer ) );
512 QgsExpressionContextScope *bandScope = new QgsExpressionContextScope();
513 context.appendScope( bandScope );
514
515 QgsProperty lowerProperty = mDataDefinedProperties.property( Property::RasterPerBandLowerElevation );
516 QgsProperty upperProperty = mDataDefinedProperties.property( Property::RasterPerBandUpperElevation );
517 lowerProperty.prepare( context );
518 upperProperty.prepare( context );
519
520 int currentMatchingBand = -1;
521 QgsDoubleRange currentMatchingRange;
522
523 for ( int band = 1; band <= layer->bandCount(); ++band )
524 {
525 bandScope->setVariable( QStringLiteral( "band" ), band );
526 bandScope->setVariable( QStringLiteral( "band_name" ), layer->dataProvider()->displayBandName( band ) );
527 bandScope->setVariable( QStringLiteral( "band_description" ), layer->dataProvider()->bandDescription( band ) );
528
529 bool ok = false;
530 const double lower = lowerProperty.valueAsDouble( context, 0, &ok );
531 if ( !ok )
532 continue;
533 const double upper = upperProperty.valueAsDouble( context, 0, &ok );
534 if ( !ok )
535 continue;
536
537 const QgsDoubleRange bandRange = QgsDoubleRange( lower, upper );
538 if ( bandRange.overlaps( range ) )
539 {
540 if ( currentMatchingRange.isInfinite()
541 || ( bandRange.includeUpper() && bandRange.upper() >= currentMatchingRange.upper() )
542 || ( !currentMatchingRange.includeUpper() && bandRange.upper() >= currentMatchingRange.upper() ) )
543 {
544 currentMatchingBand = band;
545 currentMatchingRange = bandRange;
546 }
547 }
548 }
549 return currentMatchingBand;
550 }
551 return -1;
552 }
553 }
554 BUILTIN_UNREACHABLE
555}
556
557QgsLineSymbol *QgsRasterLayerElevationProperties::profileLineSymbol() const
558{
559 return mProfileLineSymbol.get();
560}
561
562void QgsRasterLayerElevationProperties::setProfileLineSymbol( QgsLineSymbol *symbol )
563{
564 mProfileLineSymbol.reset( symbol );
565 emit changed();
566 emit profileRenderingPropertyChanged();
567}
568
569QgsFillSymbol *QgsRasterLayerElevationProperties::profileFillSymbol() const
570{
571 return mProfileFillSymbol.get();
572}
573
574void QgsRasterLayerElevationProperties::setProfileFillSymbol( QgsFillSymbol *symbol )
575{
576 mProfileFillSymbol.reset( symbol );
577 emit changed();
578 emit profileRenderingPropertyChanged();
579}
580
581void QgsRasterLayerElevationProperties::setProfileSymbology( Qgis::ProfileSurfaceSymbology symbology )
582{
583 if ( mSymbology == symbology )
584 return;
585
586 mSymbology = symbology;
587 emit changed();
588 emit profileRenderingPropertyChanged();
589}
590
591double QgsRasterLayerElevationProperties::elevationLimit() const
592{
593 return mElevationLimit;
594}
595
596void QgsRasterLayerElevationProperties::setElevationLimit( double limit )
597{
598 if ( qgsDoubleNear( mElevationLimit, limit ) )
599 return;
600
601 mElevationLimit = limit;
602 emit changed();
603 emit profileRenderingPropertyChanged();
604}
605
606bool QgsRasterLayerElevationProperties::layerLooksLikeDem( QgsRasterLayer *layer )
607{
608 // multiple bands => unlikely to be a DEM
609 if ( layer->bandCount() > 1 )
610 return false;
611
612 // raster attribute table => unlikely to be a DEM
613 if ( layer->attributeTable( 1 ) )
614 return false;
615
616 if ( QgsRasterDataProvider *dataProvider = layer->dataProvider() )
617 {
618 // filter out data types which aren't likely to be DEMs
619 switch ( dataProvider->dataType( 1 ) )
620 {
621 case Qgis::DataType::Byte:
622 case Qgis::DataType::UnknownDataType:
623 case Qgis::DataType::CInt16:
624 case Qgis::DataType::CInt32:
625 case Qgis::DataType::CFloat32:
626 case Qgis::DataType::CFloat64:
627 case Qgis::DataType::ARGB32:
628 case Qgis::DataType::ARGB32_Premultiplied:
629 return false;
630
631 case Qgis::DataType::Int8:
632 case Qgis::DataType::UInt16:
633 case Qgis::DataType::Int16:
634 case Qgis::DataType::UInt32:
635 case Qgis::DataType::Int32:
636 case Qgis::DataType::Float32:
637 case Qgis::DataType::Float64:
638 break;
639 }
640 }
641
642 // Check the layer's name for DEM-ish hints.
643 // See discussion at https://github.com/qgis/QGIS/pull/30245 - this list must NOT be translated,
644 // but adding hardcoded localized variants of the strings is encouraged.
645 static const QStringList sPartialCandidates{ QStringLiteral( "dem" ),
646 QStringLiteral( "dtm" ),
647 QStringLiteral( "dsm" ),
648 QStringLiteral( "height" ),
649 QStringLiteral( "elev" ),
650 QStringLiteral( "srtm" ),
651 // French hints
652 QStringLiteral( "mne" ),
653 QStringLiteral( "mnt" ),
654 QStringLiteral( "mns" ),
655 QStringLiteral( "rge" ),
656 QStringLiteral( "alti" ),
657 // German hints
658 QStringLiteral( "dhm" ),
659 QStringLiteral( "dgm" ),
660 QStringLiteral( "dom" ),
661 QStringLiteral( "Höhe" ),
662 QStringLiteral( "Hoehe" ) };
663 const QString layerName = layer->name();
664 for ( const QString &candidate : sPartialCandidates )
665 {
666 if ( layerName.contains( candidate, Qt::CaseInsensitive ) )
667 return true;
668 }
669
670 // these candidates must occur with word boundaries (we don't want to find "aster" in "raster"!)
671 static const QStringList sWordCandidates{ QStringLiteral( "aster" ) };
672 for ( const QString &candidate : sWordCandidates )
673 {
674 const thread_local QRegularExpression re( QStringLiteral( "\\b%1\\b" ).arg( candidate ) );
675 if ( re.match( layerName, Qt::CaseInsensitive ).hasMatch() )
676 return true;
677 }
678
679 return false;
680}
681
682void QgsRasterLayerElevationProperties::setDefaultProfileLineSymbol( const QColor &color )
683{
684 std::unique_ptr< QgsSimpleLineSymbolLayer > profileLineLayer = std::make_unique< QgsSimpleLineSymbolLayer >( color, 0.6 );
685 mProfileLineSymbol = std::make_unique< QgsLineSymbol>( QgsSymbolLayerList( { profileLineLayer.release() } ) );
686}
687
688void QgsRasterLayerElevationProperties::setDefaultProfileFillSymbol( const QColor &color )
689{
690 std::unique_ptr< QgsSimpleFillSymbolLayer > profileFillLayer = std::make_unique< QgsSimpleFillSymbolLayer >( color );
691 profileFillLayer->setStrokeStyle( Qt::NoPen );
692 mProfileFillSymbol = std::make_unique< QgsFillSymbol>( QgsSymbolLayerList( { profileFillLayer.release() } ) );
693}
694
695QMap<int, QgsDoubleRange> QgsRasterLayerElevationProperties::fixedRangePerBand() const
696{
697 return mRangePerBand;
698}
699
700void QgsRasterLayerElevationProperties::setFixedRangePerBand( const QMap<int, QgsDoubleRange> &ranges )
701{
702 if ( ranges == mRangePerBand )
703 return;
704
705 mRangePerBand = ranges;
706 emit changed();
707}
708
709QgsDoubleRange QgsRasterLayerElevationProperties::fixedRange() const
710{
711 return mFixedRange;
712}
713
714void QgsRasterLayerElevationProperties::setFixedRange( const QgsDoubleRange &range )
715{
716 if ( range == mFixedRange )
717 return;
718
719 mFixedRange = range;
720 emit changed();
721}
Qgis::RasterElevationMode
RasterElevationMode
Raster layer elevation modes.
Definition: qgis.h:3277
Qgis::RasterElevationMode::FixedRangePerBand
@ FixedRangePerBand
Layer has a fixed (manually specified) elevation range per band.
Qgis::RasterElevationMode::FixedElevationRange
@ FixedElevationRange
Layer has a fixed elevation range.
Qgis::RasterElevationMode::RepresentsElevationSurface
@ RepresentsElevationSurface
Pixel values represent an elevation surface.
Qgis::RasterElevationMode::DynamicRangePerBand
@ DynamicRangePerBand
Layer has a elevation range per band, calculated dynamically from an expression.
Qgis::DataType::CInt32
@ CInt32
Complex Int32.
Qgis::DataType::Float32
@ Float32
Thirty two bit floating point (float)
Qgis::DataType::CFloat64
@ CFloat64
Complex Float64.
Qgis::DataType::Int16
@ Int16
Sixteen bit signed integer (qint16)
Qgis::DataType::ARGB32_Premultiplied
@ ARGB32_Premultiplied
Color, alpha, red, green, blue, 4 bytes the same as QImage::Format_ARGB32_Premultiplied.
Qgis::DataType::Int8
@ Int8
Eight bit signed integer (qint8) (added in QGIS 3.30)
Qgis::DataType::UInt16
@ UInt16
Sixteen bit unsigned integer (quint16)
Qgis::DataType::Byte
@ Byte
Eight bit unsigned integer (quint8)
Qgis::DataType::UnknownDataType
@ UnknownDataType
Unknown or unspecified type.
Qgis::DataType::ARGB32
@ ARGB32
Color, alpha, red, green, blue, 4 bytes the same as QImage::Format_ARGB32.
Qgis::DataType::Int32
@ Int32
Thirty two bit signed integer (qint32)
Qgis::DataType::Float64
@ Float64
Sixty four bit floating point (double)
Qgis::DataType::CFloat32
@ CFloat32
Complex Float32.
Qgis::DataType::CInt16
@ CInt16
Complex Int16.
Qgis::DataType::UInt32
@ UInt32
Thirty two bit unsigned integer (quint32)
Qgis::ProfileSurfaceSymbology
ProfileSurfaceSymbology
Surface symbology type for elevation profile plots.
Definition: qgis.h:3435
Qgis::ProfileSurfaceSymbology::Line
@ Line
The elevation surface will be rendered using a line symbol.
QgsApplication::colorSchemeRegistry
static QgsColorSchemeRegistry * colorSchemeRegistry()
Returns the application's color scheme registry, used for managing color schemes.
Definition: qgsapplication.cpp:2421
QgsColorSchemeRegistry::fetchRandomStyleColor
QColor fetchRandomStyleColor() const
Returns a random color for use with a new symbol style (e.g.
Definition: qgscolorschemeregistry.cpp:141
QgsDoubleRange
QgsRange which stores a range of double values.
Definition: qgsrange.h:231
QgsDoubleRange::isInfinite
bool isInfinite() const
Returns true if the range consists of all possible values.
Definition: qgsrange.h:285
QgsExpressionContextScope
Single scope for storing variables and functions for use within a QgsExpressionContext.
Definition: qgsexpressioncontext.h:114
QgsExpressionContextScope::addVariable
void addVariable(const QgsExpressionContextScope::StaticVariable &variable)
Adds a variable into the context scope.
Definition: qgsexpressioncontext.cpp:102
QgsExpressionContextScope::setVariable
void setVariable(const QString &name, const QVariant &value, bool isStatic=false)
Convenience method for setting a variable in the context scope by name name and value.
Definition: qgsexpressioncontext.cpp:88
QgsExpressionContextUtils::globalProjectLayerScopes
static QList< QgsExpressionContextScope * > globalProjectLayerScopes(const QgsMapLayer *layer)
Creates a list of three scopes: global, layer's project and layer.
Definition: qgsexpressioncontextutils.cpp:402
QgsExpressionContext
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
Definition: qgsexpressioncontext.h:471
QgsExpressionContext::appendScope
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
Definition: qgsexpressioncontext.cpp:598
QgsExpressionContext::appendScopes
void appendScopes(const QList< QgsExpressionContextScope * > &scopes)
Appends a list of scopes to the end of the context.
Definition: qgsexpressioncontext.cpp:603
QgsFillSymbol
A fill symbol type, for rendering Polygon and MultiPolygon geometries.
Definition: qgsfillsymbol.h:30
QgsLineSymbol
A line symbol type, for rendering LineString and MultiLineString geometries.
Definition: qgslinesymbol.h:30
QgsMapLayerElevationProperties
Base class for storage of map layer elevation properties.
Definition: qgsmaplayerelevationproperties.h:45
QgsMapLayerElevationProperties::mDataDefinedProperties
QgsPropertyCollection mDataDefinedProperties
Property collection for data defined elevation settings.
Definition: qgsmaplayerelevationproperties.h:317
QgsMapLayerElevationProperties::writeCommonProperties
void writeCommonProperties(QDomElement &element, QDomDocument &doc, const QgsReadWriteContext &context)
Writes common class properties to a DOM element, to be used later with readXml().
Definition: qgsmaplayerelevationproperties.cpp:44
QgsMapLayerElevationProperties::profileGenerationPropertyChanged
void profileGenerationPropertyChanged()
Emitted when any of the elevation properties which relate solely to generation of elevation profiles ...
QgsMapLayerElevationProperties::readCommonProperties
void readCommonProperties(const QDomElement &element, const QgsReadWriteContext &context)
Reads common class properties from a DOM element previously written by writeXml().
Definition: qgsmaplayerelevationproperties.cpp:54
QgsMapLayerElevationProperties::changed
void changed()
Emitted when any of the elevation properties have changed.
QgsMapLayerElevationProperties::profileRenderingPropertyChanged
void profileRenderingPropertyChanged()
Emitted when any of the elevation properties which relate solely to presentation of elevation results...
QgsMapLayerElevationProperties::Property::RasterPerBandUpperElevation
@ RasterPerBandUpperElevation
Upper elevation for each raster band (since QGIS 3.38)
QgsMapLayerElevationProperties::Property::RasterPerBandLowerElevation
@ RasterPerBandLowerElevation
Lower elevation for each raster band (since QGIS 3.38)
QgsMapLayer
Base class for all map layer types.
Definition: qgsmaplayer.h:75
QgsMapLayer::name
QString name
Definition: qgsmaplayer.h:78
QgsPropertyCollection::property
QgsProperty property(int key) const final
Returns a matching property from the collection, if one exists.
Definition: qgspropertycollection.cpp:214
QgsProperty
A store for object properties.
Definition: qgsproperty.h:228
QgsProperty::valueAsDouble
double valueAsDouble(const QgsExpressionContext &context, double defaultValue=0.0, bool *ok=nullptr) const
Calculates the current value of the property and interprets it as a double.
Definition: qgsproperty.cpp:687
QgsProperty::prepare
bool prepare(const QgsExpressionContext &context=QgsExpressionContext()) const
Prepares the property against a specified expression context.
Definition: qgsproperty.cpp:419
QgsRange::includeUpper
bool includeUpper() const
Returns true if the upper bound is inclusive, or false if the upper bound is exclusive.
Definition: qgsrange.h:101
QgsRange::overlaps
bool overlaps(const QgsRange< T > &other) const
Returns true if this range overlaps another range.
Definition: qgsrange.h:176
QgsRange::lower
T lower() const
Returns the lower bound of the range.
Definition: qgsrange.h:78
QgsRange::includeLower
bool includeLower() const
Returns true if the lower bound is inclusive, or false if the lower bound is exclusive.
Definition: qgsrange.h:93
QgsRange::upper
T upper() const
Returns the upper bound of the range.
Definition: qgsrange.h:85
QgsRasterDataProvider
Base class for raster data providers.
Definition: qgsrasterdataprovider.h:89
QgsRasterDataProvider::bandDescription
virtual QString bandDescription(int bandNumber)
Returns the description for band bandNumber, or an empty string if the band is not valid or has not d...
Definition: qgsrasterdataprovider.cpp:766
QgsRasterInterface::displayBandName
QString displayBandName(int bandNumber) const
Generates a friendly, descriptive name for the specified bandNumber.
Definition: qgsrasterinterface.cpp:646
QgsRasterLayerElevationProperties
Raster layer specific subclass of QgsMapLayerElevationProperties.
Definition: qgsrasterlayerelevationproperties.h:37
QgsRasterLayerElevationProperties::fixedRange
QgsDoubleRange fixedRange() const
Returns the fixed elevation range for the raster.
Definition: qgsrasterlayerelevationproperties.cpp:709
QgsRasterLayerElevationProperties::setProfileFillSymbol
void setProfileFillSymbol(QgsFillSymbol *symbol)
Sets the fill symbol used to render the raster profile in elevation profile plots.
Definition: qgsrasterlayerelevationproperties.cpp:574
QgsRasterLayerElevationProperties::setFixedRange
void setFixedRange(const QgsDoubleRange &range)
Sets the fixed elevation range for the raster.
Definition: qgsrasterlayerelevationproperties.cpp:714
QgsRasterLayerElevationProperties::elevationRangeForPixelValue
QgsDoubleRange elevationRangeForPixelValue(QgsRasterLayer *layer, int band, double pixelValue) const
Returns the elevation range corresponding to a raw pixel value from the specified band.
Definition: qgsrasterlayerelevationproperties.cpp:416
QgsRasterLayerElevationProperties::mode
Qgis::RasterElevationMode mode() const
Returns the elevation mode.
Definition: qgsrasterlayerelevationproperties.cpp:392
QgsRasterLayerElevationProperties::profileLineSymbol
QgsLineSymbol * profileLineSymbol() const
Returns the line symbol used to render the raster profile in elevation profile plots.
Definition: qgsrasterlayerelevationproperties.cpp:557
QgsRasterLayerElevationProperties::hasElevation
bool hasElevation() const override
Returns true if the layer has an elevation or z component.
Definition: qgsrasterlayerelevationproperties.cpp:39
QgsRasterLayerElevationProperties::clone
QgsRasterLayerElevationProperties * clone() const override
Creates a clone of the properties.
Definition: qgsrasterlayerelevationproperties.cpp:167
QgsRasterLayerElevationProperties::calculateZRange
QgsDoubleRange calculateZRange(QgsMapLayer *layer) const override
Attempts to calculate the overall elevation or z range for the specified layer, using the settings de...
Definition: qgsrasterlayerelevationproperties.cpp:275
QgsRasterLayerElevationProperties::flags
QgsMapLayerElevationProperties::Flags flags() const override
Returns flags associated to the elevation properties.
Definition: qgsrasterlayerelevationproperties.cpp:364
QgsRasterLayerElevationProperties::setBandNumber
void setBandNumber(int band)
Sets the band number from which the elevation should be taken.
Definition: qgsrasterlayerelevationproperties.cpp:406
QgsRasterLayerElevationProperties::bandForElevationRange
int bandForElevationRange(QgsRasterLayer *layer, const QgsDoubleRange &range) const
Returns the band corresponding to the specified range.
Definition: qgsrasterlayerelevationproperties.cpp:477
QgsRasterLayerElevationProperties::htmlSummary
QString htmlSummary() const override
Returns a HTML formatted summary of the properties.
Definition: qgsrasterlayerelevationproperties.cpp:183
QgsRasterLayerElevationProperties::setElevationLimit
void setElevationLimit(double limit)
Sets the elevation limit, which is used when profileSymbology() is Qgis::ProfileSurfaceSymbology::Fil...
Definition: qgsrasterlayerelevationproperties.cpp:596
QgsRasterLayerElevationProperties::setFixedRangePerBand
void setFixedRangePerBand(const QMap< int, QgsDoubleRange > &ranges)
Sets the fixed elevation range for each band.
Definition: qgsrasterlayerelevationproperties.cpp:700
QgsRasterLayerElevationProperties::isVisibleInZRange
bool isVisibleInZRange(const QgsDoubleRange &range, QgsMapLayer *layer=nullptr) const override
Returns true if the layer should be visible and rendered for the specified z range.
Definition: qgsrasterlayerelevationproperties.cpp:214
QgsRasterLayerElevationProperties::setProfileSymbology
void setProfileSymbology(Qgis::ProfileSurfaceSymbology symbology)
Sets the symbology option used to render the raster profile in elevation profile plots.
Definition: qgsrasterlayerelevationproperties.cpp:581
QgsRasterLayerElevationProperties::fixedRangePerBand
QMap< int, QgsDoubleRange > fixedRangePerBand() const
Returns the fixed elevation range for each band.
Definition: qgsrasterlayerelevationproperties.cpp:695
QgsRasterLayerElevationProperties::layerLooksLikeDem
static bool layerLooksLikeDem(QgsRasterLayer *layer)
Returns true if a raster layer looks like a DEM.
Definition: qgsrasterlayerelevationproperties.cpp:606
QgsRasterLayerElevationProperties::writeXml
QDomElement writeXml(QDomElement &element, QDomDocument &doc, const QgsReadWriteContext &context) override
Writes the properties to a DOM element, to be used later with readXml().
Definition: qgsrasterlayerelevationproperties.cpp:44
QgsRasterLayerElevationProperties::profileFillSymbol
QgsFillSymbol * profileFillSymbol() const
Returns the fill symbol used to render the raster profile in elevation profile plots.
Definition: qgsrasterlayerelevationproperties.cpp:569
QgsRasterLayerElevationProperties::elevationLimit
double elevationLimit() const
Returns the elevation limit, which is used when profileSymbology() is Qgis::ProfileSurfaceSymbology::...
Definition: qgsrasterlayerelevationproperties.cpp:591
QgsRasterLayerElevationProperties::setProfileLineSymbol
void setProfileLineSymbol(QgsLineSymbol *symbol)
Sets the line symbol used to render the raster profile in elevation profile plots.
Definition: qgsrasterlayerelevationproperties.cpp:562
QgsRasterLayerElevationProperties::setMode
void setMode(Qgis::RasterElevationMode mode)
Sets the elevation mode.
Definition: qgsrasterlayerelevationproperties.cpp:397
QgsRasterLayerElevationProperties::setEnabled
void setEnabled(bool enabled)
Sets whether the elevation properties are enabled, i.e.
Definition: qgsrasterlayerelevationproperties.cpp:382
QgsRasterLayerElevationProperties::QgsRasterLayerElevationProperties
QgsRasterLayerElevationProperties(QObject *parent)
Constructor for QgsRasterLayerElevationProperties, with the specified parent object.
Definition: qgsrasterlayerelevationproperties.cpp:29
QgsRasterLayerElevationProperties::readXml
bool readXml(const QDomElement &element, const QgsReadWriteContext &context) override
Reads the elevation properties from a DOM element previously written by writeXml().
Definition: qgsrasterlayerelevationproperties.cpp:101
QgsRasterLayerElevationProperties::showByDefaultInElevationProfilePlots
bool showByDefaultInElevationProfilePlots() const override
Returns true if the layer should be visible by default in newly created elevation profile plots.
Definition: qgsrasterlayerelevationproperties.cpp:359
QgsRasterLayer
Represents a raster layer.
Definition: qgsrasterlayer.h:78
QgsRasterLayer::attributeTable
QgsRasterAttributeTable * attributeTable(int bandNumber) const
Returns the (possibly NULL) raster attribute table for the given band bandNumber.
Definition: qgsrasterlayer.cpp:267
QgsRasterLayer::bandCount
int bandCount() const
Returns the number of bands in this layer.
Definition: qgsrasterlayer.cpp:251
QgsRasterLayer::dataProvider
QgsRasterDataProvider * dataProvider() override
Returns the source data provider.
Definition: qgsrasterlayer.cpp:308
QgsReadWriteContext
The class is used as a container of context for various read/write operations on other objects.
Definition: qgsreadwritecontext.h:34
QgsSymbolLayerUtils::saveSymbol
static QDomElement saveSymbol(const QString &symbolName, const QgsSymbol *symbol, QDomDocument &doc, const QgsReadWriteContext &context)
Writes a symbol definition to XML.
Definition: qgssymbollayerutils.cpp:1421
MathUtils::lower
int ANALYSIS_EXPORT lower(int n, int i)
Lower function.
Definition: MathUtils.cpp:337
qgsEnumKeyToValue
T qgsEnumKeyToValue(const QString &key, const T &defaultValue, bool tryValueAsKey=true, bool *returnOk=nullptr)
Returns the value corresponding to the given key of an enum.
Definition: qgis.h:5417
qgsDoubleToString
QString qgsDoubleToString(double a, int precision=17)
Returns a string representation of a double.
Definition: qgis.h:5124
qgsEnumValueToKey
QString qgsEnumValueToKey(const T &value, bool *returnOk=nullptr)
Returns the value for the given key of an enum.
Definition: qgis.h:5398
BUILTIN_UNREACHABLE
#define BUILTIN_UNREACHABLE
Definition: qgis.h:5853
qgsDoubleNear
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition: qgis.h:5207
QgsSymbolLayerList
QList< QgsSymbolLayer * > QgsSymbolLayerList
Definition: qgssymbol.h:30
QgsExpressionContextScope::StaticVariable
Single variable definition for use within a QgsExpressionContextScope.
Definition: qgsexpressioncontext.h:121
Generated by doxygen 1.9.4