QGIS API Documentation 3.41.0-Master (af5edcb665c)
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#include "qgsmaterial.h"
21
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
132
134{
135 return QStringLiteral( "single-color" );
136}
137
139{
141 result->mSingleColor = mSingleColor;
142 copyBaseSettings( result );
143 return result;
144}
145
146void QgsSingleColorPointCloud3DSymbol::writeXml( QDomElement &elem, const QgsReadWriteContext &context ) const
147{
148 Q_UNUSED( context )
149
150 writeBaseXml( elem, context );
151 elem.setAttribute( QStringLiteral( "single-color" ), QgsColorUtils::colorToString( mSingleColor ) );
152}
153
154void QgsSingleColorPointCloud3DSymbol::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
155{
156 Q_UNUSED( context )
157
158 readBaseXml( elem, context );
159 mSingleColor = QgsColorUtils::colorFromString( elem.attribute( QStringLiteral( "single-color" ), QStringLiteral( "0,0,255" ) ) );
160}
161
163{
164 mSingleColor = color;
165}
166
168{
169 Qt3DRender::QParameter *renderingStyle = new Qt3DRender::QParameter( "u_renderingStyle", QgsPointCloud3DSymbol::SingleColor );
170 mat->addParameter( renderingStyle );
171 Qt3DRender::QParameter *pointSizeParameter = new Qt3DRender::QParameter( "u_pointSize", QVariant::fromValue( mPointSize ) );
172 mat->addParameter( pointSizeParameter );
173 Qt3DRender::QParameter *singleColorParameter = new Qt3DRender::QParameter( "u_singleColor", QVector3D( mSingleColor.redF(), mSingleColor.greenF(), mSingleColor.blueF() ) );
174 mat->addParameter( singleColorParameter );
175}
176
177// QgsColorRampPointCloud3DSymbol
178
183
185{
187 result->mRenderingParameter = mRenderingParameter;
188 result->mColorRampShader = mColorRampShader;
189 result->mColorRampShaderMin = mColorRampShaderMin;
190 result->mColorRampShaderMax = mColorRampShaderMax;
191 copyBaseSettings( result );
192 return result;
193}
194
196{
197 return QStringLiteral( "color-ramp" );
198}
199
200void QgsColorRampPointCloud3DSymbol::writeXml( QDomElement &elem, const QgsReadWriteContext &context ) const
201{
202 Q_UNUSED( context )
203
204 writeBaseXml( elem, context );
205 elem.setAttribute( QStringLiteral( "rendering-parameter" ), mRenderingParameter );
206 elem.setAttribute( QStringLiteral( "color-ramp-shader-min" ), mColorRampShaderMin );
207 elem.setAttribute( QStringLiteral( "color-ramp-shader-max" ), mColorRampShaderMax );
208 QDomDocument doc = elem.ownerDocument();
209 const QDomElement elemColorRampShader = mColorRampShader.writeXml( doc );
210 elem.appendChild( elemColorRampShader );
211}
212
213void QgsColorRampPointCloud3DSymbol::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
214{
215 Q_UNUSED( context )
216
217 readBaseXml( elem, context );
218 mRenderingParameter = elem.attribute( "rendering-parameter", QString() );
219 mColorRampShaderMin = elem.attribute( QStringLiteral( "color-ramp-shader-min" ), QStringLiteral( "0.0" ) ).toDouble();
220 mColorRampShaderMax = elem.attribute( QStringLiteral( "color-ramp-shader-max" ), QStringLiteral( "1.0" ) ).toDouble();
221 mColorRampShader.readXml( elem );
222}
223
225{
226 return mRenderingParameter;
227}
228
229void QgsColorRampPointCloud3DSymbol::setAttribute( const QString &parameter )
230{
231 mRenderingParameter = parameter;
232}
233
235{
236 return mColorRampShader;
237}
238
240{
241 mColorRampShader = colorRampShader;
242}
243
245{
246 mColorRampShaderMin = min;
247 mColorRampShaderMax = max;
248}
249
251{
252 Qt3DRender::QParameter *renderingStyle = new Qt3DRender::QParameter( "u_renderingStyle", QgsPointCloud3DSymbol::ColorRamp );
253 mat->addParameter( renderingStyle );
254 Qt3DRender::QParameter *pointSizeParameter = new Qt3DRender::QParameter( "u_pointSize", QVariant::fromValue( mPointSize ) );
255 mat->addParameter( pointSizeParameter );
256 // Create the texture to pass the color ramp
257 Qt3DRender::QTexture1D *colorRampTexture = nullptr;
258 if ( mColorRampShader.colorRampItemList().count() > 0 )
259 {
260 colorRampTexture = new Qt3DRender::QTexture1D( mat );
261 colorRampTexture->addTextureImage( new QgsColorRampTexture( mColorRampShader, 1 ) );
262 colorRampTexture->setMinificationFilter( Qt3DRender::QTexture1D::Linear );
263 colorRampTexture->setMagnificationFilter( Qt3DRender::QTexture1D::Linear );
264 }
265
266 // Parameters
267 Qt3DRender::QParameter *colorRampTextureParameter = new Qt3DRender::QParameter( "u_colorRampTexture", colorRampTexture );
268 mat->addParameter( colorRampTextureParameter );
269 Qt3DRender::QParameter *colorRampCountParameter = new Qt3DRender::QParameter( "u_colorRampCount", mColorRampShader.colorRampItemList().count() );
270 mat->addParameter( colorRampCountParameter );
271 const Qgis::ShaderInterpolationMethod colorRampType = mColorRampShader.colorRampType();
272 Qt3DRender::QParameter *colorRampTypeParameter = new Qt3DRender::QParameter( "u_colorRampType", static_cast<int>( colorRampType ) );
273 mat->addParameter( colorRampTypeParameter );
274}
275
276// QgsRgbPointCloud3DSymbol
277
282
284{
285 return QStringLiteral( "rgb" );
286}
287
289{
291 result->mRedAttribute = mRedAttribute;
292 result->mGreenAttribute = mGreenAttribute;
293 result->mBlueAttribute = mBlueAttribute;
294
295 if ( mRedContrastEnhancement )
296 {
297 result->setRedContrastEnhancement( new QgsContrastEnhancement( *mRedContrastEnhancement ) );
298 }
299 if ( mGreenContrastEnhancement )
300 {
301 result->setGreenContrastEnhancement( new QgsContrastEnhancement( *mGreenContrastEnhancement ) );
302 }
303 if ( mBlueContrastEnhancement )
304 {
305 result->setBlueContrastEnhancement( new QgsContrastEnhancement( *mBlueContrastEnhancement ) );
306 }
307 copyBaseSettings( result );
308 return result;
309}
310
311void QgsRgbPointCloud3DSymbol::writeXml( QDomElement &elem, const QgsReadWriteContext &context ) const
312{
313 Q_UNUSED( context )
314
315 writeBaseXml( elem, context );
316
317 elem.setAttribute( QStringLiteral( "red" ), mRedAttribute );
318 elem.setAttribute( QStringLiteral( "green" ), mGreenAttribute );
319 elem.setAttribute( QStringLiteral( "blue" ), mBlueAttribute );
320
321 QDomDocument doc = elem.ownerDocument();
322
323 //contrast enhancement
324 if ( mRedContrastEnhancement )
325 {
326 QDomElement redContrastElem = doc.createElement( QStringLiteral( "redContrastEnhancement" ) );
327 mRedContrastEnhancement->writeXml( doc, redContrastElem );
328 elem.appendChild( redContrastElem );
329 }
330 if ( mGreenContrastEnhancement )
331 {
332 QDomElement greenContrastElem = doc.createElement( QStringLiteral( "greenContrastEnhancement" ) );
333 mGreenContrastEnhancement->writeXml( doc, greenContrastElem );
334 elem.appendChild( greenContrastElem );
335 }
336 if ( mBlueContrastEnhancement )
337 {
338 QDomElement blueContrastElem = doc.createElement( QStringLiteral( "blueContrastEnhancement" ) );
339 mBlueContrastEnhancement->writeXml( doc, blueContrastElem );
340 elem.appendChild( blueContrastElem );
341 }
342}
343
344void QgsRgbPointCloud3DSymbol::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
345{
346 Q_UNUSED( context )
347
348 readBaseXml( elem, context );
349
350 setRedAttribute( elem.attribute( QStringLiteral( "red" ), QStringLiteral( "Red" ) ) );
351 setGreenAttribute( elem.attribute( QStringLiteral( "green" ), QStringLiteral( "Green" ) ) );
352 setBlueAttribute( elem.attribute( QStringLiteral( "blue" ), QStringLiteral( "Blue" ) ) );
353
354 //contrast enhancements
356 const QDomElement redContrastElem = elem.firstChildElement( QStringLiteral( "redContrastEnhancement" ) );
357 if ( !redContrastElem.isNull() )
358 {
360 redContrastEnhancement->readXml( redContrastElem );
362 }
363
365 const QDomElement greenContrastElem = elem.firstChildElement( QStringLiteral( "greenContrastEnhancement" ) );
366 if ( !greenContrastElem.isNull() )
367 {
369 greenContrastEnhancement->readXml( greenContrastElem );
371 }
372
374 const QDomElement blueContrastElem = elem.firstChildElement( QStringLiteral( "blueContrastEnhancement" ) );
375 if ( !blueContrastElem.isNull() )
376 {
378 blueContrastEnhancement->readXml( blueContrastElem );
380 }
381}
382
384{
385 Qt3DRender::QParameter *renderingStyle = new Qt3DRender::QParameter( "u_renderingStyle", QgsPointCloud3DSymbol::RgbRendering );
386 mat->addParameter( renderingStyle );
387 Qt3DRender::QParameter *pointSizeParameter = new Qt3DRender::QParameter( "u_pointSize", QVariant::fromValue( mPointSize ) );
388 mat->addParameter( pointSizeParameter );
389}
390
391
393{
394 return mRedAttribute;
395}
396
397void QgsRgbPointCloud3DSymbol::setRedAttribute( const QString &redAttribute )
398{
399 mRedAttribute = redAttribute;
400}
401
403{
404 return mGreenAttribute;
405}
406
407void QgsRgbPointCloud3DSymbol::setGreenAttribute( const QString &greenAttribute )
408{
409 mGreenAttribute = greenAttribute;
410}
411
413{
414 return mBlueAttribute;
415}
416
417void QgsRgbPointCloud3DSymbol::setBlueAttribute( const QString &blueAttribute )
418{
419 mBlueAttribute = blueAttribute;
420}
421
423{
424 return mRedContrastEnhancement.get();
425}
426
428{
429 mRedContrastEnhancement.reset( enhancement );
430}
431
433{
434 return mGreenContrastEnhancement.get();
435}
436
438{
439 mGreenContrastEnhancement.reset( enhancement );
440}
441
443{
444 return mBlueContrastEnhancement.get();
445}
446
448{
449 mBlueContrastEnhancement.reset( enhancement );
450}
451
452// QgsClassificationPointCloud3DSymbol
453
454
459
461{
463 result->mRenderingParameter = mRenderingParameter;
464 result->mCategoriesList = mCategoriesList;
465 copyBaseSettings( result );
466 return result;
467}
468
470{
471 return QStringLiteral( "classification" );
472}
473
474void QgsClassificationPointCloud3DSymbol::writeXml( QDomElement &elem, const QgsReadWriteContext &context ) const
475{
476 Q_UNUSED( context )
477 QDomDocument doc = elem.ownerDocument();
478
479 writeBaseXml( elem, context );
480
481 elem.setAttribute( QStringLiteral( "rendering-parameter" ), mRenderingParameter );
482
483 // categories
484 QDomElement catsElem = doc.createElement( QStringLiteral( "categories" ) );
485 for ( const QgsPointCloudCategory &category : mCategoriesList )
486 {
487 QDomElement catElem = doc.createElement( QStringLiteral( "category" ) );
488 catElem.setAttribute( QStringLiteral( "value" ), QString::number( category.value() ) );
489 catElem.setAttribute( QStringLiteral( "pointSize" ), category.pointSize() );
490 catElem.setAttribute( QStringLiteral( "label" ), category.label() );
491 catElem.setAttribute( QStringLiteral( "color" ), QgsColorUtils::colorToString( category.color() ) );
492 catElem.setAttribute( QStringLiteral( "render" ), category.renderState() ? "true" : "false" );
493 catsElem.appendChild( catElem );
494 }
495 elem.appendChild( catsElem );
496}
497
498void QgsClassificationPointCloud3DSymbol::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
499{
500 Q_UNUSED( context )
501
502 readBaseXml( elem, context );
503 mRenderingParameter = elem.attribute( "rendering-parameter", QString() );
504
505 const QDomElement catsElem = elem.firstChildElement( QStringLiteral( "categories" ) );
506 if ( !catsElem.isNull() )
507 {
508 mCategoriesList.clear();
509 QDomElement catElem = catsElem.firstChildElement();
510 while ( !catElem.isNull() )
511 {
512 if ( catElem.tagName() == QLatin1String( "category" ) )
513 {
514 const int value = catElem.attribute( QStringLiteral( "value" ) ).toInt();
515 const double size = catElem.attribute( QStringLiteral( "pointSize" ), QStringLiteral( "0" ) ).toDouble();
516 const QString label = catElem.attribute( QStringLiteral( "label" ) );
517 const bool render = catElem.attribute( QStringLiteral( "render" ) ) != QLatin1String( "false" );
518 const QColor color = QgsColorUtils::colorFromString( catElem.attribute( QStringLiteral( "color" ) ) );
519 mCategoriesList.append( QgsPointCloudCategory( value, color, label, render, size ) );
520 }
521 catElem = catElem.nextSiblingElement();
522 }
523 }
524}
525
527{
528 return mRenderingParameter;
529}
530
532{
533 mRenderingParameter = attribute;
534}
535
537{
538 mCategoriesList = categories;
539}
540
542{
543 QgsPointCloudCategoryList filteredOut;
544 for ( const QgsPointCloudCategory &category : mCategoriesList )
545 {
546 if ( !category.renderState() )
547 filteredOut.push_back( category );
548 }
549 return filteredOut;
550}
551
552QgsColorRampShader QgsClassificationPointCloud3DSymbol::colorRampShader() const
553{
554 QgsColorRampShader colorRampShader;
557 QList<QgsColorRampShader::ColorRampItem> colorRampItemList;
558 for ( const QgsPointCloudCategory &category : mCategoriesList )
559 {
560 const QColor color = category.color();
561 const QgsColorRampShader::ColorRampItem item( category.value(), color, category.label() );
562 colorRampItemList.push_back( item );
563 }
564 colorRampShader.setColorRampItemList( colorRampItemList );
565 return colorRampShader;
566}
567
568
570{
571 const QgsColorRampShader mColorRampShader = colorRampShader();
572 Qt3DRender::QParameter *renderingStyle = new Qt3DRender::QParameter( "u_renderingStyle", QgsPointCloud3DSymbol::Classification );
573 mat->addParameter( renderingStyle );
574 Qt3DRender::QParameter *pointSizeParameter = new Qt3DRender::QParameter( "u_pointSize", QVariant::fromValue( mPointSize ) );
575 mat->addParameter( pointSizeParameter );
576 // Create the texture to pass the color ramp
577 Qt3DRender::QTexture1D *colorRampTexture = nullptr;
578 if ( mColorRampShader.colorRampItemList().count() > 0 )
579 {
580 colorRampTexture = new Qt3DRender::QTexture1D( mat );
581 colorRampTexture->addTextureImage( new QgsColorRampTexture( mColorRampShader, 1 ) );
582 colorRampTexture->setMinificationFilter( Qt3DRender::QTexture1D::Linear );
583 colorRampTexture->setMagnificationFilter( Qt3DRender::QTexture1D::Linear );
584 }
585
586 // Parameters
587 Qt3DRender::QParameter *colorRampTextureParameter = new Qt3DRender::QParameter( "u_colorRampTexture", colorRampTexture );
588 mat->addParameter( colorRampTextureParameter );
589 Qt3DRender::QParameter *colorRampCountParameter = new Qt3DRender::QParameter( "u_colorRampCount", mColorRampShader.colorRampItemList().count() );
590 mat->addParameter( colorRampCountParameter );
591 const Qgis::ShaderInterpolationMethod colorRampType = mColorRampShader.colorRampType();
592 Qt3DRender::QParameter *colorRampTypeParameter = new Qt3DRender::QParameter( "u_colorRampType", static_cast<int>( colorRampType ) );
593 mat->addParameter( colorRampTypeParameter );
594}
ShaderInterpolationMethod
Color ramp shader interpolation methods.
Definition qgis.h:1335
@ Exact
Assigns the color of the exact matching value in the color ramp item list.
@ Continuous
Uses breaks from color palette.
@ 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
void fillMaterial(QgsMaterial *material) override SIP_SKIP
Used to fill material object with necessary QParameters (and consequently opengl uniforms)
QString attribute() const
Returns the attribute used to select the color of the point cloud.
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.
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.
void fillMaterial(QgsMaterial *material) override SIP_SKIP
Used to fill material object with necessary QParameters (and consequently opengl uniforms)
A ramp shader will color a raster pixel based on a list of values ranges in a ramp.
Qgis::ShaderInterpolationMethod colorRampType() const
Returns the color ramp interpolation method.
void setClassificationMode(Qgis::ShaderClassificationMethod classificationMode)
Sets the classification mode.
QList< QgsColorRampShader::ColorRampItem > colorRampItemList() const
Returns the custom color map.
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context=QgsReadWriteContext()) const
Writes configuration to a new DOM element.
void setColorRampType(Qgis::ShaderInterpolationMethod colorRampType)
Sets the color ramp interpolation method.
void setColorRampItemList(const QList< QgsColorRampShader::ColorRampItem > &list)
Sets a custom color map.
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)
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.
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.
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 fillMaterial(QgsMaterial *material) override SIP_SKIP
Used to fill material object with necessary QParameters (and consequently opengl uniforms)
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(QgsMaterial *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
void setSingleColor(QColor color)
Sets the color used by the renderer when using SingleColor rendering mode.
QList< QgsPointCloudCategory > QgsPointCloudCategoryList