QGIS API Documentation 3.37.0-Master (c2d15952569)
Loading...
Searching...
No Matches
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 "qgscolorutils.h"
19#include "qgscolorramptexture.h"
20
21#include <Qt3DRender/QMaterial>
22#include <Qt3DRender/QParameter>
23#include <Qt3DRender/QTexture>
24
25// QgsPointCloud3DSymbol
26
27
32
34
36{
37 mPointSize = size;
38}
39
44
46{
47 mRenderAsTriangles = asTriangles;
48}
49
54
59
64
69
74
79
84
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
125
126// QgsSingleColorPointCloud3DSymbol
127
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" ), QgsColorUtils::colorToString( 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 = QgsColorUtils::colorFromString( 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
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
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
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( "pointSize" ), category.pointSize() );
495 catElem.setAttribute( QStringLiteral( "label" ), category.label() );
496 catElem.setAttribute( QStringLiteral( "color" ), QgsColorUtils::colorToString( category.color() ) );
497 catElem.setAttribute( QStringLiteral( "render" ), category.renderState() ? "true" : "false" );
498 catsElem.appendChild( catElem );
499 }
500 elem.appendChild( catsElem );
501}
502
503void QgsClassificationPointCloud3DSymbol::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
504{
505 Q_UNUSED( context )
506
507 readBaseXml( elem, context );
508 mRenderingParameter = elem.attribute( "rendering-parameter", QString() );
509
510 const QDomElement catsElem = elem.firstChildElement( QStringLiteral( "categories" ) );
511 if ( !catsElem.isNull() )
512 {
513 mCategoriesList.clear();
514 QDomElement catElem = catsElem.firstChildElement();
515 while ( !catElem.isNull() )
516 {
517 if ( catElem.tagName() == QLatin1String( "category" ) )
518 {
519 const int value = catElem.attribute( QStringLiteral( "value" ) ).toInt();
520 const double size = catElem.attribute( QStringLiteral( "pointSize" ), QStringLiteral( "0" ) ).toDouble();
521 const QString label = catElem.attribute( QStringLiteral( "label" ) );
522 const bool render = catElem.attribute( QStringLiteral( "render" ) ) != QLatin1String( "false" );
523 const QColor color = QgsColorUtils::colorFromString( catElem.attribute( QStringLiteral( "color" ) ) );
524 mCategoriesList.append( QgsPointCloudCategory( value, color, label, render, size ) );
525 }
526 catElem = catElem.nextSiblingElement();
527 }
528 }
529}
530
532{
533 return mRenderingParameter;
534}
535
537{
538 mRenderingParameter = attribute;
539}
540
542{
543 mCategoriesList = categories;
544}
545
547{
548 QgsPointCloudCategoryList filteredOut;
549 for ( const QgsPointCloudCategory &category : mCategoriesList )
550 {
551 if ( !category.renderState() )
552 filteredOut.push_back( category );
553 }
554 return filteredOut;
555}
556
557QgsColorRampShader QgsClassificationPointCloud3DSymbol::colorRampShader() const
558{
559 QgsColorRampShader colorRampShader;
562 QList<QgsColorRampShader::ColorRampItem> colorRampItemList;
563 for ( const QgsPointCloudCategory &category : mCategoriesList )
564 {
565 const QColor color = category.color();
566 const QgsColorRampShader::ColorRampItem item( category.value(), color, category.label() );
567 colorRampItemList.push_back( item );
568 }
569 colorRampShader.setColorRampItemList( colorRampItemList );
570 return colorRampShader;
571}
572
573
575{
576 const QgsColorRampShader mColorRampShader = colorRampShader();
577 Qt3DRender::QParameter *renderingStyle = new Qt3DRender::QParameter( "u_renderingStyle", QgsPointCloud3DSymbol::Classification );
578 mat->addParameter( renderingStyle );
579 Qt3DRender::QParameter *pointSizeParameter = new Qt3DRender::QParameter( "u_pointSize", QVariant::fromValue( mPointSize ) );
580 mat->addParameter( pointSizeParameter );
581 // Create the texture to pass the color ramp
582 Qt3DRender::QTexture1D *colorRampTexture = nullptr;
583 if ( mColorRampShader.colorRampItemList().count() > 0 )
584 {
585 colorRampTexture = new Qt3DRender::QTexture1D( mat );
586 colorRampTexture->addTextureImage( new QgsColorRampTexture( mColorRampShader, 1 ) );
587 colorRampTexture->setMinificationFilter( Qt3DRender::QTexture1D::Linear );
588 colorRampTexture->setMagnificationFilter( Qt3DRender::QTexture1D::Linear );
589 }
590
591 // Parameters
592 Qt3DRender::QParameter *colorRampTextureParameter = new Qt3DRender::QParameter( "u_colorRampTexture", colorRampTexture );
593 mat->addParameter( colorRampTextureParameter );
594 Qt3DRender::QParameter *colorRampCountParameter = new Qt3DRender::QParameter( "u_colorRampCount", mColorRampShader.colorRampItemList().count() );
595 mat->addParameter( colorRampCountParameter );
596 const int colorRampType = mColorRampShader.colorRampType();
597 Qt3DRender::QParameter *colorRampTypeParameter = new Qt3DRender::QParameter( "u_colorRampType", colorRampType );
598 mat->addParameter( colorRampTypeParameter );
599}
600
@ 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.
@ Continuous
Uses breaks from color palette.
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context=QgsReadWriteContext()) const
Writes configuration to a new DOM element.
@ Exact
Assigns the color of the exact matching value in the color ramp item list.
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.
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.
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.
QList< QgsPointCloudCategory > QgsPointCloudCategoryList