QGIS API Documentation 3.41.0-Master (d5b93354e9c)
Loading...
Searching...
No Matches
qgspointcloudrenderer.h
Go to the documentation of this file.
1/***************************************************************************
2 qgspointcloudrenderer.h
3 --------------------
4 begin : October 2020
5 copyright : (C) 2020 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#ifndef QGSPOINTCLOUDRENDERER_H
19#define QGSPOINTCLOUDRENDERER_H
20
21#include "qgsrendercontext.h"
22
23#include "qgis_core.h"
24#include "qgis_sip.h"
25#include "qgsvector3d.h"
27
32class QgsElevationMap;
33
43{
44 public:
45
58 QgsPointCloudRenderContext( QgsRenderContext &context, const QgsVector3D &scale, const QgsVector3D &offset,
59 double zValueScale, double zValueFixedOffset, QgsFeedback *feedback = nullptr );
60
63
67 QgsRenderContext &renderContext() { return mRenderContext; }
68
73 const QgsRenderContext &renderContext() const SIP_SKIP { return mRenderContext; }
74
78 QgsVector3D scale() const { return mScale; }
79
84 void setScale( const QgsVector3D &scale ) { mScale = scale; }
85
89 QgsVector3D offset() const { return mOffset; }
90
95 void setOffset( const QgsVector3D &offset ) { mOffset = offset; }
96
100 long pointsRendered() const;
101
108 void incrementPointsRendered( long count );
109
115 QgsPointCloudAttributeCollection attributes() const { return mAttributes; }
116
122 void setAttributes( const QgsPointCloudAttributeCollection &attributes );
123
127 int pointRecordSize() const { return mPointRecordSize; }
128
135 int xOffset() const { return mXOffset; }
136
143 int yOffset() const { return mYOffset; }
144
151 int zOffset() const { return mZOffset; }
152
158 double zValueScale() const { return mZValueScale; }
159
165 double zValueFixedOffset() const { return mZValueFixedOffset; }
166
172 QgsFeedback *feedback() const { return mFeedback; }
173
174#ifndef SIP_RUN
175
180 template <typename T>
181 static void getAttribute( const char *data, std::size_t offset, QgsPointCloudAttribute::DataType type, T &value )
182 {
183 switch ( type )
184 {
186 value = *reinterpret_cast< const unsigned char * >( data + offset );
187 return;
189 value = *( data + offset );
190 return;
191
193 value = *reinterpret_cast< const quint32 * >( data + offset );
194 return;
196 value = *reinterpret_cast< const qint32 * >( data + offset );
197 return;
198
200 value = *reinterpret_cast< const quint64 * >( data + offset );
201 return;
203 value = *reinterpret_cast< const qint64 * >( data + offset );
204 return;
205
207 value = *reinterpret_cast< const short * >( data + offset );
208 return;
209
211 value = *reinterpret_cast< const unsigned short * >( data + offset );
212 return;
213
215 value = *reinterpret_cast< const float * >( data + offset );
216 return;
217
219 value = *reinterpret_cast< const double * >( data + offset );
220 return;
221 }
222 }
223#endif
224
225#ifndef SIP_RUN // this is only meant for low-level rendering in C++ code
226
234 {
235 std::vector<double> points;
236 std::vector<QRgb> colors;
237 std::vector<float> elevations;
238 };
239
244 TriangulationData &triangulationData() { return mTriangulationData; }
245#endif
246
247 private:
248#ifdef SIP_RUN
250#endif
251
252 QgsRenderContext &mRenderContext;
253 QgsVector3D mScale;
254 QgsVector3D mOffset;
255 long mPointsRendered = 0;
257 int mPointRecordSize = 0;
258 int mXOffset = 0;
259 int mYOffset = 0;
260 int mZOffset = 0;
261 double mZValueScale = 1.0;
262 double mZValueFixedOffset = 0;
263
264 QgsFeedback *mFeedback = nullptr;
265
266 TriangulationData mTriangulationData;
267};
268
269#ifndef SIP_RUN
270
281{
282 public:
283
285
289 virtual QSet< QString > usedAttributes() const = 0;
290
296 virtual bool prepareBlock( const QgsPointCloudBlock *block ) = 0;
297
305 virtual QColor pointColor( const QgsPointCloudBlock *block, int i, double z ) = 0;
306
307};
308
309#endif
310
311
320class CORE_EXPORT QgsPointCloudRenderer
321{
322
323#ifdef SIP_RUN
325
326 const QString type = sipCpp->type();
327
328 if ( type == QLatin1String( "rgb" ) )
329 sipType = sipType_QgsPointCloudRgbRenderer;
330 else if ( type == QLatin1String( "ramp" ) )
331 sipType = sipType_QgsPointCloudAttributeByRampRenderer;
332 else if ( type == QLatin1String( "classified" ) )
333 sipType = sipType_QgsPointCloudClassifiedRenderer;
334 else if ( type == QLatin1String( "extent" ) )
335 sipType = sipType_QgsPointCloudExtentRenderer;
336 else
337 sipType = 0;
338 SIP_END
339#endif
340
341 public:
342
344
345 virtual ~QgsPointCloudRenderer() = default;
346
350 virtual QString type() const = 0;
351
357
360
363
367 virtual void renderBlock( const QgsPointCloudBlock *block, QgsPointCloudRenderContext &context ) = 0;
368
378 QVector<QVariantMap> identify( QgsPointCloudLayer *layer, const QgsRenderContext &context, const QgsGeometry &geometry, double toleranceForPointIdentification = 0 ) SIP_SKIP;
379
385 virtual bool willRenderPoint( const QMap<QString, QVariant> &pointAttributes )
386 {
387 Q_UNUSED( pointAttributes );
388 return true;
389 }
390
398 static QgsPointCloudRenderer *load( QDomElement &element, const QgsReadWriteContext &context ) SIP_FACTORY;
399
404 virtual QDomElement save( QDomDocument &doc, const QgsReadWriteContext &context ) const = 0;
405
413 virtual QSet< QString > usedAttributes( const QgsPointCloudRenderContext &context ) const;
414
421 virtual std::unique_ptr< QgsPreparedPointCloudRendererData > prepare() SIP_SKIP;
422
432 virtual void startRender( QgsPointCloudRenderContext &context );
433
444 virtual void stopRender( QgsPointCloudRenderContext &context );
445
451 virtual bool legendItemChecked( const QString &key );
452
458 virtual void checkLegendItem( const QString &key, bool state = true );
459
466 void setPointSize( double size ) { mPointSize = size; }
467
477 double pointSize() const { return mPointSize; }
478
486 void setPointSizeUnit( const Qgis::RenderUnit units ) { mPointSizeUnit = units; }
487
494 Qgis::RenderUnit pointSizeUnit() const { return mPointSizeUnit; }
495
502 void setPointSizeMapUnitScale( const QgsMapUnitScale &scale ) { mPointSizeMapUnitScale = scale; }
503
510 const QgsMapUnitScale &pointSizeMapUnitScale() const { return mPointSizeMapUnitScale; }
511
518 Qgis::PointCloudDrawOrder drawOrder2d() const;
519
526 void setDrawOrder2d( Qgis::PointCloudDrawOrder order );
527
533 Qgis::PointCloudSymbol pointSymbol() const;
534
540 void setPointSymbol( Qgis::PointCloudSymbol symbol );
541
552 double maximumScreenError() const;
553
564 void setMaximumScreenError( double error );
565
572 Qgis::RenderUnit maximumScreenErrorUnit() const;
573
580 void setMaximumScreenErrorUnit( Qgis::RenderUnit unit );
581
587 bool renderAsTriangles() const { return mRenderAsTriangles; }
588
594 void setRenderAsTriangles( bool asTriangles ) { mRenderAsTriangles = asTriangles; }
595
606 bool horizontalTriangleFilter() const { return mHorizontalTriangleFilter; }
607
618 void setHorizontalTriangleFilter( bool enabled ) { mHorizontalTriangleFilter = enabled; }
619
631 double horizontalTriangleFilterThreshold() const { return mHorizontalTriangleFilterThreshold; }
632
644 void setHorizontalTriangleFilterThreshold( double threshold ) { mHorizontalTriangleFilterThreshold = threshold; }
645
655 Qgis::RenderUnit horizontalTriangleFilterUnit() const { return mHorizontalTriangleFilterUnit; }
656
666 void setHorizontalTriangleFilterUnit( Qgis::RenderUnit unit ) { mHorizontalTriangleFilterUnit = unit; }
667
671 virtual QList<QgsLayerTreeModelLegendNode *> createLegendNodes( QgsLayerTreeLayer *nodeLayer ) SIP_FACTORY;
672
676 virtual QStringList legendRuleKeys() const;
677
678 protected:
679
683 static void pointXY( QgsPointCloudRenderContext &context, const char *ptr, int i, double &x, double &y )
684 {
685 // be wary when copying this code!! In the renderer we explicitly request x/y/z as qint32 values, but in other
686 // situations these may be floats or doubles!
687 const qint32 ix = *reinterpret_cast< const qint32 * >( ptr + i * context.pointRecordSize() + context.xOffset() );
688 const qint32 iy = *reinterpret_cast< const qint32 * >( ptr + i * context.pointRecordSize() + context.yOffset() );
689 x = context.offset().x() + context.scale().x() * ix;
690 y = context.offset().y() + context.scale().y() * iy;
691 }
692
696 static double pointZ( QgsPointCloudRenderContext &context, const char *ptr, int i )
697 {
698 // be wary when copying this code!! In the renderer we explicitly request x/y/z as qint32 values, but in other
699 // situations these may be floats or doubles!
700 const qint32 iz = *reinterpret_cast<const qint32 * >( ptr + i * context.pointRecordSize() + context.zOffset() );
701 return ( context.offset().z() + context.scale().z() * iz ) * context.zValueScale() + context.zValueFixedOffset();
702 }
703
707 void drawPoint( double x, double y, const QColor &color, QgsPointCloudRenderContext &context ) const
708 {
709 drawPoint( x, y, color, mDefaultPainterPenWidth, context );
710 }
711
717 void drawPoint( double x, double y, const QColor &color, int width, QgsPointCloudRenderContext &context ) const
718 {
719 const QPointF originalXY( x, y );
720 context.renderContext().mapToPixel().transformInPlace( x, y );
721 QPainter *painter = context.renderContext().painter();
722 switch ( mPointSymbol )
723 {
725 painter->fillRect( QRectF( x - width * 0.5,
726 y - width * 0.5,
727 width, width ), color );
728 break;
729
731 painter->setBrush( QBrush( color ) );
732 painter->setPen( Qt::NoPen );
733 painter->drawEllipse( QRectF( x - width * 0.5,
734 y - width * 0.5,
735 width, width ) );
736 break;
737 };
738 }
739
740#ifndef SIP_RUN // intentionally left out from SIP to avoid API breaks in future when we move elevation post-processing elsewhere
741
746 void drawPointToElevationMap( double x, double y, double z, QgsPointCloudRenderContext &context ) const;
747
752 void drawPointToElevationMap( double x, double y, double z, int width, QgsPointCloudRenderContext &context ) const;
753#endif
754
759 void addPointToTriangulation( double x, double y, double z, const QColor &color, QgsPointCloudRenderContext &context )
760 {
761 QgsPointXY p = context.renderContext().mapToPixel().transform( x, y ) * context.renderContext().devicePixelRatio();
763 triangulation.points.push_back( p.x() );
764 triangulation.points.push_back( p.y() );
765 triangulation.colors.push_back( color.rgb() );
766 if ( context.renderContext().elevationMap() )
767 triangulation.elevations.push_back( static_cast<float>( z ) );
768 }
769
773 void copyCommonProperties( QgsPointCloudRenderer *destination ) const;
774
781 void restoreCommonProperties( const QDomElement &element, const QgsReadWriteContext &context );
782
789 void saveCommonProperties( QDomElement &element, const QgsReadWriteContext &context ) const;
790
791 private:
792#ifdef SIP_RUN
794#endif
795
796#ifdef QGISDEBUG
798 QThread *mThread = nullptr;
799#endif
800
801 double mMaximumScreenError = 0.3;
802 Qgis::RenderUnit mMaximumScreenErrorUnit = Qgis::RenderUnit::Millimeters;
803
804 double mPointSize = 1;
806 QgsMapUnitScale mPointSizeMapUnitScale;
807
809 int mDefaultPainterPenWidth = 1;
811
812 bool mRenderAsTriangles = false;
813 bool mHorizontalTriangleFilter = false;
814 double mHorizontalTriangleFilterThreshold = 5.0;
815 Qgis::RenderUnit mHorizontalTriangleFilterUnit = Qgis::RenderUnit::Millimeters;
816};
817
818#endif // QGSPOINTCLOUDRENDERER_H
PointCloudSymbol
Rendering symbols for point cloud points.
Definition qgis.h:3995
@ Circle
Renders points as circles.
@ Square
Renders points as squares.
PointCloudDrawOrder
Pointcloud rendering order for 2d views.
Definition qgis.h:4007
@ Default
Draw points in the order they are stored.
RenderUnit
Rendering size units.
Definition qgis.h:4892
@ Millimeters
Millimeters.
Stores digital elevation model in a raster image which may get updated as a part of map layer renderi...
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition qgsfeedback.h:44
A geometry is the spatial representation of a feature.
Layer tree node points to a map layer.
The QgsLegendRendererItem class is abstract interface for legend items returned from QgsMapLayerLegen...
QgsPointXY transform(const QgsPointXY &p) const
Transforms a point p from map (world) coordinates to device coordinates.
void transformInPlace(double &x, double &y) const
Transforms map coordinates to device coordinates.
Struct for storing maximum and minimum scales for measurements in map units.
Collection of point cloud attributes.
DataType
Systems of unit measurement.
@ UShort
Unsigned short int 2 bytes.
@ UChar
Unsigned char 1 byte.
@ UInt32
Unsigned int32 4 bytes.
@ UInt64
Unsigned int64 8 bytes.
Base class for storing raw data from point cloud nodes.
Represents a map layer supporting display of point clouds.
Encapsulates the render context for a 2D point cloud rendering operation.
int yOffset() const
Returns the offset for the y value in a point record.
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.
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...
void setOffset(const QgsVector3D &offset)
Sets the offset of the layer's int32 coordinates compared to CRS coords.
void setScale(const QgsVector3D &scale)
Sets the scale of the layer's int32 coordinates compared to CRS coords.
int pointRecordSize() const
Returns the size of a single point record.
int xOffset() const
Returns the offset for the x value in a point record.
const QgsRenderContext & renderContext() const
Returns a reference to the context's render context.
QgsPointCloudRenderContext & operator=(const QgsPointCloudRenderContext &)=delete
QgsPointCloudRenderContext(const QgsPointCloudRenderContext &rh)=delete
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.
QgsPointCloudAttributeCollection attributes() const
Returns the attributes associated with the rendered block.
TriangulationData & triangulationData()
Returns reference to the triangulation data structure (only used when rendering as triangles is enabl...
int zOffset() const
Returns the offset for the y value in a point record.
QgsFeedback * feedback() const
Returns the feedback object used to cancel rendering.
Abstract base class for 2d point cloud renderers.
virtual QDomElement save(QDomDocument &doc, const QgsReadWriteContext &context) const =0
Saves the renderer configuration to an XML element.
bool renderAsTriangles() const
Returns whether points are triangulated to render solid surface.
virtual void renderBlock(const QgsPointCloudBlock *block, QgsPointCloudRenderContext &context)=0
Renders a block of point cloud data using the specified render context.
QgsPointCloudRenderer & operator=(const QgsPointCloudRenderer &other)=delete
QgsPointCloudRenderer cannot be copied – use clone() instead.
const QgsMapUnitScale & pointSizeMapUnitScale() const
Returns the map unit scale used for the point size.
void setPointSizeMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale used for the point size.
QgsPointCloudRenderer()=default
bool horizontalTriangleFilter() const
Returns whether large triangles will get rendered.
virtual QString type() const =0
Returns the identifier of the renderer type.
void setHorizontalTriangleFilterThreshold(double threshold)
Sets threshold for filtering of triangles.
void setHorizontalTriangleFilterUnit(Qgis::RenderUnit unit)
Sets units of the threshold for filtering of triangles.
QgsPointCloudRenderer(const QgsPointCloudRenderer &other)=delete
QgsPointCloudRenderer cannot be copied – use clone() instead.
virtual QgsPointCloudRenderer * clone() const =0
Create a deep copy of this renderer.
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 setPointSizeUnit(const Qgis::RenderUnit units)
Sets the units used for the point size.
Qgis::RenderUnit horizontalTriangleFilterUnit() const
Returns units of the threshold for filtering of triangles.
void setRenderAsTriangles(bool asTriangles)
Sets whether points are triangulated to render solid surface.
virtual ~QgsPointCloudRenderer()=default
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).
void drawPoint(double x, double y, const QColor &color, int width, QgsPointCloudRenderContext &context) const
Draws a point using a color and painter width at the specified x and y (in map coordinates).
Qgis::RenderUnit pointSizeUnit() const
Returns the units used for the point size.
double horizontalTriangleFilterThreshold() const
Returns threshold for filtering of triangles.
void setHorizontalTriangleFilter(bool enabled)
Sets whether large triangles will get rendered.
double pointSize() const
Returns the point size.
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.
A class to represent a 2D point.
Definition qgspointxy.h:60
double y
Definition qgspointxy.h:64
double x
Definition qgspointxy.h:63
Base class for 2d point cloud renderer prepared data containers.
virtual QColor pointColor(const QgsPointCloudBlock *block, int i, double z)=0
An optimised method of retrieving the color of a point from a point cloud block.
virtual bool prepareBlock(const QgsPointCloudBlock *block)=0
Prepares the renderer for using the specified block.
virtual QSet< QString > usedAttributes() const =0
Returns the set of attributes used by the prepared point cloud renderer.
The class is used as a container of context for various read/write operations on other objects.
Contains information about the context of a rendering operation.
QPainter * painter()
Returns the destination QPainter for the render operation.
QgsElevationMap * elevationMap() const
Returns the destination elevation map for the render operation.
float devicePixelRatio() const
Returns the device pixel ratio.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
Class for storage of 3D vectors similar to QVector3D, with the difference that it uses double precisi...
Definition qgsvector3d.h:31
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
#define SIP_CONVERT_TO_SUBCLASS_CODE(code)
Definition qgis_sip.h:191
#define SIP_SKIP
Definition qgis_sip.h:126
#define SIP_FACTORY
Definition qgis_sip.h:76
#define SIP_END
Definition qgis_sip.h:208
Helper data structure used when rendering points as triangulated surface.
std::vector< QRgb > colors
RGB color for each point.
std::vector< float > elevations
Z value for each point (only used when global map shading is enabled)
std::vector< double > points
X,Y for each point - kept in this structure so that we can use it without further conversions in Dela...