QGIS API Documentation 3.29.0-Master (8c80f25a4f)
qgspointcloud3dsymbol.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgspointcloud3dsymbol.h
3 ------------------------------
4 Date : November 2020
5 Copyright : (C) 2020 by Nedjima Belgacem
6 Email : belgacem dot nedjima at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
17
18#include "qgscolorramptexture.h"
19#include "qgssymbollayerutils.h"
20
21#include <Qt3DRender/QMaterial>
22#include <Qt3DRender/QParameter>
23#include <Qt3DRender/QTexture>
24
25// QgsPointCloud3DSymbol
26
27
30{
31}
32
34
36{
37 mPointSize = size;
38}
39
41{
42 return mRenderAsTriangles;
43}
44
46{
47 mRenderAsTriangles = asTriangles;
48}
49
51{
53}
54
55void QgsPointCloud3DSymbol::setHorizontalTriangleFilter( bool horizontalTriangleFilter )
56{
58}
59
61{
63}
64
65void QgsPointCloud3DSymbol::setHorizontalFilterThreshold( float horizontalFilterThreshold )
66{
68}
69
71{
73}
74
75void QgsPointCloud3DSymbol::setVerticalTriangleFilter( bool verticalTriangleFilter )
76{
78}
79
81{
83}
84
85void QgsPointCloud3DSymbol::setVerticalFilterThreshold( float verticalFilterThreshold )
86{
88}
89
90void QgsPointCloud3DSymbol::writeBaseXml( QDomElement &elem, const QgsReadWriteContext &context ) const
91{
92 Q_UNUSED( context )
93
94 elem.setAttribute( QStringLiteral( "point-size" ), mPointSize );
95 elem.setAttribute( QStringLiteral( "render-as-triangles" ), mRenderAsTriangles ? 1 : 0 );
96 elem.setAttribute( QStringLiteral( "horizontal-triangle-filter" ), mHorizontalTriangleFilter ? 1 : 0 );
97 elem.setAttribute( QStringLiteral( "horizontal-filter-threshold" ), mHorizontalFilterThreshold );
98 elem.setAttribute( QStringLiteral( "vertical-triangle-filter" ), mVerticalTriangleFilter ? 1 : 0 );
99 elem.setAttribute( QStringLiteral( "vertical-filter-threshold" ), mVerticalFilterThreshold );
100}
101
102void QgsPointCloud3DSymbol::readBaseXml( const QDomElement &elem, const QgsReadWriteContext &context )
103{
104 Q_UNUSED( context )
105
106 mPointSize = elem.attribute( QStringLiteral( "point-size" ), QStringLiteral( "3.0" ) ).toFloat();
107 mRenderAsTriangles = elem.attribute( QStringLiteral( "render-as-triangles" ), QStringLiteral( "0" ) ).toInt() == 1;
108 mHorizontalTriangleFilter = elem.attribute( QStringLiteral( "horizontal-triangle-filter" ), QStringLiteral( "0" ) ).toInt() == 1;
109 mHorizontalFilterThreshold = elem.attribute( QStringLiteral( "horizontal-filter-threshold" ), QStringLiteral( "10.0" ) ).toFloat();
110 mVerticalTriangleFilter = elem.attribute( QStringLiteral( "vertical-triangle-filter" ), QStringLiteral( "0" ) ).toInt() == 1;
111 mVerticalFilterThreshold = elem.attribute( QStringLiteral( "vertical-filter-threshold" ), QStringLiteral( "10.0" ) ).toFloat();
112}
113
115{
117 QgsPointCloud3DSymbol *pcDestination = static_cast<QgsPointCloud3DSymbol *>( destination );
118 pcDestination->mPointSize = mPointSize;
119 pcDestination->mRenderAsTriangles = mRenderAsTriangles;
124}
125
126// QgsSingleColorPointCloud3DSymbol
127
130{
131
132}
133
135{
136 return QStringLiteral( "single-color" );
137}
138
140{
142 result->mSingleColor = mSingleColor;
143 copyBaseSettings( result );
144 return result;
145}
146
147void QgsSingleColorPointCloud3DSymbol::writeXml( QDomElement &elem, const QgsReadWriteContext &context ) const
148{
149 Q_UNUSED( context )
150
151 writeBaseXml( elem, context );
152 elem.setAttribute( QStringLiteral( "single-color" ), QgsSymbolLayerUtils::encodeColor( mSingleColor ) );
153
154}
155
156void QgsSingleColorPointCloud3DSymbol::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
157{
158 Q_UNUSED( context )
159
160 readBaseXml( elem, context );
161 mSingleColor = QgsSymbolLayerUtils::decodeColor( elem.attribute( QStringLiteral( "single-color" ), QStringLiteral( "0,0,255" ) ) );
162}
163
165{
166 mSingleColor = color;
167}
168
169void QgsSingleColorPointCloud3DSymbol::fillMaterial( Qt3DRender::QMaterial *mat )
170{
171 Qt3DRender::QParameter *renderingStyle = new Qt3DRender::QParameter( "u_renderingStyle", QgsPointCloud3DSymbol::SingleColor );
172 mat->addParameter( renderingStyle );
173 Qt3DRender::QParameter *pointSizeParameter = new Qt3DRender::QParameter( "u_pointSize", QVariant::fromValue( mPointSize ) );
174 mat->addParameter( pointSizeParameter );
175 Qt3DRender::QParameter *singleColorParameter = new Qt3DRender::QParameter( "u_singleColor", QVector3D( mSingleColor.redF(), mSingleColor.greenF(), mSingleColor.blueF() ) );
176 mat->addParameter( singleColorParameter );
177}
178
179// QgsColorRampPointCloud3DSymbol
180
183{
184
185}
186
188{
190 result->mRenderingParameter = mRenderingParameter;
191 result->mColorRampShader = mColorRampShader;
192 result->mColorRampShaderMin = mColorRampShaderMin;
193 result->mColorRampShaderMax = mColorRampShaderMax;
194 copyBaseSettings( result );
195 return result;
196}
197
199{
200 return QStringLiteral( "color-ramp" );
201}
202
203void QgsColorRampPointCloud3DSymbol::writeXml( QDomElement &elem, const QgsReadWriteContext &context ) const
204{
205 Q_UNUSED( context )
206
207 writeBaseXml( elem, context );
208 elem.setAttribute( QStringLiteral( "rendering-parameter" ), mRenderingParameter );
209 elem.setAttribute( QStringLiteral( "color-ramp-shader-min" ), mColorRampShaderMin );
210 elem.setAttribute( QStringLiteral( "color-ramp-shader-max" ), mColorRampShaderMax );
211 QDomDocument doc = elem.ownerDocument();
212 const QDomElement elemColorRampShader = mColorRampShader.writeXml( doc );
213 elem.appendChild( elemColorRampShader );
214}
215
216void QgsColorRampPointCloud3DSymbol::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
217{
218 Q_UNUSED( context )
219
220 readBaseXml( elem, context );
221 mRenderingParameter = elem.attribute( "rendering-parameter", QString() );
222 mColorRampShaderMin = elem.attribute( QStringLiteral( "color-ramp-shader-min" ), QStringLiteral( "0.0" ) ).toDouble();
223 mColorRampShaderMax = elem.attribute( QStringLiteral( "color-ramp-shader-max" ), QStringLiteral( "1.0" ) ).toDouble();
224 mColorRampShader.readXml( elem );
225}
226
228{
229 return mRenderingParameter;
230}
231
232void QgsColorRampPointCloud3DSymbol::setAttribute( const QString &parameter )
233{
234 mRenderingParameter = parameter;
235}
236
238{
239 return mColorRampShader;
240}
241
243{
244 mColorRampShader = colorRampShader;
245}
246
248{
249 mColorRampShaderMin = min;
250 mColorRampShaderMax = max;
251}
252
253void QgsColorRampPointCloud3DSymbol::fillMaterial( Qt3DRender::QMaterial *mat )
254{
255 Qt3DRender::QParameter *renderingStyle = new Qt3DRender::QParameter( "u_renderingStyle", QgsPointCloud3DSymbol::ColorRamp );
256 mat->addParameter( renderingStyle );
257 Qt3DRender::QParameter *pointSizeParameter = new Qt3DRender::QParameter( "u_pointSize", QVariant::fromValue( mPointSize ) );
258 mat->addParameter( pointSizeParameter );
259 // Create the texture to pass the color ramp
260 Qt3DRender::QTexture1D *colorRampTexture = nullptr;
261 if ( mColorRampShader.colorRampItemList().count() > 0 )
262 {
263 colorRampTexture = new Qt3DRender::QTexture1D( mat );
264 colorRampTexture->addTextureImage( new QgsColorRampTexture( mColorRampShader, 1 ) );
265 colorRampTexture->setMinificationFilter( Qt3DRender::QTexture1D::Linear );
266 colorRampTexture->setMagnificationFilter( Qt3DRender::QTexture1D::Linear );
267 }
268
269 // Parameters
270 Qt3DRender::QParameter *colorRampTextureParameter = new Qt3DRender::QParameter( "u_colorRampTexture", colorRampTexture );
271 mat->addParameter( colorRampTextureParameter );
272 Qt3DRender::QParameter *colorRampCountParameter = new Qt3DRender::QParameter( "u_colorRampCount", mColorRampShader.colorRampItemList().count() );
273 mat->addParameter( colorRampCountParameter );
274 const int colorRampType = mColorRampShader.colorRampType();
275 Qt3DRender::QParameter *colorRampTypeParameter = new Qt3DRender::QParameter( "u_colorRampType", colorRampType );
276 mat->addParameter( colorRampTypeParameter );
277}
278
279// QgsRgbPointCloud3DSymbol
280
283{
284
285}
286
288{
289 return QStringLiteral( "rgb" );
290}
291
293{
295 result->mRedAttribute = mRedAttribute;
296 result->mGreenAttribute = mGreenAttribute;
297 result->mBlueAttribute = mBlueAttribute;
298
299 if ( mRedContrastEnhancement )
300 {
301 result->setRedContrastEnhancement( new QgsContrastEnhancement( *mRedContrastEnhancement ) );
302 }
303 if ( mGreenContrastEnhancement )
304 {
305 result->setGreenContrastEnhancement( new QgsContrastEnhancement( *mGreenContrastEnhancement ) );
306 }
307 if ( mBlueContrastEnhancement )
308 {
309 result->setBlueContrastEnhancement( new QgsContrastEnhancement( *mBlueContrastEnhancement ) );
310 }
311 copyBaseSettings( result );
312 return result;
313}
314
315void QgsRgbPointCloud3DSymbol::writeXml( QDomElement &elem, const QgsReadWriteContext &context ) const
316{
317 Q_UNUSED( context )
318
319 writeBaseXml( elem, context );
320
321 elem.setAttribute( QStringLiteral( "red" ), mRedAttribute );
322 elem.setAttribute( QStringLiteral( "green" ), mGreenAttribute );
323 elem.setAttribute( QStringLiteral( "blue" ), mBlueAttribute );
324
325 QDomDocument doc = elem.ownerDocument();
326
327 //contrast enhancement
328 if ( mRedContrastEnhancement )
329 {
330 QDomElement redContrastElem = doc.createElement( QStringLiteral( "redContrastEnhancement" ) );
331 mRedContrastEnhancement->writeXml( doc, redContrastElem );
332 elem.appendChild( redContrastElem );
333 }
334 if ( mGreenContrastEnhancement )
335 {
336 QDomElement greenContrastElem = doc.createElement( QStringLiteral( "greenContrastEnhancement" ) );
337 mGreenContrastEnhancement->writeXml( doc, greenContrastElem );
338 elem.appendChild( greenContrastElem );
339 }
340 if ( mBlueContrastEnhancement )
341 {
342 QDomElement blueContrastElem = doc.createElement( QStringLiteral( "blueContrastEnhancement" ) );
343 mBlueContrastEnhancement->writeXml( doc, blueContrastElem );
344 elem.appendChild( blueContrastElem );
345 }
346}
347
348void QgsRgbPointCloud3DSymbol::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
349{
350 Q_UNUSED( context )
351
352 readBaseXml( elem, context );
353
354 setRedAttribute( elem.attribute( QStringLiteral( "red" ), QStringLiteral( "Red" ) ) );
355 setGreenAttribute( elem.attribute( QStringLiteral( "green" ), QStringLiteral( "Green" ) ) );
356 setBlueAttribute( elem.attribute( QStringLiteral( "blue" ), QStringLiteral( "Blue" ) ) );
357
358 //contrast enhancements
360 const QDomElement redContrastElem = elem.firstChildElement( QStringLiteral( "redContrastEnhancement" ) );
361 if ( !redContrastElem.isNull() )
362 {
364 redContrastEnhancement->readXml( redContrastElem );
366 }
367
369 const QDomElement greenContrastElem = elem.firstChildElement( QStringLiteral( "greenContrastEnhancement" ) );
370 if ( !greenContrastElem.isNull() )
371 {
373 greenContrastEnhancement->readXml( greenContrastElem );
375 }
376
378 const QDomElement blueContrastElem = elem.firstChildElement( QStringLiteral( "blueContrastEnhancement" ) );
379 if ( !blueContrastElem.isNull() )
380 {
382 blueContrastEnhancement->readXml( blueContrastElem );
384 }
385}
386
387void QgsRgbPointCloud3DSymbol::fillMaterial( Qt3DRender::QMaterial *mat )
388{
389 Qt3DRender::QParameter *renderingStyle = new Qt3DRender::QParameter( "u_renderingStyle", QgsPointCloud3DSymbol::RgbRendering );
390 mat->addParameter( renderingStyle );
391 Qt3DRender::QParameter *pointSizeParameter = new Qt3DRender::QParameter( "u_pointSize", QVariant::fromValue( mPointSize ) );
392 mat->addParameter( pointSizeParameter );
393}
394
395
397{
398 return mRedAttribute;
399}
400
401void QgsRgbPointCloud3DSymbol::setRedAttribute( const QString &redAttribute )
402{
403 mRedAttribute = redAttribute;
404}
405
407{
408 return mGreenAttribute;
409}
410
411void QgsRgbPointCloud3DSymbol::setGreenAttribute( const QString &greenAttribute )
412{
413 mGreenAttribute = greenAttribute;
414}
415
417{
418 return mBlueAttribute;
419}
420
421void QgsRgbPointCloud3DSymbol::setBlueAttribute( const QString &blueAttribute )
422{
423 mBlueAttribute = blueAttribute;
424}
425
427{
428 return mRedContrastEnhancement.get();
429}
430
432{
433 mRedContrastEnhancement.reset( enhancement );
434}
435
437{
438 return mGreenContrastEnhancement.get();
439}
440
442{
443 mGreenContrastEnhancement.reset( enhancement );
444}
445
447{
448 return mBlueContrastEnhancement.get();
449}
450
452{
453 mBlueContrastEnhancement.reset( enhancement );
454}
455
456// QgsClassificationPointCloud3DSymbol
457
458
461{
462
463}
464
466{
468 result->mRenderingParameter = mRenderingParameter;
469 result->mCategoriesList = mCategoriesList;
470 copyBaseSettings( result );
471 return result;
472}
473
475{
476 return QStringLiteral( "classification" );
477}
478
479void QgsClassificationPointCloud3DSymbol::writeXml( QDomElement &elem, const QgsReadWriteContext &context ) const
480{
481 Q_UNUSED( context )
482 QDomDocument doc = elem.ownerDocument();
483
484 writeBaseXml( elem, context );
485
486 elem.setAttribute( QStringLiteral( "rendering-parameter" ), mRenderingParameter );
487
488 // categories
489 QDomElement catsElem = doc.createElement( QStringLiteral( "categories" ) );
490 for ( const QgsPointCloudCategory &category : mCategoriesList )
491 {
492 QDomElement catElem = doc.createElement( QStringLiteral( "category" ) );
493 catElem.setAttribute( QStringLiteral( "value" ), QString::number( category.value() ) );
494 catElem.setAttribute( QStringLiteral( "label" ), category.label() );
495 catElem.setAttribute( QStringLiteral( "color" ), QgsSymbolLayerUtils::encodeColor( category.color() ) );
496 catElem.setAttribute( QStringLiteral( "render" ), category.renderState() ? "true" : "false" );
497 catsElem.appendChild( catElem );
498 }
499 elem.appendChild( catsElem );
500}
501
502void QgsClassificationPointCloud3DSymbol::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
503{
504 Q_UNUSED( context )
505
506 readBaseXml( elem, context );
507 mRenderingParameter = elem.attribute( "rendering-parameter", QString() );
508
509 const QDomElement catsElem = elem.firstChildElement( QStringLiteral( "categories" ) );
510 if ( !catsElem.isNull() )
511 {
512 mCategoriesList.clear();
513 QDomElement catElem = catsElem.firstChildElement();
514 while ( !catElem.isNull() )
515 {
516 if ( catElem.tagName() == QLatin1String( "category" ) )
517 {
518 const int value = catElem.attribute( QStringLiteral( "value" ) ).toInt();
519 const QString label = catElem.attribute( QStringLiteral( "label" ) );
520 const bool render = catElem.attribute( QStringLiteral( "render" ) ) != QLatin1String( "false" );
521 const QColor color = QgsSymbolLayerUtils::decodeColor( catElem.attribute( QStringLiteral( "color" ) ) );
522 mCategoriesList.append( QgsPointCloudCategory( value, color, label, render ) );
523 }
524 catElem = catElem.nextSiblingElement();
525 }
526 }
527}
528
530{
531 return mRenderingParameter;
532}
533
535{
536 mRenderingParameter = attribute;
537}
538
540{
541 mCategoriesList = categories;
542}
543
545{
546 QgsPointCloudCategoryList filteredOut;
547 for ( const QgsPointCloudCategory &category : mCategoriesList )
548 {
549 if ( !category.renderState() )
550 filteredOut.push_back( category );
551 }
552 return filteredOut;
553}
554
555QgsColorRampShader QgsClassificationPointCloud3DSymbol::colorRampShader() const
556{
557 QgsColorRampShader colorRampShader;
558 colorRampShader.setColorRampType( QgsColorRampShader::Type::Exact );
559 colorRampShader.setClassificationMode( QgsColorRampShader::ClassificationMode::Continuous );
560 QList<QgsColorRampShader::ColorRampItem> colorRampItemList;
561 for ( const QgsPointCloudCategory &category : mCategoriesList )
562 {
563 const QColor color = category.color();
564 const QgsColorRampShader::ColorRampItem item( category.value(), color, category.label() );
565 colorRampItemList.push_back( item );
566 }
567 colorRampShader.setColorRampItemList( colorRampItemList );
568 return colorRampShader;
569}
570
571
573{
574 const QgsColorRampShader mColorRampShader = colorRampShader();
575 Qt3DRender::QParameter *renderingStyle = new Qt3DRender::QParameter( "u_renderingStyle", QgsPointCloud3DSymbol::Classification );
576 mat->addParameter( renderingStyle );
577 Qt3DRender::QParameter *pointSizeParameter = new Qt3DRender::QParameter( "u_pointSize", QVariant::fromValue( mPointSize ) );
578 mat->addParameter( pointSizeParameter );
579 // Create the texture to pass the color ramp
580 Qt3DRender::QTexture1D *colorRampTexture = nullptr;
581 if ( mColorRampShader.colorRampItemList().count() > 0 )
582 {
583 colorRampTexture = new Qt3DRender::QTexture1D( mat );
584 colorRampTexture->addTextureImage( new QgsColorRampTexture( mColorRampShader, 1 ) );
585 colorRampTexture->setMinificationFilter( Qt3DRender::QTexture1D::Linear );
586 colorRampTexture->setMagnificationFilter( Qt3DRender::QTexture1D::Linear );
587 }
588
589 // Parameters
590 Qt3DRender::QParameter *colorRampTextureParameter = new Qt3DRender::QParameter( "u_colorRampTexture", colorRampTexture );
591 mat->addParameter( colorRampTextureParameter );
592 Qt3DRender::QParameter *colorRampCountParameter = new Qt3DRender::QParameter( "u_colorRampCount", mColorRampShader.colorRampItemList().count() );
593 mat->addParameter( colorRampCountParameter );
594 const int colorRampType = mColorRampShader.colorRampType();
595 Qt3DRender::QParameter *colorRampTypeParameter = new Qt3DRender::QParameter( "u_colorRampType", colorRampType );
596 mat->addParameter( colorRampTypeParameter );
597}
598
@ UnknownDataType
Unknown or unspecified type.
virtual void copyBaseSettings(QgsAbstract3DSymbol *destination) const
Copies base class settings from this object to a destination object.
void readXml(const QDomElement &elem, const QgsReadWriteContext &context) override
void writeXml(QDomElement &elem, const QgsReadWriteContext &context) const override
QgsAbstract3DSymbol * clone() const override SIP_FACTORY
QString attribute() const
Returns the attribute used to select the color of the point cloud.
void fillMaterial(Qt3DRender::QMaterial *material) override SIP_SKIP
Used to fill material object with necessary QParameters (and consequently opengl uniforms)
void setCategoriesList(const QgsPointCloudCategoryList &categories)
Sets the list of categories of the classification.
QgsPointCloudCategoryList getFilteredOutCategories() const
Gets the list of categories of the classification that should not be rendered.
void setAttribute(const QString &attribute)
Sets the attribute used to select the color of the point cloud.
QString symbolType() const override
Returns a unique string identifier of the symbol type.
QgsClassificationPointCloud3DSymbol()
Constructor for QgsClassificationPointCloud3DSymbol.
void fillMaterial(Qt3DRender::QMaterial *material) override SIP_SKIP
Used to fill material object with necessary QParameters (and consequently opengl uniforms)
void readXml(const QDomElement &elem, const QgsReadWriteContext &context) override
QgsAbstract3DSymbol * clone() const override SIP_FACTORY
void setAttribute(const QString &attribute)
Sets the attribute used to select the color of the point cloud.
void writeXml(QDomElement &elem, const QgsReadWriteContext &context) const override
void setColorRampShaderMinMax(double min, double max)
Sets the minimum and maximum values used when classifying colors in the color ramp shader.
QString attribute() const
Returns the attribute used to select the color of the point cloud.
QString symbolType() const override
Returns a unique string identifier of the symbol type.
QgsColorRampShader colorRampShader() const
Returns the color ramp shader used to render the color.
void setColorRampShader(const QgsColorRampShader &colorRampShader)
Sets the color ramp shader used to render the point cloud.
QgsColorRampPointCloud3DSymbol()
Constructor for QgsColorRampPointCloud3DSymbol.
A ramp shader will color a raster pixel based on a list of values ranges in a ramp.
Type colorRampType() const
Returns the color ramp type.
QList< QgsColorRampShader::ColorRampItem > colorRampItemList() const
Returns the custom colormap.
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context=QgsReadWriteContext()) const
Writes configuration to a new DOM element.
void setClassificationMode(ClassificationMode classificationMode)
Sets classification mode.
void setColorRampItemList(const QList< QgsColorRampShader::ColorRampItem > &list)
Sets a custom colormap.
void setColorRampType(QgsColorRampShader::Type colorRampType)
Sets the color ramp type.
void readXml(const QDomElement &elem, const QgsReadWriteContext &context=QgsReadWriteContext())
Reads configuration from the given DOM element.
Manipulates raster or point cloud pixel values so that they enhanceContrast or clip into a specified ...
void readXml(const QDomElement &elem)
QgsPointCloud3DSymbol()
Constructor for QgsPointCloud3DSymbol.
bool verticalTriangleFilter() const
Returns whether triangles are filtered by vertical height for rendering.
float verticalFilterThreshold() const
Returns the threshold vertical height value for filtering triangles.
void setVerticalTriangleFilter(bool verticalTriangleFilter)
Sets whether triangles are filtered by vertical height for rendering.
void setHorizontalFilterThreshold(float horizontalFilterThreshold)
Sets the threshold horizontal size value for filtering triangles.
void setRenderAsTriangles(bool asTriangles)
Sets whether points are triangulated to render solid surface.
float horizontalFilterThreshold() const
Returns the threshold horizontal size value for filtering triangles.
void copyBaseSettings(QgsAbstract3DSymbol *destination) const override
bool renderAsTriangles() const
Returns whether points are triangulated to render solid surface.
void setPointSize(float size)
Sets the point size.
~QgsPointCloud3DSymbol() override
Destructor for QgsPointCloud3DSymbol.
void writeBaseXml(QDomElement &elem, const QgsReadWriteContext &context) const
Writes symbol configuration of this class to the given DOM element.
@ Classification
Render the point cloud with classified colors.
@ SingleColor
Render the point cloud with a single color.
@ ColorRamp
Render the point cloud with a color ramp.
@ RgbRendering
Render the RGB colors of the point cloud.
void setHorizontalTriangleFilter(bool horizontalTriangleFilter)
Sets whether whether triangles are filtered by horizontal size for rendering.
bool horizontalTriangleFilter() const
Returns whether triangles are filtered by horizontal size for rendering.
void readBaseXml(const QDomElement &elem, const QgsReadWriteContext &context)
Reads symbol configuration of this class from the given DOM element.
void setVerticalFilterThreshold(float verticalFilterThreshold)
Sets the threshold vertical height value for filtering triangles.
Represents an individual category (class) from a QgsPointCloudClassifiedRenderer.
The class is used as a container of context for various read/write operations on other objects.
QString blueAttribute() const
Returns the attribute to use for the blue channel.
void readXml(const QDomElement &elem, const QgsReadWriteContext &context) override
void setBlueAttribute(const QString &attribute)
Sets the attribute to use for the blue channel.
void setGreenContrastEnhancement(QgsContrastEnhancement *enhancement SIP_TRANSFER)
Sets the contrast enhancement to use for the green channel.
void fillMaterial(Qt3DRender::QMaterial *material) override SIP_SKIP
Used to fill material object with necessary QParameters (and consequently opengl uniforms)
QgsRgbPointCloud3DSymbol()
Constructor for QgsRGBPointCloud3DSymbol.
QString greenAttribute() const
Returns the attribute to use for the green channel.
QgsContrastEnhancement * blueContrastEnhancement()
Returns the contrast enhancement to use for the blue channel.
void setGreenAttribute(const QString &attribute)
Sets the attribute to use for the green channel.
QString redAttribute() const
Returns the attribute to use for the red channel.
void setBlueContrastEnhancement(QgsContrastEnhancement *enhancement SIP_TRANSFER)
Sets the contrast enhancement to use for the blue channel.
QgsContrastEnhancement * greenContrastEnhancement()
Returns the contrast enhancement to use for the green channel.
QgsContrastEnhancement * redContrastEnhancement()
Returns the contrast enhancement to use for the red channel.
void setRedContrastEnhancement(QgsContrastEnhancement *enhancement SIP_TRANSFER)
Sets the contrast enhancement to use for the red channel.
QgsAbstract3DSymbol * clone() const override SIP_FACTORY
QString symbolType() const override
Returns a unique string identifier of the symbol type.
void writeXml(QDomElement &elem, const QgsReadWriteContext &context) const override
void setRedAttribute(const QString &attribute)
Sets the attribute to use for the red channel.
QString symbolType() const override
Returns a unique string identifier of the symbol type.
QgsAbstract3DSymbol * clone() const override SIP_FACTORY
void fillMaterial(Qt3DRender::QMaterial *material) override SIP_SKIP
Used to fill material object with necessary QParameters (and consequently opengl uniforms)
void readXml(const QDomElement &elem, const QgsReadWriteContext &context) override
void writeXml(QDomElement &elem, const QgsReadWriteContext &context) const override
QgsSingleColorPointCloud3DSymbol()
Constructor for QgsSingleColorPointCloud3DSymbol.
void setSingleColor(QColor color)
Sets the color used by the renderer when using SingleColor rendering mode.
static QColor decodeColor(const QString &str)
static QString encodeColor(const QColor &color)
QList< QgsPointCloudCategory > QgsPointCloudCategoryList