QGIS API Documentation  3.23.0-Master (7c4a6de034)
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 
16 #include "qgspointcloud3dsymbol.h"
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 
40 // QgsSingleColorPointCloud3DSymbol
41 
44 {
45 
46 }
47 
49 {
50  return QStringLiteral( "single-color" );
51 }
52 
54 {
56  result->mPointSize = mPointSize;
57  result->mSingleColor = mSingleColor;
58  copyBaseSettings( result );
59  return result;
60 }
61 
62 void QgsSingleColorPointCloud3DSymbol::writeXml( QDomElement &elem, const QgsReadWriteContext &context ) const
63 {
64  Q_UNUSED( context )
65 
66  elem.setAttribute( QStringLiteral( "point-size" ), mPointSize );
67  elem.setAttribute( QStringLiteral( "single-color" ), QgsSymbolLayerUtils::encodeColor( mSingleColor ) );
68 }
69 
70 void QgsSingleColorPointCloud3DSymbol::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
71 {
72  Q_UNUSED( context )
73 
74  mPointSize = elem.attribute( QStringLiteral( "point-size" ), QStringLiteral( "2.0" ) ).toFloat();
75  mSingleColor = QgsSymbolLayerUtils::decodeColor( elem.attribute( QStringLiteral( "single-color" ), QStringLiteral( "0,0,255" ) ) );
76 }
77 
79 {
80  mSingleColor = color;
81 }
82 
83 void QgsSingleColorPointCloud3DSymbol::fillMaterial( Qt3DRender::QMaterial *mat )
84 {
85  Qt3DRender::QParameter *renderingStyle = new Qt3DRender::QParameter( "u_renderingStyle", QgsPointCloud3DSymbol::SingleColor );
86  mat->addParameter( renderingStyle );
87  Qt3DRender::QParameter *pointSizeParameter = new Qt3DRender::QParameter( "u_pointSize", QVariant::fromValue( mPointSize ) );
88  mat->addParameter( pointSizeParameter );
89  Qt3DRender::QParameter *singleColorParameter = new Qt3DRender::QParameter( "u_singleColor", QVector3D( mSingleColor.redF(), mSingleColor.greenF(), mSingleColor.blueF() ) );
90  mat->addParameter( singleColorParameter );
91 }
92 
93 // QgsColorRampPointCloud3DSymbol
94 
97 {
98 
99 }
100 
102 {
104  result->mPointSize = mPointSize;
105  result->mRenderingParameter = mRenderingParameter;
106  result->mColorRampShader = mColorRampShader;
107  result->mColorRampShaderMin = mColorRampShaderMin;
108  result->mColorRampShaderMax = mColorRampShaderMax;
109  copyBaseSettings( result );
110  return result;
111 }
112 
114 {
115  return QStringLiteral( "color-ramp" );
116 }
117 
118 void QgsColorRampPointCloud3DSymbol::writeXml( QDomElement &elem, const QgsReadWriteContext &context ) const
119 {
120  Q_UNUSED( context )
121 
122  elem.setAttribute( QStringLiteral( "point-size" ), mPointSize );
123  elem.setAttribute( QStringLiteral( "rendering-parameter" ), mRenderingParameter );
124  elem.setAttribute( QStringLiteral( "color-ramp-shader-min" ), mColorRampShaderMin );
125  elem.setAttribute( QStringLiteral( "color-ramp-shader-max" ), mColorRampShaderMax );
126  QDomDocument doc = elem.ownerDocument();
127  const QDomElement elemColorRampShader = mColorRampShader.writeXml( doc );
128  elem.appendChild( elemColorRampShader );
129 }
130 
131 void QgsColorRampPointCloud3DSymbol::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
132 {
133  Q_UNUSED( context )
134 
135  mPointSize = elem.attribute( "point-size", QStringLiteral( "2.0" ) ).toFloat();
136  mRenderingParameter = elem.attribute( "rendering-parameter", QString() );
137  mColorRampShaderMin = elem.attribute( QStringLiteral( "color-ramp-shader-min" ), QStringLiteral( "0.0" ) ).toDouble();
138  mColorRampShaderMax = elem.attribute( QStringLiteral( "color-ramp-shader-max" ), QStringLiteral( "1.0" ) ).toDouble();
139  mColorRampShader.readXml( elem );
140 }
141 
143 {
144  return mRenderingParameter;
145 }
146 
147 void QgsColorRampPointCloud3DSymbol::setAttribute( const QString &parameter )
148 {
149  mRenderingParameter = parameter;
150 }
151 
153 {
154  return mColorRampShader;
155 }
156 
158 {
159  mColorRampShader = colorRampShader;
160 }
161 
163 {
164  mColorRampShaderMin = min;
165  mColorRampShaderMax = max;
166 }
167 
168 void QgsColorRampPointCloud3DSymbol::fillMaterial( Qt3DRender::QMaterial *mat )
169 {
170  Qt3DRender::QParameter *renderingStyle = new Qt3DRender::QParameter( "u_renderingStyle", QgsPointCloud3DSymbol::ColorRamp );
171  mat->addParameter( renderingStyle );
172  Qt3DRender::QParameter *pointSizeParameter = new Qt3DRender::QParameter( "u_pointSize", QVariant::fromValue( mPointSize ) );
173  mat->addParameter( pointSizeParameter );
174  // Create the texture to pass the color ramp
175  Qt3DRender::QTexture1D *colorRampTexture = nullptr;
176  if ( mColorRampShader.colorRampItemList().count() > 0 )
177  {
178  colorRampTexture = new Qt3DRender::QTexture1D( mat );
179  colorRampTexture->addTextureImage( new QgsColorRampTexture( mColorRampShader, 1 ) );
180  colorRampTexture->setMinificationFilter( Qt3DRender::QTexture1D::Linear );
181  colorRampTexture->setMagnificationFilter( Qt3DRender::QTexture1D::Linear );
182  }
183 
184  // Parameters
185  Qt3DRender::QParameter *colorRampTextureParameter = new Qt3DRender::QParameter( "u_colorRampTexture", colorRampTexture );
186  mat->addParameter( colorRampTextureParameter );
187  Qt3DRender::QParameter *colorRampCountParameter = new Qt3DRender::QParameter( "u_colorRampCount", mColorRampShader.colorRampItemList().count() );
188  mat->addParameter( colorRampCountParameter );
189  const int colorRampType = mColorRampShader.colorRampType();
190  Qt3DRender::QParameter *colorRampTypeParameter = new Qt3DRender::QParameter( "u_colorRampType", colorRampType );
191  mat->addParameter( colorRampTypeParameter );
192 }
193 
194 // QgsRgbPointCloud3DSymbol
195 
198 {
199 
200 }
201 
203 {
204  return QStringLiteral( "rgb" );
205 }
206 
208 {
210  result->mPointSize = mPointSize;
211  result->mRedAttribute = mRedAttribute;
212  result->mGreenAttribute = mGreenAttribute;
213  result->mBlueAttribute = mBlueAttribute;
214 
215  if ( mRedContrastEnhancement )
216  {
217  result->setRedContrastEnhancement( new QgsContrastEnhancement( *mRedContrastEnhancement ) );
218  }
219  if ( mGreenContrastEnhancement )
220  {
221  result->setGreenContrastEnhancement( new QgsContrastEnhancement( *mGreenContrastEnhancement ) );
222  }
223  if ( mBlueContrastEnhancement )
224  {
225  result->setBlueContrastEnhancement( new QgsContrastEnhancement( *mBlueContrastEnhancement ) );
226  }
227  copyBaseSettings( result );
228  return result;
229 }
230 
231 void QgsRgbPointCloud3DSymbol::writeXml( QDomElement &elem, const QgsReadWriteContext &context ) const
232 {
233  Q_UNUSED( context )
234  elem.setAttribute( QStringLiteral( "point-size" ), mPointSize );
235 
236  elem.setAttribute( QStringLiteral( "red" ), mRedAttribute );
237  elem.setAttribute( QStringLiteral( "green" ), mGreenAttribute );
238  elem.setAttribute( QStringLiteral( "blue" ), mBlueAttribute );
239 
240  QDomDocument doc = elem.ownerDocument();
241 
242  //contrast enhancement
243  if ( mRedContrastEnhancement )
244  {
245  QDomElement redContrastElem = doc.createElement( QStringLiteral( "redContrastEnhancement" ) );
246  mRedContrastEnhancement->writeXml( doc, redContrastElem );
247  elem.appendChild( redContrastElem );
248  }
249  if ( mGreenContrastEnhancement )
250  {
251  QDomElement greenContrastElem = doc.createElement( QStringLiteral( "greenContrastEnhancement" ) );
252  mGreenContrastEnhancement->writeXml( doc, greenContrastElem );
253  elem.appendChild( greenContrastElem );
254  }
255  if ( mBlueContrastEnhancement )
256  {
257  QDomElement blueContrastElem = doc.createElement( QStringLiteral( "blueContrastEnhancement" ) );
258  mBlueContrastEnhancement->writeXml( doc, blueContrastElem );
259  elem.appendChild( blueContrastElem );
260  }
261 }
262 
263 void QgsRgbPointCloud3DSymbol::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
264 {
265  Q_UNUSED( context )
266  mPointSize = elem.attribute( "point-size", QStringLiteral( "2.0" ) ).toFloat();
267 
268  setRedAttribute( elem.attribute( QStringLiteral( "red" ), QStringLiteral( "Red" ) ) );
269  setGreenAttribute( elem.attribute( QStringLiteral( "green" ), QStringLiteral( "Green" ) ) );
270  setBlueAttribute( elem.attribute( QStringLiteral( "blue" ), QStringLiteral( "Blue" ) ) );
271 
272  //contrast enhancements
274  const QDomElement redContrastElem = elem.firstChildElement( QStringLiteral( "redContrastEnhancement" ) );
275  if ( !redContrastElem.isNull() )
276  {
278  redContrastEnhancement->readXml( redContrastElem );
280  }
281 
283  const QDomElement greenContrastElem = elem.firstChildElement( QStringLiteral( "greenContrastEnhancement" ) );
284  if ( !greenContrastElem.isNull() )
285  {
287  greenContrastEnhancement->readXml( greenContrastElem );
289  }
290 
292  const QDomElement blueContrastElem = elem.firstChildElement( QStringLiteral( "blueContrastEnhancement" ) );
293  if ( !blueContrastElem.isNull() )
294  {
296  blueContrastEnhancement->readXml( blueContrastElem );
298  }
299 }
300 
301 void QgsRgbPointCloud3DSymbol::fillMaterial( Qt3DRender::QMaterial *mat )
302 {
303  Qt3DRender::QParameter *renderingStyle = new Qt3DRender::QParameter( "u_renderingStyle", QgsPointCloud3DSymbol::RgbRendering );
304  mat->addParameter( renderingStyle );
305  Qt3DRender::QParameter *pointSizeParameter = new Qt3DRender::QParameter( "u_pointSize", QVariant::fromValue( mPointSize ) );
306  mat->addParameter( pointSizeParameter );
307 }
308 
309 
311 {
312  return mRedAttribute;
313 }
314 
315 void QgsRgbPointCloud3DSymbol::setRedAttribute( const QString &redAttribute )
316 {
317  mRedAttribute = redAttribute;
318 }
319 
321 {
322  return mGreenAttribute;
323 }
324 
325 void QgsRgbPointCloud3DSymbol::setGreenAttribute( const QString &greenAttribute )
326 {
327  mGreenAttribute = greenAttribute;
328 }
329 
331 {
332  return mBlueAttribute;
333 }
334 
335 void QgsRgbPointCloud3DSymbol::setBlueAttribute( const QString &blueAttribute )
336 {
337  mBlueAttribute = blueAttribute;
338 }
339 
341 {
342  return mRedContrastEnhancement.get();
343 }
344 
346 {
347  mRedContrastEnhancement.reset( enhancement );
348 }
349 
351 {
352  return mGreenContrastEnhancement.get();
353 }
354 
356 {
357  mGreenContrastEnhancement.reset( enhancement );
358 }
359 
361 {
362  return mBlueContrastEnhancement.get();
363 }
364 
366 {
367  mBlueContrastEnhancement.reset( enhancement );
368 }
369 
370 // QgsClassificationPointCloud3DSymbol
371 
372 
375 {
376 
377 }
378 
380 {
382  result->mPointSize = mPointSize;
383  result->mRenderingParameter = mRenderingParameter;
384  result->mCategoriesList = mCategoriesList;
385  copyBaseSettings( result );
386  return result;
387 }
388 
390 {
391  return QStringLiteral( "classification" );
392 }
393 
394 void QgsClassificationPointCloud3DSymbol::writeXml( QDomElement &elem, const QgsReadWriteContext &context ) const
395 {
396  Q_UNUSED( context )
397  QDomDocument doc = elem.ownerDocument();
398 
399  elem.setAttribute( QStringLiteral( "point-size" ), mPointSize );
400  elem.setAttribute( QStringLiteral( "rendering-parameter" ), mRenderingParameter );
401 
402  // categories
403  QDomElement catsElem = doc.createElement( QStringLiteral( "categories" ) );
404  for ( const QgsPointCloudCategory &category : mCategoriesList )
405  {
406  QDomElement catElem = doc.createElement( QStringLiteral( "category" ) );
407  catElem.setAttribute( QStringLiteral( "value" ), QString::number( category.value() ) );
408  catElem.setAttribute( QStringLiteral( "label" ), category.label() );
409  catElem.setAttribute( QStringLiteral( "color" ), QgsSymbolLayerUtils::encodeColor( category.color() ) );
410  catElem.setAttribute( QStringLiteral( "render" ), category.renderState() ? "true" : "false" );
411  catsElem.appendChild( catElem );
412  }
413  elem.appendChild( catsElem );
414 }
415 
416 void QgsClassificationPointCloud3DSymbol::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
417 {
418  Q_UNUSED( context )
419 
420  mPointSize = elem.attribute( "point-size", QStringLiteral( "2.0" ) ).toFloat();
421  mRenderingParameter = elem.attribute( "rendering-parameter", QString() );
422 
423  const QDomElement catsElem = elem.firstChildElement( QStringLiteral( "categories" ) );
424  if ( !catsElem.isNull() )
425  {
426  mCategoriesList.clear();
427  QDomElement catElem = catsElem.firstChildElement();
428  while ( !catElem.isNull() )
429  {
430  if ( catElem.tagName() == QLatin1String( "category" ) )
431  {
432  const int value = catElem.attribute( QStringLiteral( "value" ) ).toInt();
433  const QString label = catElem.attribute( QStringLiteral( "label" ) );
434  const bool render = catElem.attribute( QStringLiteral( "render" ) ) != QLatin1String( "false" );
435  const QColor color = QgsSymbolLayerUtils::decodeColor( catElem.attribute( QStringLiteral( "color" ) ) );
436  mCategoriesList.append( QgsPointCloudCategory( value, color, label, render ) );
437  }
438  catElem = catElem.nextSiblingElement();
439  }
440  }
441 }
442 
444 {
445  return mRenderingParameter;
446 }
447 
449 {
450  mRenderingParameter = attribute;
451 }
452 
454 {
455  mCategoriesList = categories;
456 }
457 
459 {
460  QgsPointCloudCategoryList filteredOut;
461  for ( const QgsPointCloudCategory &category : mCategoriesList )
462  {
463  if ( !category.renderState() )
464  filteredOut.push_back( category );
465  }
466  return filteredOut;
467 }
468 
469 QgsColorRampShader QgsClassificationPointCloud3DSymbol::colorRampShader() const
470 {
471  QgsColorRampShader colorRampShader;
472  colorRampShader.setColorRampType( QgsColorRampShader::Type::Exact );
473  colorRampShader.setClassificationMode( QgsColorRampShader::ClassificationMode::Continuous );
474  QList<QgsColorRampShader::ColorRampItem> colorRampItemList;
475  for ( const QgsPointCloudCategory &category : mCategoriesList )
476  {
477  const QColor color = category.color();
478  const QgsColorRampShader::ColorRampItem item( category.value(), color, category.label() );
479  colorRampItemList.push_back( item );
480  }
481  colorRampShader.setColorRampItemList( colorRampItemList );
482  return colorRampShader;
483 }
484 
485 
486 void QgsClassificationPointCloud3DSymbol::fillMaterial( Qt3DRender::QMaterial *mat )
487 {
488  const QgsColorRampShader mColorRampShader = colorRampShader();
489  Qt3DRender::QParameter *renderingStyle = new Qt3DRender::QParameter( "u_renderingStyle", QgsPointCloud3DSymbol::ColorRamp );
490  mat->addParameter( renderingStyle );
491  Qt3DRender::QParameter *pointSizeParameter = new Qt3DRender::QParameter( "u_pointSize", QVariant::fromValue( mPointSize ) );
492  mat->addParameter( pointSizeParameter );
493  // Create the texture to pass the color ramp
494  Qt3DRender::QTexture1D *colorRampTexture = nullptr;
495  if ( mColorRampShader.colorRampItemList().count() > 0 )
496  {
497  colorRampTexture = new Qt3DRender::QTexture1D( mat );
498  colorRampTexture->addTextureImage( new QgsColorRampTexture( mColorRampShader, 1 ) );
499  colorRampTexture->setMinificationFilter( Qt3DRender::QTexture1D::Linear );
500  colorRampTexture->setMagnificationFilter( Qt3DRender::QTexture1D::Linear );
501  }
502 
503  // Parameters
504  Qt3DRender::QParameter *colorRampTextureParameter = new Qt3DRender::QParameter( "u_colorRampTexture", colorRampTexture );
505  mat->addParameter( colorRampTextureParameter );
506  Qt3DRender::QParameter *colorRampCountParameter = new Qt3DRender::QParameter( "u_colorRampCount", mColorRampShader.colorRampItemList().count() );
507  mat->addParameter( colorRampCountParameter );
508  const int colorRampType = mColorRampShader.colorRampType();
509  Qt3DRender::QParameter *colorRampTypeParameter = new Qt3DRender::QParameter( "u_colorRampType", colorRampType );
510  mat->addParameter( colorRampTypeParameter );
511 }
512 
@ UnknownDataType
Unknown or unspecified type.
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.
QList< QgsColorRampShader::ColorRampItem > colorRampItemList() const
Returns the custom colormap.
Type colorRampType() const
Returns the color ramp type.
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.
void setPointSize(float size)
Sets the point size.
~QgsPointCloud3DSymbol() override
Destructor for QgsPointCloud3DSymbol.
@ 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.
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