QGIS API Documentation  3.21.0-Master (909859188c)
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"
24 #include "qgscolorramplegendnode.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  const QgsRectangle visibleExtent = context.renderContext().extent();
53 
54  const char *ptr = block->data();
55  int count = block->pointCount();
56  const QgsPointCloudAttributeCollection request = block->attributes();
57 
58  const std::size_t recordSize = request.pointRecordSize();
59  int attributeOffset = 0;
60  const QgsPointCloudAttribute *attribute = request.find( mAttribute, attributeOffset );
61  if ( !attribute )
62  return;
63  const QgsPointCloudAttribute::DataType attributeType = attribute->type();
64 
65  const QgsDoubleRange zRange = context.renderContext().zRange();
66  const bool considerZ = !zRange.isInfinite();
67 
68  const bool applyZOffset = attribute->name() == QLatin1String( "Z" );
69  const bool applyXOffset = attribute->name() == QLatin1String( "X" );
70  const bool applyYOffset = attribute->name() == QLatin1String( "Y" );
71 
72  int rendered = 0;
73  double x = 0;
74  double y = 0;
75  double z = 0;
77  const bool reproject = ct.isValid();
78 
79  int red = 0;
80  int green = 0;
81  int blue = 0;
82  int alpha = 0;
83  for ( int i = 0; i < count; ++i )
84  {
85  if ( context.renderContext().renderingStopped() )
86  {
87  break;
88  }
89 
90  if ( considerZ )
91  {
92  // z value filtering is cheapest, if we're doing it...
93  z = pointZ( context, ptr, i );
94  if ( !zRange.contains( z ) )
95  continue;
96  }
97 
98  pointXY( context, ptr, i, x, y );
99  if ( visibleExtent.contains( x, y ) )
100  {
101  if ( reproject )
102  {
103  try
104  {
105  ct.transformInPlace( x, y, z );
106  }
107  catch ( QgsCsException & )
108  {
109  continue;
110  }
111  }
112 
113  double attributeValue = 0;
114  context.getAttribute( ptr, i * recordSize + attributeOffset, attributeType, attributeValue );
115 
116  if ( applyXOffset )
117  attributeValue = context.offset().x() + context.scale().x() * attributeValue;
118  if ( applyYOffset )
119  attributeValue = context.offset().y() + context.scale().y() * attributeValue;
120  if ( applyZOffset )
121  attributeValue = ( context.offset().z() + context.scale().z() * attributeValue ) * context.zValueScale() + context.zValueFixedOffset();
122 
123  mColorRampShader.shade( attributeValue, &red, &green, &blue, &alpha );
124  drawPoint( x, y, QColor( red, green, blue, alpha ), context );
125 
126  rendered++;
127  }
128  }
129  context.incrementPointsRendered( rendered );
130 }
131 
132 
134 {
135  std::unique_ptr< QgsPointCloudAttributeByRampRenderer > r = std::make_unique< QgsPointCloudAttributeByRampRenderer >();
136 
137  r->setAttribute( element.attribute( QStringLiteral( "attribute" ), QStringLiteral( "Intensity" ) ) );
138 
139  QDomElement elemShader = element.firstChildElement( QStringLiteral( "colorrampshader" ) );
140  r->mColorRampShader.readXml( elemShader, context );
141 
142  r->setMinimum( element.attribute( QStringLiteral( "min" ), QStringLiteral( "0" ) ).toDouble() );
143  r->setMaximum( element.attribute( QStringLiteral( "max" ), QStringLiteral( "100" ) ).toDouble() );
144 
145  r->restoreCommonProperties( element, context );
146 
147  return r.release();
148 }
149 
150 QDomElement QgsPointCloudAttributeByRampRenderer::save( QDomDocument &doc, const QgsReadWriteContext &context ) const
151 {
152  QDomElement rendererElem = doc.createElement( QStringLiteral( "renderer" ) );
153 
154  rendererElem.setAttribute( QStringLiteral( "type" ), QStringLiteral( "ramp" ) );
155  rendererElem.setAttribute( QStringLiteral( "min" ), mMin );
156  rendererElem.setAttribute( QStringLiteral( "max" ), mMax );
157 
158  rendererElem.setAttribute( QStringLiteral( "attribute" ), mAttribute );
159 
160  QDomElement elemShader = mColorRampShader.writeXml( doc, context );
161  rendererElem.appendChild( elemShader );
162 
163  saveCommonProperties( rendererElem, context );
164 
165  return rendererElem;
166 }
167 
169 {
170  QSet<QString> res;
171  res << mAttribute;
172  return res;
173 }
174 
175 QList<QgsLayerTreeModelLegendNode *> QgsPointCloudAttributeByRampRenderer::createLegendNodes( QgsLayerTreeLayer *nodeLayer )
176 {
177  QList<QgsLayerTreeModelLegendNode *> res;
178  res << new QgsSimpleLegendNode( nodeLayer, mAttribute );
179 
180  switch ( mColorRampShader.colorRampType() )
181  {
183  // for interpolated shaders we use a ramp legend node unless the settings flag
184  // to use the continuous legend is not set, in that case we fall through
185  if ( mColorRampShader.sourceColorRamp() && ( ! mColorRampShader.legendSettings() || mColorRampShader.legendSettings()->useContinuousLegend() ) )
186  {
187  res << new QgsColorRampLegendNode( nodeLayer, mColorRampShader.sourceColorRamp()->clone(),
188  mColorRampShader.legendSettings() ? *mColorRampShader.legendSettings() : QgsColorRampLegendNodeSettings(),
189  mColorRampShader.minimumValue(),
190  mColorRampShader.maximumValue() );
191  break;
192  }
193  Q_FALLTHROUGH();
196  {
197  // for all others we use itemised lists
198  QList< QPair< QString, QColor > > items;
199  mColorRampShader.legendSymbologyItems( items );
200  res.reserve( items.size() );
201  for ( const QPair< QString, QColor > &item : std::as_const( items ) )
202  {
203  res << new QgsRasterSymbolLegendNode( nodeLayer, item.second, item.first );
204  }
205  break;
206  }
207  }
208  return res;
209 }
210 
212 {
213  return mAttribute;
214 }
215 
217 {
218  mAttribute = attribute;
219 }
220 
222 {
223  return mColorRampShader;
224 }
225 
227 {
228  mColorRampShader = shader;
229 }
230 
232 {
233  return mMin;
234 }
235 
237 {
238  mMin = minimum;
239 }
240 
242 {
243  return mMax;
244 }
245 
247 {
248  mMax = value;
249 }
250 
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.
const QgsColorRampLegendNodeSettings * legendSettings() const
Returns the color ramp shader legend settings.
Type colorRampType() const
Returns the color ramp type.
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 and new RGB value based on one input value.
QgsColorRamp * sourceColorRamp() const
Returns the source color ramp.
@ Interpolated
Interpolates the color between two class breaks linearly.
@ Discrete
Assigns the color of the higher class for every pixel between two class breaks.
@ Exact
Assigns the color of the exact matching value in the color ramp item list.
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, TransformDirection direction=ForwardTransform) const SIP_THROW(QgsCsException)
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.
Definition: qgsexception.h:66
QgsRange which stores a range of double values.
Definition: qgsrange.h:203
bool isInfinite() const
Returns true if the range consists of all possible values.
Definition: qgsrange.h:247
Layer tree node points to a map layer.
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.
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.
Base class for storing raw data from point cloud nodes.
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.
Encapsulates the render context for a 2D point cloud rendering operation.
void getAttribute(const char *data, std::size_t offset, QgsPointCloudAttribute::DataType type, T &value) const
Retrieves the attribute value from data at the specified offset, where type indicates the original da...
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.
void incrementPointsRendered(long count)
Increments the count of points rendered by the specified amount.
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.
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
Abstract base class for 2d point cloud renderers.
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 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:108
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.
Definition: qgsrectangle.h:42
bool contains(const QgsRectangle &rect) const SIP_HOLDGIL
Returns true when rectangle contains other rectangle.
Definition: qgsrectangle.h:363
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...
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context.
const QgsRectangle & extent() const
When rendering a map layer, calling this method returns the "clipping" extent for the layer (in the l...
Implementation of legend node interface for displaying arbitrary label with icon.
static QgsStyle * defaultStyle()
Returns default application-wide style.
Definition: qgsstyle.cpp:131
double y() const
Returns Y coordinate.
Definition: qgsvector3d.h:51
double z() const
Returns Z coordinate.
Definition: qgsvector3d.h:53
double x() const
Returns X coordinate.
Definition: qgsvector3d.h:49