QGIS API Documentation 3.39.0-Master (67e056379ed)
Loading...
Searching...
No Matches
qgspointcloudlayerelevationproperties.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgspointcloudlayerelevationproperties.cpp
3 ---------------
4 begin : November 2020
5 copyright : (C) 2020 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
19#include "qgspointcloudlayer.h"
20#include "qgsapplication.h"
22#include "qgscolorutils.h"
23
26{
28
29 if ( QgsPointCloudLayer *pcLayer = qobject_cast< QgsPointCloudLayer * >( parent ) )
30 {
31 connect( pcLayer, &QgsPointCloudLayer::rendererChanged, this, [this]
32 {
33 if ( mRespectLayerColors )
35 } );
36 }
37}
38
40{
41 return true;
42}
43
44QDomElement QgsPointCloudLayerElevationProperties::writeXml( QDomElement &parentElement, QDomDocument &document, const QgsReadWriteContext &context )
45{
46 QDomElement element = document.createElement( QStringLiteral( "elevation" ) );
47 writeCommonProperties( element, document, context );
48
49 element.setAttribute( QStringLiteral( "max_screen_error" ), qgsDoubleToString( mMaximumScreenError ) );
50 element.setAttribute( QStringLiteral( "max_screen_error_unit" ), QgsUnitTypes::encodeUnit( mMaximumScreenErrorUnit ) );
51 element.setAttribute( QStringLiteral( "point_size" ), qgsDoubleToString( mPointSize ) );
52 element.setAttribute( QStringLiteral( "point_size_unit" ), QgsUnitTypes::encodeUnit( mPointSizeUnit ) );
53 element.setAttribute( QStringLiteral( "point_symbol" ), qgsEnumValueToKey( mPointSymbol ) );
54 element.setAttribute( QStringLiteral( "point_color" ), QgsColorUtils::colorToString( mPointColor ) );
55 element.setAttribute( QStringLiteral( "respect_layer_colors" ), mRespectLayerColors ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
56 element.setAttribute( QStringLiteral( "opacity_by_distance" ), mApplyOpacityByDistanceEffect ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
57
58 parentElement.appendChild( element );
59 return element;
60}
61
62bool QgsPointCloudLayerElevationProperties::readXml( const QDomElement &element, const QgsReadWriteContext &context )
63{
64 const QDomElement elevationElement = element.firstChildElement( QStringLiteral( "elevation" ) ).toElement();
65 readCommonProperties( elevationElement, context );
66
67 mMaximumScreenError = elevationElement.attribute( QStringLiteral( "max_screen_error" ), QStringLiteral( "0.3" ) ).toDouble();
68 bool ok = false;
69 mMaximumScreenErrorUnit = QgsUnitTypes::decodeRenderUnit( elevationElement.attribute( QStringLiteral( "max_screen_error_unit" ) ), &ok );
70 if ( !ok )
71 mMaximumScreenErrorUnit = Qgis::RenderUnit::Millimeters;
72 mPointSize = elevationElement.attribute( QStringLiteral( "point_size" ), QStringLiteral( "0.6" ) ).toDouble();
73 mPointSizeUnit = QgsUnitTypes::decodeRenderUnit( elevationElement.attribute( QStringLiteral( "point_size_unit" ) ), &ok );
74 if ( !ok )
75 mPointSizeUnit = Qgis::RenderUnit::Millimeters;
76 mPointSymbol = qgsEnumKeyToValue( elevationElement.attribute( QStringLiteral( "point_symbol" ) ), Qgis::PointCloudSymbol::Square );
77 const QString colorString = elevationElement.attribute( QStringLiteral( "point_color" ) );
78 if ( !colorString.isEmpty() )
79 {
80 mPointColor = QgsColorUtils::colorFromString( elevationElement.attribute( QStringLiteral( "point_color" ) ) );
81 }
82 else
83 {
85 }
86 mRespectLayerColors = elevationElement.attribute( QStringLiteral( "respect_layer_colors" ), QStringLiteral( "1" ) ).toInt();
87 mApplyOpacityByDistanceEffect = elevationElement.attribute( QStringLiteral( "opacity_by_distance" ) ).toInt();
88
89 return true;
90}
91
93{
94 std::unique_ptr< QgsPointCloudLayerElevationProperties > res = std::make_unique< QgsPointCloudLayerElevationProperties >( nullptr );
95 res->copyCommonProperties( this );
96
97 res->mMaximumScreenError = mMaximumScreenError;
98 res->mMaximumScreenErrorUnit = mMaximumScreenErrorUnit;
99 res->mPointSize = mPointSize;
100 res->mPointSizeUnit = mPointSizeUnit;
101 res->mPointSymbol = mPointSymbol;
102 res->mPointColor = mPointColor;
103 res->mRespectLayerColors = mRespectLayerColors;
104 res->mApplyOpacityByDistanceEffect = mApplyOpacityByDistanceEffect;
105
106 return res.release();
107}
108
110{
111 QStringList properties;
112 properties << tr( "Scale: %1" ).arg( mZScale );
113 properties << tr( "Offset: %1" ).arg( mZOffset );
114 return QStringLiteral( "<ul><li>%1</li></ul>" ).arg( properties.join( QLatin1String( "</li><li>" ) ) );
115}
116
118{
119 // TODO -- test actual point cloud z range
120 return true;
121}
122
124{
125 if ( QgsPointCloudLayer *pcLayer = qobject_cast< QgsPointCloudLayer * >( layer ) )
126 {
127 if ( pcLayer->dataProvider() )
128 {
129 const QgsPointCloudStatistics stats = pcLayer->statistics();
130
131 // try to fetch z range from provider metadata
132 const double zMin = stats.minimum( QStringLiteral( "Z" ) );
133 const double zMax = stats.maximum( QStringLiteral( "Z" ) );
134 if ( !std::isnan( zMin ) && !std::isnan( zMax ) )
135 {
136 return QgsDoubleRange( zMin * mZScale + mZOffset, zMax * mZScale + mZOffset );
137 }
138 }
139 }
140
141 return QgsDoubleRange();
142}
143
145{
146 const QgsDoubleRange range = calculateZRange( layer );
147 if ( !range.isInfinite() && range.lower() != range.upper() )
148 return {range.lower(), range.upper() };
149 else if ( !range.isInfinite() )
150 return {range.lower() };
151 else
152 return {};
153}
154
159
161{
162 if ( qgsDoubleNear( error, mMaximumScreenError ) )
163 return;
164
165 mMaximumScreenError = error;
166 emit changed();
168}
169
171{
172 if ( unit == mMaximumScreenErrorUnit )
173 return;
174
175 mMaximumScreenErrorUnit = unit;
176 emit changed();
178}
179
184
186{
187 if ( mPointSymbol == symbol )
188 return;
189
190 mPointSymbol = symbol;
191 emit changed();
193}
194
196{
197 if ( color == mPointColor )
198 return;
199
200 mPointColor = color;
201 emit changed();
203}
204
206{
207 if ( apply == mApplyOpacityByDistanceEffect )
208 return;
209
210 mApplyOpacityByDistanceEffect = apply;
211 emit changed();
212
213 // turning ON opacity by distance requires a profile regeneration, turning it off does not.
214 if ( mApplyOpacityByDistanceEffect )
216 else
218}
219
221{
222 if ( qgsDoubleNear( size, mPointSize ) )
223 return;
224
225 mPointSize = size;
226 emit changed();
228}
229
231{
232 if ( mPointSizeUnit == units )
233 return;
234
235 mPointSizeUnit = units;
236 emit changed();
238}
239
241{
242 if ( mRespectLayerColors == enabled )
243 return;
244
245 mRespectLayerColors = enabled;
246 emit changed();
247
248 // turning ON respect layer colors requires a profile regeneration, turning it off does not.
249 if ( mRespectLayerColors )
251 else
253}
PointCloudSymbol
Rendering symbols for point cloud points.
Definition qgis.h:3659
@ Square
Renders points as squares.
RenderUnit
Rendering size units.
Definition qgis.h:4494
@ Millimeters
Millimeters.
static QgsColorSchemeRegistry * colorSchemeRegistry()
Returns the application's color scheme registry, used for managing color schemes.
QColor fetchRandomStyleColor() const
Returns a random color for use with a new symbol style (e.g.
static QColor colorFromString(const QString &string)
Decodes a string into a color value.
static QString colorToString(const QColor &color)
Encodes a color into a string value.
QgsRange which stores a range of double values.
Definition qgsrange.h:231
bool isInfinite() const
Returns true if the range consists of all possible values.
Definition qgsrange.h:285
Base class for storage of map layer elevation properties.
void writeCommonProperties(QDomElement &element, QDomDocument &doc, const QgsReadWriteContext &context)
Writes common class properties to a DOM element, to be used later with readXml().
void profileGenerationPropertyChanged()
Emitted when any of the elevation properties which relate solely to generation of elevation profiles ...
void readCommonProperties(const QDomElement &element, const QgsReadWriteContext &context)
Reads common class properties from a DOM element previously written by writeXml().
void changed()
Emitted when any of the elevation properties have changed.
void profileRenderingPropertyChanged()
Emitted when any of the elevation properties which relate solely to presentation of elevation results...
Base class for all map layer types.
Definition qgsmaplayer.h:75
void rendererChanged()
Signal emitted when renderer is changed.
Point cloud layer specific subclass of QgsMapLayerElevationProperties.
void setRespectLayerColors(bool enabled)
Sets whether layer coloring should be respected when rendering elevation profile plots.
QString htmlSummary() const override
Returns a HTML formatted summary of the properties.
void setPointColor(const QColor &color)
Sets the color used drawing points in elevation profile charts.
bool showByDefaultInElevationProfilePlots() const override
Returns true if the layer should be visible by default in newly created elevation profile plots.
bool hasElevation() const override
Returns true if the layer has an elevation or z component.
void setApplyOpacityByDistanceEffect(bool apply)
Sets whether a reduced opacity by distance from profile curve effect should be applied when drawing p...
QDomElement writeXml(QDomElement &element, QDomDocument &doc, const QgsReadWriteContext &context) override
Writes the properties to a DOM element, to be used later with readXml().
void setPointSize(double size)
Sets the point size used for drawing points in elevation profile charts.
bool readXml(const QDomElement &element, const QgsReadWriteContext &context) override
Reads the elevation properties from a DOM element previously written by writeXml().
void setPointSymbol(Qgis::PointCloudSymbol symbol)
Sets the symbol used drawing points in elevation profile charts.
QgsDoubleRange calculateZRange(QgsMapLayer *layer) const override
Attempts to calculate the overall elevation or z range for the specified layer, using the settings de...
void setMaximumScreenError(double error)
Sets the maximum screen error allowed when generating elevation profiles for the point cloud.
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.
void setPointSizeUnit(const Qgis::RenderUnit units)
Sets the units used for the point size used for drawing points in elevation profile charts.
QgsPointCloudLayerElevationProperties * clone() const override
Creates a clone of the properties.
void setMaximumScreenErrorUnit(Qgis::RenderUnit unit)
Sets the unit for the maximum screen error allowed when generating elevation profiles for the point c...
QList< double > significantZValues(QgsMapLayer *layer) const override
Returns a list of significant elevation/z-values for the specified layer, using the settings defined ...
Qgis::PointCloudSymbol pointSymbol() const
Returns the symbol used drawing points in elevation profile charts.
QgsPointCloudLayerElevationProperties(QObject *parent)
Constructor for QgsPointCloudLayerElevationProperties, with the specified parent object.
Represents a map layer supporting display of point clouds.
Class used to store statistics of a point cloud dataset.
double maximum(const QString &attribute) const
Returns the maximum value for the attribute attribute If no matching statistic is available then NaN ...
double minimum(const QString &attribute) const
Returns the minimum value for the attribute attribute If no matching statistic is available then NaN ...
T lower() const
Returns the lower bound of the range.
Definition qgsrange.h:78
T upper() const
Returns the upper bound of the range.
Definition qgsrange.h:85
The class is used as a container of context for various read/write operations on other objects.
static Q_INVOKABLE Qgis::RenderUnit decodeRenderUnit(const QString &string, bool *ok=nullptr)
Decodes a render unit from a string.
static Q_INVOKABLE QString encodeUnit(Qgis::DistanceUnit unit)
Encodes a distance unit to a string.
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:5675
QString qgsDoubleToString(double a, int precision=17)
Returns a string representation of a double.
Definition qgis.h:5382
QString qgsEnumValueToKey(const T &value, bool *returnOk=nullptr)
Returns the value for the given key of an enum.
Definition qgis.h:5656
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition qgis.h:5465