QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgspointcloudattributebyramprenderer.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgspointcloudattributebyramprenderer.h
3 --------------------
4 begin : October 2020
5 copyright : (C) 2020 by Nyall Dawson
6 email : nyall dot dawson 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 "qgspointcloudblock.h"
20#include "qgsstyle.h"
21#include "qgscolorramp.h"
22#include "qgssymbollayerutils.h"
25
27{
28 mColorRampShader.setSourceColorRamp( QgsStyle::defaultStyle()->colorRamp( QStringLiteral( "Viridis" ) ) );
29 mColorRampShader.classifyColorRamp( 5, -1, QgsRectangle(), nullptr );
30}
31
33{
34 return QStringLiteral( "ramp" );
35}
36
38{
39 std::unique_ptr< QgsPointCloudAttributeByRampRenderer > res = std::make_unique< QgsPointCloudAttributeByRampRenderer >();
40 res->mAttribute = mAttribute;
41 res->mColorRampShader = mColorRampShader;
42 res->mMin = mMin;
43 res->mMax = mMax;
44
45 copyCommonProperties( res.get() );
46
47 return res.release();
48}
49
51{
52 QgsRectangle visibleExtent = context.renderContext().extent();
53 if ( renderAsTriangles() )
54 {
55 // we need to include also points slightly outside of the visible extent,
56 // otherwise the triangulation may be missing triangles near the edges and corners
57 visibleExtent.grow( std::max( visibleExtent.width(), visibleExtent.height() ) * 0.05 );
58 }
59
60 const char *ptr = block->data();
61 int count = block->pointCount();
62 const QgsPointCloudAttributeCollection request = block->attributes();
63
64 const std::size_t recordSize = request.pointRecordSize();
65 int attributeOffset = 0;
66 const QgsPointCloudAttribute *attribute = request.find( mAttribute, attributeOffset );
67 if ( !attribute )
68 return;
69 const QgsPointCloudAttribute::DataType attributeType = attribute->type();
70
71 const bool renderElevation = context.renderContext().elevationMap();
72 const QgsDoubleRange zRange = context.renderContext().zRange();
73 const bool considerZ = !zRange.isInfinite() || renderElevation;
74
75 const bool applyZOffset = attribute->name() == QLatin1String( "Z" );
76 const bool applyXOffset = attribute->name() == QLatin1String( "X" );
77 const bool applyYOffset = attribute->name() == QLatin1String( "Y" );
78
79 int rendered = 0;
80 double x = 0;
81 double y = 0;
82 double z = 0;
84 const bool reproject = ct.isValid();
85
86 int red = 0;
87 int green = 0;
88 int blue = 0;
89 int alpha = 0;
90 for ( int i = 0; i < count; ++i )
91 {
92 if ( context.renderContext().renderingStopped() )
93 {
94 break;
95 }
96
97 if ( considerZ )
98 {
99 // z value filtering is cheapest, if we're doing it...
100 z = pointZ( context, ptr, i );
101 if ( !zRange.contains( z ) )
102 continue;
103 }
104
105 pointXY( context, ptr, i, x, y );
106 if ( visibleExtent.contains( x, y ) )
107 {
108 if ( reproject )
109 {
110 try
111 {
112 ct.transformInPlace( x, y, z );
113 }
114 catch ( QgsCsException & )
115 {
116 continue;
117 }
118 }
119
120 double attributeValue = 0;
121 context.getAttribute( ptr, i * recordSize + attributeOffset, attributeType, attributeValue );
122
123 if ( applyXOffset )
124 attributeValue = context.offset().x() + context.scale().x() * attributeValue;
125 if ( applyYOffset )
126 attributeValue = context.offset().y() + context.scale().y() * attributeValue;
127 if ( applyZOffset )
128 attributeValue = ( context.offset().z() + context.scale().z() * attributeValue ) * context.zValueScale() + context.zValueFixedOffset();
129
130 mColorRampShader.shade( attributeValue, &red, &green, &blue, &alpha );
131
132 if ( renderAsTriangles() )
133 {
134 addPointToTriangulation( x, y, z, QColor( red, green, blue, alpha ), context );
135
136 // We don't want to render any points if we're rendering triangles and there is no preview painter
137 if ( !context.renderContext().previewRenderPainter() )
138 continue;
139 }
140
141 drawPoint( x, y, QColor( red, green, blue, alpha ), context );
142 if ( renderElevation )
143 drawPointToElevationMap( x, y, z, context );
144
145 rendered++;
146 }
147 }
148 context.incrementPointsRendered( rendered );
149}
150
151
153{
154 std::unique_ptr< QgsPointCloudAttributeByRampRenderer > r = std::make_unique< QgsPointCloudAttributeByRampRenderer >();
155
156 r->setAttribute( element.attribute( QStringLiteral( "attribute" ), QStringLiteral( "Intensity" ) ) );
157
158 QDomElement elemShader = element.firstChildElement( QStringLiteral( "colorrampshader" ) );
159 r->mColorRampShader.readXml( elemShader, context );
160
161 r->setMinimum( element.attribute( QStringLiteral( "min" ), QStringLiteral( "0" ) ).toDouble() );
162 r->setMaximum( element.attribute( QStringLiteral( "max" ), QStringLiteral( "100" ) ).toDouble() );
163
164 r->restoreCommonProperties( element, context );
165
166 return r.release();
167}
168
169QDomElement QgsPointCloudAttributeByRampRenderer::save( QDomDocument &doc, const QgsReadWriteContext &context ) const
170{
171 QDomElement rendererElem = doc.createElement( QStringLiteral( "renderer" ) );
172
173 rendererElem.setAttribute( QStringLiteral( "type" ), QStringLiteral( "ramp" ) );
174 rendererElem.setAttribute( QStringLiteral( "min" ), mMin );
175 rendererElem.setAttribute( QStringLiteral( "max" ), mMax );
176
177 rendererElem.setAttribute( QStringLiteral( "attribute" ), mAttribute );
178
179 QDomElement elemShader = mColorRampShader.writeXml( doc, context );
180 rendererElem.appendChild( elemShader );
181
182 saveCommonProperties( rendererElem, context );
183
184 return rendererElem;
185}
186
188{
189 QSet<QString> res;
190 res << mAttribute;
191 return res;
192}
193
194QList<QgsLayerTreeModelLegendNode *> QgsPointCloudAttributeByRampRenderer::createLegendNodes( QgsLayerTreeLayer *nodeLayer )
195{
196 QList<QgsLayerTreeModelLegendNode *> res;
197 res << new QgsSimpleLegendNode( nodeLayer, mAttribute );
198
199 switch ( mColorRampShader.colorRampType() )
200 {
202 // for interpolated shaders we use a ramp legend node unless the settings flag
203 // to use the continuous legend is not set, in that case we fall through
204 if ( mColorRampShader.sourceColorRamp() && ( ! mColorRampShader.legendSettings() || mColorRampShader.legendSettings()->useContinuousLegend() ) )
205 {
206 res << new QgsColorRampLegendNode( nodeLayer, mColorRampShader.sourceColorRamp()->clone(),
207 mColorRampShader.legendSettings() ? *mColorRampShader.legendSettings() : QgsColorRampLegendNodeSettings(),
208 mColorRampShader.minimumValue(),
209 mColorRampShader.maximumValue() );
210 break;
211 }
212 [[fallthrough]];
215 {
216 // for all others we use itemised lists
217 QList< QPair< QString, QColor > > items;
218 mColorRampShader.legendSymbologyItems( items );
219 res.reserve( items.size() );
220 for ( const QPair< QString, QColor > &item : std::as_const( items ) )
221 {
222 res << new QgsRasterSymbolLegendNode( nodeLayer, item.second, item.first );
223 }
224 break;
225 }
226 }
227 return res;
228}
229
231{
232 return mAttribute;
233}
234
236{
237 mAttribute = attribute;
238}
239
244
246{
247 mColorRampShader = shader;
248}
249
251{
252 return mMin;
253}
254
256{
257 mMin = minimum;
258}
259
261{
262 return mMax;
263}
264
266{
267 mMax = value;
268}
269
270std::unique_ptr<QgsPreparedPointCloudRendererData> QgsPointCloudAttributeByRampRenderer::prepare()
271{
272 std::unique_ptr< QgsPointCloudAttributeByRampRendererPreparedData> data = std::make_unique< QgsPointCloudAttributeByRampRendererPreparedData >();
273 data->attributeName = mAttribute;
274 data->colorRampShader = mColorRampShader;
275
276 data->attributeIsX = mAttribute == QLatin1String( "X" );
277 data->attributeIsY = mAttribute == QLatin1String( "Y" );
278 data->attributeIsZ = mAttribute == QLatin1String( "Z" );
279 return data;
280}
281
283{
284 double attributeValue = 0;
285 if ( attributeIsZ )
286 attributeValue = z;
287 else
289
290 if ( attributeIsX )
291 attributeValue = block->offset().x() + block->scale().x() * attributeValue;
292 else if ( attributeIsY )
293 attributeValue = block->offset().y() + block->scale().y() * attributeValue;
294
295 int red = 0;
296 int green = 0;
297 int blue = 0;
298 int alpha = 0;
299 colorRampShader.shade( attributeValue, &red, &green, &blue, &alpha );
300 return QColor( red, green, blue, alpha );
301}
302
307
309{
310 const QgsPointCloudAttributeCollection attributes = block->attributes();
311 const QgsPointCloudAttribute *attribute = attributes.find( attributeName, attributeOffset );
312 if ( !attribute )
313 return false;
314
315 attributeType = attribute->type();
316 return true;
317}
@ Exact
Assigns the color of the exact matching value in the color ramp item list.
@ Linear
Interpolates the color between two class breaks linearly.
@ Discrete
Assigns the color of the higher class for every pixel between two class breaks.
Settings for a color ramp legend node.
bool useContinuousLegend() const
Returns true if a continuous gradient legend will be used.
A legend node which renders a color ramp.
A ramp shader will color a raster pixel based on a list of values ranges in a ramp.
void legendSymbologyItems(QList< QPair< QString, QColor > > &symbolItems) const override
Returns legend symbology items if provided by renderer.
Qgis::ShaderInterpolationMethod colorRampType() const
Returns the color ramp interpolation method.
const QgsColorRampLegendNodeSettings * legendSettings() const
Returns the color ramp shader legend settings.
void setSourceColorRamp(QgsColorRamp *colorramp)
Set the source color ramp.
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context=QgsReadWriteContext()) const
Writes configuration to a new DOM element.
bool shade(double value, int *returnRedValue, int *returnGreenValue, int *returnBlueValue, int *returnAlphaValue) const override
Generates an new RGBA value based on one input value.
QgsColorRamp * sourceColorRamp() const
Returns the source color ramp.
void classifyColorRamp(int classes=0, int band=-1, const QgsRectangle &extent=QgsRectangle(), QgsRasterInterface *input=nullptr)
Classify color ramp shader.
virtual QgsColorRamp * clone() const =0
Creates a clone of the color ramp.
Class for doing transforms between two map coordinate systems.
void transformInPlace(double &x, double &y, double &z, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward) const
Transforms an array of x, y and z double coordinates in place, from the source CRS to the destination...
bool isValid() const
Returns true if the coordinate transform is valid, ie both the source and destination CRS have been s...
Custom exception class for Coordinate Reference System related exceptions.
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
Layer tree node points to a map layer.
QColor pointColor(const QgsPointCloudBlock *block, int i, double z) override
An optimised method of retrieving the color of a point from a point cloud block.
bool prepareBlock(const QgsPointCloudBlock *block) override
Prepares the renderer for using the specified block.
QSet< QString > usedAttributes() const override
Returns the set of attributes used by the prepared point cloud renderer.
QString type() const override
Returns the identifier of the renderer type.
void setMaximum(double maximum)
Sets the maximum value for attributes which will be used by the color ramp shader.
QgsPointCloudRenderer * clone() const override
Create a deep copy of this renderer.
static QgsPointCloudRenderer * create(QDomElement &element, const QgsReadWriteContext &context)
Creates an RGB renderer from an XML element.
void renderBlock(const QgsPointCloudBlock *block, QgsPointCloudRenderContext &context) override
Renders a block of point cloud data using the specified render context.
void setMinimum(double minimum)
Sets the minimum value for attributes which will be used by the color ramp shader.
QgsPointCloudAttributeByRampRenderer()
Constructor for QgsPointCloudAttributeByRampRenderer.
QDomElement save(QDomDocument &doc, const QgsReadWriteContext &context) const override
Saves the renderer configuration to an XML element.
double maximum() const
Returns the maximum value for attributes which will be used by the color ramp shader.
QList< QgsLayerTreeModelLegendNode * > createLegendNodes(QgsLayerTreeLayer *nodeLayer) override
Creates a set of legend nodes representing the renderer.
void setColorRampShader(const QgsColorRampShader &shader)
Sets the color ramp shader function used to visualize the attribute.
QSet< QString > usedAttributes(const QgsPointCloudRenderContext &context) const override
Returns a list of attributes required by this renderer.
std::unique_ptr< QgsPreparedPointCloudRendererData > prepare() override
Returns prepared data container for bulk point color retrieval.
QgsColorRampShader colorRampShader() const
Returns the color ramp shader function used to visualize the attribute.
double minimum() const
Returns the minimum value for attributes which will be used by the color ramp shader.
QString attribute() const
Returns the attribute to use for the renderer.
void setAttribute(const QString &attribute)
Sets the attribute to use for the renderer.
Collection of point cloud attributes.
int pointRecordSize() const
Returns total size of record.
const QgsPointCloudAttribute * find(const QString &attributeName, int &offset) const
Finds the attribute with the name.
Attribute for point cloud data pair of name and size in bytes.
DataType
Systems of unit measurement.
DataType type() const
Returns the data type.
Base class for storing raw data from point cloud nodes.
QgsVector3D scale() const
Returns the custom scale of the block.
const char * data() const
Returns raw pointer to data.
QgsPointCloudAttributeCollection attributes() const
Returns the attributes that are stored in the data block, along with their size.
int pointCount() const
Returns number of points that are stored in the block.
int pointRecordSize() const
Returns the total size of each individual point record.
QgsVector3D offset() const
Returns the custom offset of the block.
Encapsulates the render context for a 2D point cloud rendering operation.
double zValueFixedOffset() const
Returns any constant offset which must be applied to z values taken from the point cloud index.
QgsVector3D offset() const
Returns the offset of the layer's int32 coordinates compared to CRS coords.
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
void incrementPointsRendered(long count)
Increments the count of points rendered by the specified amount.
static void getAttribute(const char *data, std::size_t offset, QgsPointCloudAttribute::DataType type, T &value)
Retrieves the attribute value from data at the specified offset, where type indicates the original da...
double zValueScale() const
Returns any constant scaling factor which must be applied to z values taken from the point cloud inde...
QgsVector3D scale() const
Returns the scale of the layer's int32 coordinates compared to CRS coords.
Abstract base class for 2d point cloud renderers.
bool renderAsTriangles() const
Returns whether points are triangulated to render solid surface.
void drawPointToElevationMap(double x, double y, double z, QgsPointCloudRenderContext &context) const
Draws a point at the elevation z using at the specified x and y (in map coordinates) on the elevation...
void saveCommonProperties(QDomElement &element, const QgsReadWriteContext &context) const
Saves common renderer properties (such as point size and screen error) to the specified DOM element.
void addPointToTriangulation(double x, double y, double z, const QColor &color, QgsPointCloudRenderContext &context)
Adds a point to the list of points to be triangulated (only used when renderAsTriangles() is enabled)
void copyCommonProperties(QgsPointCloudRenderer *destination) const
Copies common point cloud properties (such as point size and screen error) to the destination rendere...
void drawPoint(double x, double y, const QColor &color, QgsPointCloudRenderContext &context) const
Draws a point using a color at the specified x and y (in map coordinates).
static double pointZ(QgsPointCloudRenderContext &context, const char *ptr, int i)
Retrieves the z value for the point at index i.
static void pointXY(QgsPointCloudRenderContext &context, const char *ptr, int i, double &x, double &y)
Retrieves the x and y coordinate for the point at index i.
bool contains(const QgsRange< T > &other) const
Returns true if this range contains another range.
Definition qgsrange.h:137
double maximumValue() const
Returns the minimum value for the raster shader.
double minimumValue() const
Returns the maximum value for the raster shader.
Implementation of legend node interface for displaying raster legend entries.
The class is used as a container of context for various read/write operations on other objects.
A rectangle specified with double values.
bool contains(const QgsRectangle &rect) const
Returns true when rectangle contains other rectangle.
double width() const
Returns the width of the rectangle.
void grow(double delta)
Grows the rectangle in place by the specified amount.
double height() const
Returns the height of the rectangle.
QgsElevationMap * elevationMap() const
Returns the destination elevation map for the render operation.
const QgsRectangle & extent() const
When rendering a map layer, calling this method returns the "clipping" extent for the layer (in the l...
QgsDoubleRange zRange() const
Returns the range of z-values which should be rendered.
bool renderingStopped() const
Returns true if the rendering operation has been stopped and any ongoing rendering should be canceled...
QPainter * previewRenderPainter()
Returns the const destination QPainter for temporary in-progress preview renders.
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context.
Implementation of legend node interface for displaying arbitrary label with icon.
static QgsStyle * defaultStyle(bool initialize=true)
Returns the default application-wide style.
Definition qgsstyle.cpp:145
double y() const
Returns Y coordinate.
Definition qgsvector3d.h:50
double z() const
Returns Z coordinate.
Definition qgsvector3d.h:52
double x() const
Returns X coordinate.
Definition qgsvector3d.h:48