sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-10-06 00:07:29 -04:00
Code Issues Packages Projects Releases Wiki Activity

address review

Browse Source
This commit is contained in:
uclaros 2022-04-01 10:27:42 +03:00 committed by Martin Dobias
parent b61bc22885
commit df740b4d0b
13 changed files with 110 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
python/3d/auto_generated/qgspointcloudlayer3drenderer.sip.in
View File

@ -104,7 +104,6 @@ Sets the maximum number of points to be rendered in the scene
virtual bool convertFrom2DRenderer( QgsPointCloudRenderer *renderer );
virtual bool syncedWith2DRenderer();
private:
QgsPointCloudLayer3DRenderer( const QgsPointCloudLayer3DRenderer & );

12
python/core/auto_generated/3d/qgsabstractpointcloud3drenderer.sip.in
View File

@ -31,18 +31,6 @@ This class allows for functionality in 3D to be called from core.
Updates the 3D renderer's symbol to match that of a given :py:class:`QgsPointCloudRenderer`
:return: ``True`` on success, ``False`` otherwise
%End
virtual void setSyncedWith2DRenderer( bool synced ) = 0;
%Docstring
Sets whether this 3D renderer should be automatically updated
with changes applied to the respective layer's 2D renderer
%End
virtual bool syncedWith2DRenderer() = 0;
%Docstring
Returns whether this 3D renderer should be automatically updated
with changes applied to the respective layer's 2D renderer
%End
protected:

30
src/3d/qgs3dutils.cpp
View File

@ -735,7 +735,7 @@ QVector2D Qgs3DUtils::textureToScreenCoordinates( QVector2D textureXY, QSize win
return QVector2D( textureXY.x() * winSize.width(), ( 1 - textureXY.y() ) * winSize.height() );
}
std::unique_ptr<QgsPointCloudLayer3DRenderer> Qgs3DUtils::convert2dPointCloudRendererTo3d( QgsPointCloudRenderer *renderer )
std::unique_ptr<QgsPointCloudLayer3DRenderer> Qgs3DUtils::convert2DPointCloudRendererTo3D( QgsPointCloudRenderer *renderer )
{
if ( !renderer )
return nullptr;
@ -743,34 +743,34 @@ std::unique_ptr<QgsPointCloudLayer3DRenderer> Qgs3DUtils::convert2dPointCloudRen
std::unique_ptr< QgsPointCloud3DSymbol > symbol3D;
if ( renderer->type() == QLatin1String( "ramp" ) )
{
const QgsPointCloudAttributeByRampRenderer *renderer2d = dynamic_cast< const QgsPointCloudAttributeByRampRenderer * >( renderer );
const QgsPointCloudAttributeByRampRenderer *renderer2D = dynamic_cast< const QgsPointCloudAttributeByRampRenderer * >( renderer );
symbol3D = std::make_unique< QgsColorRampPointCloud3DSymbol >();
QgsColorRampPointCloud3DSymbol *symbol = static_cast< QgsColorRampPointCloud3DSymbol * >( symbol3D.get() );
symbol->setAttribute( renderer2d->attribute() );
symbol->setColorRampShaderMinMax( renderer2d->minimum(), renderer2d->maximum() );
symbol->setColorRampShader( renderer2d->colorRampShader() );
symbol->setAttribute( renderer2D->attribute() );
symbol->setColorRampShaderMinMax( renderer2D->minimum(), renderer2D->maximum() );
symbol->setColorRampShader( renderer2D->colorRampShader() );
}
else if ( renderer->type() == QLatin1String( "rgb" ) )
{
const QgsPointCloudRgbRenderer *renderer2d = dynamic_cast< const QgsPointCloudRgbRenderer * >( renderer );
const QgsPointCloudRgbRenderer *renderer2D = dynamic_cast< const QgsPointCloudRgbRenderer * >( renderer );
symbol3D = std::make_unique< QgsRgbPointCloud3DSymbol >();
QgsRgbPointCloud3DSymbol *symbol = static_cast< QgsRgbPointCloud3DSymbol * >( symbol3D.get() );
symbol->setRedAttribute( renderer2d->redAttribute() );
symbol->setGreenAttribute( renderer2d->greenAttribute() );
symbol->setBlueAttribute( renderer2d->blueAttribute() );
symbol->setRedAttribute( renderer2D->redAttribute() );
symbol->setGreenAttribute( renderer2D->greenAttribute() );
symbol->setBlueAttribute( renderer2D->blueAttribute() );
symbol->setRedContrastEnhancement( renderer2d->redContrastEnhancement() ? new QgsContrastEnhancement( *renderer2d->redContrastEnhancement() ) : nullptr );
symbol->setGreenContrastEnhancement( renderer2d->greenContrastEnhancement() ? new QgsContrastEnhancement( *renderer2d->greenContrastEnhancement() ) : nullptr );
symbol->setBlueContrastEnhancement( renderer2d->blueContrastEnhancement() ? new QgsContrastEnhancement( *renderer2d->blueContrastEnhancement() ) : nullptr );
symbol->setRedContrastEnhancement( renderer2D->redContrastEnhancement() ? new QgsContrastEnhancement( *renderer2D->redContrastEnhancement() ) : nullptr );
symbol->setGreenContrastEnhancement( renderer2D->greenContrastEnhancement() ? new QgsContrastEnhancement( *renderer2D->greenContrastEnhancement() ) : nullptr );
symbol->setBlueContrastEnhancement( renderer2D->blueContrastEnhancement() ? new QgsContrastEnhancement( *renderer2D->blueContrastEnhancement() ) : nullptr );
}
else if ( renderer->type() == QLatin1String( "classified" ) )
{
const QgsPointCloudClassifiedRenderer *renderer2d = dynamic_cast< const QgsPointCloudClassifiedRenderer * >( renderer );
const QgsPointCloudClassifiedRenderer *renderer2D = dynamic_cast< const QgsPointCloudClassifiedRenderer * >( renderer );
symbol3D = std::make_unique< QgsClassificationPointCloud3DSymbol >();
QgsClassificationPointCloud3DSymbol *symbol = static_cast< QgsClassificationPointCloud3DSymbol * >( symbol3D.get() );
symbol->setAttribute( renderer2d->attribute() );
symbol->setCategoriesList( renderer2d->categories() );
symbol->setAttribute( renderer2D->attribute() );
symbol->setCategoriesList( renderer2D->categories() );
}
if ( symbol3D )

2
src/3d/qgs3dutils.h
View File

@ -237,7 +237,7 @@ class _3D_EXPORT Qgs3DUtils
* \note This function was formerly in Qgs3DAppUtils
* \since QGIS 3.26
*/
static std::unique_ptr< QgsPointCloudLayer3DRenderer > convert2dPointCloudRendererTo3d( QgsPointCloudRenderer *renderer );
static std::unique_ptr< QgsPointCloudLayer3DRenderer > convert2DPointCloudRendererTo3D( QgsPointCloudRenderer *renderer );
};
#endif // QGS3DUTILS_H

4
src/3d/qgspointcloudlayer3drenderer.cpp
View File

@ -156,7 +156,6 @@ void QgsPointCloudLayer3DRenderer::writeXml( QDomElement &elem, const QgsReadWri
elem.setAttribute( QStringLiteral( "max-screen-error" ), maximumScreenError() );
elem.setAttribute( QStringLiteral( "show-bounding-boxes" ), showBoundingBoxes() ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
elem.setAttribute( QStringLiteral( "point-budget" ), mPointBudget );
elem.setAttribute( QStringLiteral( "synced-with-2d-renderer" ), mSyncedWith2DRenderer ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
QDomElement elemSymbol = doc.createElement( QStringLiteral( "symbol" ) );
if ( mSymbol )
@ -177,7 +176,6 @@ void QgsPointCloudLayer3DRenderer::readXml( const QDomElement &elem, const QgsRe
mShowBoundingBoxes = elem.attribute( QStringLiteral( "show-bounding-boxes" ), QStringLiteral( "0" ) ).toInt();
mMaximumScreenError = elem.attribute( QStringLiteral( "max-screen-error" ), QStringLiteral( "1.0" ) ).toDouble();
mPointBudget = elem.attribute( QStringLiteral( "point-budget" ), QStringLiteral( "1000000" ) ).toInt();
mSyncedWith2DRenderer = elem.attribute( QStringLiteral( "synced-with-2d-renderer" ), QStringLiteral( "0" ) ).toInt();
if ( symbolType == QLatin1String( "single-color" ) )
mSymbol.reset( new QgsSingleColorPointCloud3DSymbol );
@ -226,7 +224,7 @@ void QgsPointCloudLayer3DRenderer::setPointRenderingBudget( int budget )
bool QgsPointCloudLayer3DRenderer::convertFrom2DRenderer( QgsPointCloudRenderer *renderer )
{
std::unique_ptr< QgsPointCloudLayer3DRenderer > renderer3D = Qgs3DUtils::convert2dPointCloudRendererTo3d( renderer );
std::unique_ptr< QgsPointCloudLayer3DRenderer > renderer3D = Qgs3DUtils::convert2DPointCloudRendererTo3D( renderer );
if ( !renderer3D )
{
setSymbol( nullptr );

3
src/3d/qgspointcloudlayer3drenderer.h
View File

@ -296,8 +296,6 @@ class _3D_EXPORT QgsPointCloudLayer3DRenderer : public QgsAbstractPointCloud3DRe
void setPointRenderingBudget( int budget );
bool convertFrom2DRenderer( QgsPointCloudRenderer *renderer ) override;
bool syncedWith2DRenderer() override { return mSyncedWith2DRenderer; };
void setSyncedWith2DRenderer( bool synced ) override { mSyncedWith2DRenderer = synced; };
private:
QgsMapLayerRef mLayerRef; //!< Layer used to extract mesh data from
@ -305,7 +303,6 @@ class _3D_EXPORT QgsPointCloudLayer3DRenderer : public QgsAbstractPointCloud3DRe
double mMaximumScreenError = 1.0;
bool mShowBoundingBoxes = false;
int mPointBudget = 1000000;
bool mSyncedWith2DRenderer = false;
private:
#ifdef SIP_RUN

8
src/app/3d/qgspointcloud3dsymbolwidget.cpp
View File

@ -48,7 +48,7 @@ QgsPointCloud3DSymbolWidget::QgsPointCloud3DSymbolWidget( QgsPointCloudLayer *la
mSingleColorBtn->setColor( QColor( 0, 0, 255 ) ); // default color
mRenderingStyleComboBox->addItem( tr( "No Rendering" ), QString() );
mRenderingStyleComboBox->addItem( tr( "Follow 2d renderer" ), QStringLiteral( "2d" ) );
mRenderingStyleComboBox->addItem( tr( "Follow 2D Symbology" ), QStringLiteral( "2D" ) );
mRenderingStyleComboBox->addItem( QgsApplication::getThemeIcon( QStringLiteral( "styleicons/singlecolor.svg" ) ), tr( "Single Color" ), QStringLiteral( "single-color" ) );
mRenderingStyleComboBox->addItem( QgsApplication::getThemeIcon( QStringLiteral( "styleicons/singlebandpseudocolor.svg" ) ), tr( "Attribute by Ramp" ), QStringLiteral( "color-ramp" ) );
mRenderingStyleComboBox->addItem( QgsApplication::getThemeIcon( QStringLiteral( "styleicons/multibandcolor.svg" ) ), tr( "RGB" ), QStringLiteral( "rgb" ) );
@ -229,10 +229,10 @@ QgsPointCloud3DSymbol *QgsPointCloud3DSymbolWidget::symbol() const
QgsPointCloud3DSymbol *retSymb = nullptr;
const QString symbolType = mRenderingStyleComboBox->currentData().toString();
if ( symbolType == QLatin1String( "2d" ) )
if ( symbolType == QLatin1String( "2D" ) )
{
// we still need to return some symbol since it carries needed settings like the point size
// any symbol type is ok, it will be replaced with the proper one, converted from the 2d renderer
// any symbol type is ok, it will be replaced with the proper one, converted from the 2D renderer
retSymb = new QgsSingleColorPointCloud3DSymbol;
}
else if ( symbolType == QLatin1String( "single-color" ) )
@ -422,7 +422,7 @@ void QgsPointCloud3DSymbolWidget::onRenderingStyleChanged()
const QString newSymbolType = mRenderingStyleComboBox->currentData().toString();
mLayer->setSync3DRendererTo2DRenderer( false );
if ( newSymbolType == QLatin1String( "2d" ) )
if ( newSymbolType == QLatin1String( "2D" ) )
{
mLayer->setSync3DRendererTo2DRenderer( true );
}

4
src/app/qgisapp.cpp
View File

@ -5833,7 +5833,7 @@ void QgisApp::postProcessAddedLayer( QgsMapLayer *layer )
{
QgsPointCloudLayer *pcLayer = qobject_cast< QgsPointCloudLayer * >( layer );
// for point clouds we default to a 3d renderer. it just makes sense :)
std::unique_ptr< QgsPointCloudLayer3DRenderer > renderer3D = Qgs3DUtils::convert2dPointCloudRendererTo3d( pcLayer->renderer() );
std::unique_ptr< QgsPointCloudLayer3DRenderer > renderer3D = Qgs3DUtils::convert2DPointCloudRendererTo3D( pcLayer->renderer() );
if ( renderer3D )
layer->setRenderer3D( renderer3D.release() );
else
@ -5847,7 +5847,7 @@ void QgisApp::postProcessAddedLayer( QgsMapLayer *layer )
if ( !layerPointer || state != QgsPointCloudDataProvider::Indexed )
return;
std::unique_ptr< QgsPointCloudLayer3DRenderer > renderer3D = Qgs3DUtils::convert2dPointCloudRendererTo3d( layerPointer->renderer() );
std::unique_ptr< QgsPointCloudLayer3DRenderer > renderer3D = Qgs3DUtils::convert2DPointCloudRendererTo3D( layerPointer->renderer() );
if ( renderer3D )
layerPointer->setRenderer3D( renderer3D.release() );
} );

12
src/core/3d/qgsabstractpointcloud3drenderer.h
View File

@ -50,18 +50,6 @@ class CORE_EXPORT QgsAbstractPointCloud3DRenderer : public QgsAbstract3DRenderer
*/
virtual bool convertFrom2DRenderer( QgsPointCloudRenderer *renderer ) = 0;
/**
* Sets whether this 3D renderer should be automatically updated
* with changes applied to the respective layer's 2D renderer
*/
virtual void setSyncedWith2DRenderer( bool synced ) = 0;
/**
* Returns whether this 3D renderer should be automatically updated
* with changes applied to the respective layer's 2D renderer
*/
virtual bool syncedWith2DRenderer() = 0;
protected:
//! Default constructor
QgsAbstractPointCloud3DRenderer() = default;

37
src/core/pointcloud/qgspointcloudlayer.cpp
View File

@ -197,6 +197,14 @@ bool QgsPointCloudLayer::readStyle( const QDomNode &node, QString &, QgsReadWrit
{
bool result = true;
if ( categories.testFlag( Symbology3D ) )
{
bool ok;
bool sync = node.attributes().namedItem( QStringLiteral( "sync3DRendererTo2DRenderer" ) ).nodeValue().toInt( &ok );
if ( ok )
setSync3DRendererTo2DRenderer( sync );
}
if ( categories.testFlag( Symbology ) )
{
QDomElement rendererElement = node.firstChildElement( QStringLiteral( "renderer" ) );
@ -274,6 +282,11 @@ bool QgsPointCloudLayer::writeStyle( QDomNode &node, QDomDocument &doc, QString
{
QDomElement mapLayerNode = node.toElement();
if ( categories.testFlag( Symbology3D ) )
{
mapLayerNode.setAttribute( QStringLiteral( "sync3DRendererTo2DRenderer" ), mSync3DRendererTo2DRenderer ? 1 : 0 );
}
if ( categories.testFlag( Symbology ) )
{
if ( mRenderer )
@ -310,7 +323,6 @@ bool QgsPointCloudLayer::writeStyle( QDomNode &node, QDomDocument &doc, QString
mapLayerNode.setAttribute( QStringLiteral( "maxScale" ), maximumScale() );
mapLayerNode.setAttribute( QStringLiteral( "minScale" ), minimumScale() );
}
return true;
}
@ -680,8 +692,7 @@ void QgsPointCloudLayer::setRenderer( QgsPointCloudRenderer *renderer )
emit rendererChanged();
emitStyleChanged();
QgsAbstractPointCloud3DRenderer *r = static_cast<QgsAbstractPointCloud3DRenderer *>( renderer3D() );
if ( r && r->syncedWith2DRenderer() )
if ( mSync3DRendererTo2DRenderer )
convertRenderer3DFromRenderer2D();
}
@ -717,27 +728,25 @@ QString QgsPointCloudLayer::subsetString() const
bool QgsPointCloudLayer::convertRenderer3DFromRenderer2D()
{
bool result = false;
QgsAbstractPointCloud3DRenderer *r = static_cast<QgsAbstractPointCloud3DRenderer *>( renderer3D() );
bool result = r->convertFrom2DRenderer( renderer() );
setRenderer3D( r );
trigger3DUpdate();
if ( r )
{
result = r->convertFrom2DRenderer( renderer() );
setRenderer3D( r );
trigger3DUpdate();
}
return result;
}
bool QgsPointCloudLayer::sync3DRendererTo2DRenderer() const
{
QgsAbstractPointCloud3DRenderer *r = static_cast<QgsAbstractPointCloud3DRenderer *>( renderer3D() );
if ( !r )
return false;
return r->syncedWith2DRenderer();
return mSync3DRendererTo2DRenderer;
}
void QgsPointCloudLayer::setSync3DRendererTo2DRenderer( bool sync )
{
QgsAbstractPointCloud3DRenderer *r = static_cast<QgsAbstractPointCloud3DRenderer *>( renderer3D() );
if ( !r )
return;
mSync3DRendererTo2DRenderer = sync;
if ( sync )
convertRenderer3DFromRenderer2D();
r->setSyncedWith2DRenderer( sync );
}

2
src/core/pointcloud/qgspointcloudlayer.h
View File

@ -245,6 +245,8 @@ class CORE_EXPORT QgsPointCloudLayer : public QgsMapLayer
std::unique_ptr<QgsPointCloudRenderer> mRenderer;
QgsPointCloudLayerElevationProperties *mElevationProperties = nullptr;
bool mSync3DRendererTo2DRenderer = false;
};

4
src/ui/3d/qgspointcloud3dsymbolwidget.ui
View File

@ -202,7 +202,7 @@
<number>0</number>
</property>
<widget class="QWidget" name="noRendererPage"/>
<widget class="QWidget" name="follow2dRendererPage">
<widget class="QWidget" name="follow2DRendererPage">
<layout class="QGridLayout" name="gridLayout_9">
<property name="leftMargin">
<number>0</number>
@ -216,7 +216,7 @@
<item row="0" column="0">
<widget class="QLabel" name="label_8">
<property name="text">
<string>See 2d renderer settings</string>
<string>See 2D Symbology settings</string>
</property>
<property name="alignment">
<set>Qt::AlignCenter</set>

120
tests/src/3d/testqgspointcloud3drendering.cpp
View File

@ -101,7 +101,7 @@ void TestQgsPointCloud3DRendering::initTestCase()
mProject->addMapLayer( mLayer );
mProject->setCrs( mLayer->crs() );
// set a default 3d renderer
// set a default 3D renderer
QgsSingleColorPointCloud3DSymbol *symbol = new QgsSingleColorPointCloud3DSymbol();
symbol->setSingleColor( QColor( 255, 0, 0 ) );
QgsPointCloudLayer3DRenderer *renderer = new QgsPointCloudLayer3DRenderer();
@ -128,7 +128,7 @@ void TestQgsPointCloud3DRendering::cleanupTestCase()
void TestQgsPointCloud3DRendering::testSync3DRendererTo2DRenderer()
{
// gather different 2d renderers
// gather different 2D renderers
QgsPointCloudExtentRenderer *extent2DRenderer = new QgsPointCloudExtentRenderer();
QgsPointCloudAttributeByRampRenderer *colorramp2DRenderer = new QgsPointCloudAttributeByRampRenderer();
colorramp2DRenderer->setAttribute( QStringLiteral( "Z" ) );
@ -147,58 +147,58 @@ void TestQgsPointCloud3DRendering::testSync3DRendererTo2DRenderer()
categories[5].setColor( QColor( 0, 255, 0 ) );
classification2DRenderer->setCategories( categories );
// enable syncing, the 3d renderer should change when the 2d renderer changes
// enable syncing, the 3D renderer should change when the 2D renderer changes
mLayer->setSync3DRendererTo2DRenderer( true );
{
// for the extent 2d renderer we should have a 3d renderer but no symbol
// for the extent 2D renderer we should have a 3D renderer but no symbol
mLayer->setRenderer( extent2DRenderer );
QgsPointCloudLayer3DRenderer *r3d = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3d );
QVERIFY( !r3d->symbol() );
QgsPointCloudLayer3DRenderer *r3D = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3D );
QVERIFY( !r3D->symbol() );
}
{
mLayer->setRenderer( colorramp2DRenderer );
QgsPointCloudAttributeByRampRenderer *r2d = static_cast<QgsPointCloudAttributeByRampRenderer *>( mLayer->renderer() );
QgsPointCloudLayer3DRenderer *r3d = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3d );
const QgsColorRampPointCloud3DSymbol *s = dynamic_cast<const QgsColorRampPointCloud3DSymbol *>( r3d->symbol() );
QgsPointCloudAttributeByRampRenderer *r2D = static_cast<QgsPointCloudAttributeByRampRenderer *>( mLayer->renderer() );
QgsPointCloudLayer3DRenderer *r3D = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3D );
const QgsColorRampPointCloud3DSymbol *s = dynamic_cast<const QgsColorRampPointCloud3DSymbol *>( r3D->symbol() );
QVERIFY( s );
QVERIFY( s->attribute() == r2d->attribute() );
QVERIFY( s->colorRampShader() == r2d->colorRampShader() );
QVERIFY( s->colorRampShaderMin() == r2d->minimum() );
QVERIFY( s->colorRampShaderMax() == r2d->maximum() );
QVERIFY( s->attribute() == r2D->attribute() );
QVERIFY( s->colorRampShader() == r2D->colorRampShader() );
QVERIFY( s->colorRampShaderMin() == r2D->minimum() );
QVERIFY( s->colorRampShaderMax() == r2D->maximum() );
}
{
mLayer->setRenderer( rgb2DRenderer );
QgsPointCloudRgbRenderer *r2d = static_cast<QgsPointCloudRgbRenderer *>( mLayer->renderer() );
QgsPointCloudLayer3DRenderer *r3d = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3d );
QgsRgbPointCloud3DSymbol *s = const_cast<QgsRgbPointCloud3DSymbol *>( dynamic_cast<const QgsRgbPointCloud3DSymbol *>( r3d->symbol() ) );
QgsPointCloudRgbRenderer *r2D = static_cast<QgsPointCloudRgbRenderer *>( mLayer->renderer() );
QgsPointCloudLayer3DRenderer *r3D = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3D );
QgsRgbPointCloud3DSymbol *s = const_cast<QgsRgbPointCloud3DSymbol *>( dynamic_cast<const QgsRgbPointCloud3DSymbol *>( r3D->symbol() ) );
QVERIFY( s );
QVERIFY( s->redAttribute() == r2d->redAttribute() );
QVERIFY( s->blueAttribute() == r2d->blueAttribute() );
QVERIFY( s->greenAttribute() == r2d->greenAttribute() );
QVERIFY( s->redContrastEnhancement() == r2d->redContrastEnhancement() );
QVERIFY( s->greenContrastEnhancement() == r2d->greenContrastEnhancement() );
QVERIFY( s->blueContrastEnhancement() == r2d->blueContrastEnhancement() );
QVERIFY( s->redAttribute() == r2D->redAttribute() );
QVERIFY( s->blueAttribute() == r2D->blueAttribute() );
QVERIFY( s->greenAttribute() == r2D->greenAttribute() );
QVERIFY( s->redContrastEnhancement() == r2D->redContrastEnhancement() );
QVERIFY( s->greenContrastEnhancement() == r2D->greenContrastEnhancement() );
QVERIFY( s->blueContrastEnhancement() == r2D->blueContrastEnhancement() );
}
{
mLayer->setRenderer( classification2DRenderer );
QgsPointCloudClassifiedRenderer *r2d = static_cast<QgsPointCloudClassifiedRenderer *>( mLayer->renderer() );
QgsPointCloudLayer3DRenderer *r3d = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3d );
const QgsClassificationPointCloud3DSymbol *s = dynamic_cast<const QgsClassificationPointCloud3DSymbol *>( r3d->symbol() );
QgsPointCloudClassifiedRenderer *r2D = static_cast<QgsPointCloudClassifiedRenderer *>( mLayer->renderer() );
QgsPointCloudLayer3DRenderer *r3D = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3D );
const QgsClassificationPointCloud3DSymbol *s = dynamic_cast<const QgsClassificationPointCloud3DSymbol *>( r3D->symbol() );
QVERIFY( s );
QVERIFY( s->attribute() == r2d->attribute() );
QVERIFY( s->categoriesList() == r2d->categories() );
QVERIFY( s->attribute() == r2D->attribute() );
QVERIFY( s->categoriesList() == r2D->categories() );
}
}
void TestQgsPointCloud3DRendering::testDisableSync3DRendererTo2DRenderer()
{
// gather different 2d renderers
// gather different 2D renderers
QgsPointCloudExtentRenderer *extent2DRenderer = new QgsPointCloudExtentRenderer();
QgsPointCloudAttributeByRampRenderer *colorramp2DRenderer = new QgsPointCloudAttributeByRampRenderer();
colorramp2DRenderer->setAttribute( QStringLiteral( "Z" ) );
@ -218,51 +218,51 @@ void TestQgsPointCloud3DRendering::testDisableSync3DRendererTo2DRenderer()
classification2DRenderer->setCategories( categories );
// enable syncing, the 3d renderer should change when the 2d renderer changes
// enable syncing, the 3D renderer should change when the 2D renderer changes
mLayer->setSync3DRendererTo2DRenderer( true );
{
// for the extent 2d renderer we should have a 3d renderer but no symbol
// for the extent 2D renderer we should have a 3D renderer but no symbol
mLayer->setRenderer( extent2DRenderer );
QgsPointCloudLayer3DRenderer *r3d = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3d );
QVERIFY( !r3d->symbol() );
QgsPointCloudLayer3DRenderer *r3D = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3D );
QVERIFY( !r3D->symbol() );
}
{
mLayer->setRenderer( colorramp2DRenderer );
QgsPointCloudAttributeByRampRenderer *r2d = static_cast<QgsPointCloudAttributeByRampRenderer *>( mLayer->renderer() );
QgsPointCloudLayer3DRenderer *r3d = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3d );
const QgsColorRampPointCloud3DSymbol *s = dynamic_cast<const QgsColorRampPointCloud3DSymbol *>( r3d->symbol() );
QgsPointCloudAttributeByRampRenderer *r2D = static_cast<QgsPointCloudAttributeByRampRenderer *>( mLayer->renderer() );
QgsPointCloudLayer3DRenderer *r3D = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3D );
const QgsColorRampPointCloud3DSymbol *s = dynamic_cast<const QgsColorRampPointCloud3DSymbol *>( r3D->symbol() );
QVERIFY( s );
QVERIFY( s->attribute() == r2d->attribute() );
QVERIFY( s->colorRampShader() == r2d->colorRampShader() );
QVERIFY( s->colorRampShaderMin() == r2d->minimum() );
QVERIFY( s->colorRampShaderMax() == r2d->maximum() );
QVERIFY( s->attribute() == r2D->attribute() );
QVERIFY( s->colorRampShader() == r2D->colorRampShader() );
QVERIFY( s->colorRampShaderMin() == r2D->minimum() );
QVERIFY( s->colorRampShaderMax() == r2D->maximum() );
}
// now disable syncing and check that the 3d renderer symbol does not change
// now disable syncing and check that the 3D renderer symbol does not change
mLayer->setSync3DRendererTo2DRenderer( false );
{
mLayer->setRenderer( colorramp2DRenderer );
QgsPointCloudLayer3DRenderer *r3d = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3d );
const QgsColorRampPointCloud3DSymbol *s = dynamic_cast<const QgsColorRampPointCloud3DSymbol *>( r3d->symbol() );
QgsPointCloudLayer3DRenderer *r3D = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3D );
const QgsColorRampPointCloud3DSymbol *s = dynamic_cast<const QgsColorRampPointCloud3DSymbol *>( r3D ->symbol() );
QVERIFY( s );
}
{
mLayer->setRenderer( rgb2DRenderer );
QgsPointCloudLayer3DRenderer *r3d = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3d );
const QgsColorRampPointCloud3DSymbol *s = dynamic_cast<const QgsColorRampPointCloud3DSymbol *>( r3d->symbol() );
QgsPointCloudLayer3DRenderer *r3D = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3D );
const QgsColorRampPointCloud3DSymbol *s = dynamic_cast<const QgsColorRampPointCloud3DSymbol *>( r3D ->symbol() );
QVERIFY( s );
}
{
mLayer->setRenderer( classification2DRenderer );
QgsPointCloudLayer3DRenderer *r3d = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3d );
const QgsColorRampPointCloud3DSymbol *s = dynamic_cast<const QgsColorRampPointCloud3DSymbol *>( r3d->symbol() );
QgsPointCloudLayer3DRenderer *r3D = static_cast<QgsPointCloudLayer3DRenderer *>( mLayer->renderer3D() );
QVERIFY( r3D );
const QgsColorRampPointCloud3DSymbol *s = dynamic_cast<const QgsColorRampPointCloud3DSymbol *>( r3D ->symbol() );
QVERIFY( s );
}
}
@ -447,7 +447,7 @@ void TestQgsPointCloud3DRendering::testPointCloudSyncedTo2D()
QgsPointCloudLayer3DRenderer *renderer = new QgsPointCloudLayer3DRenderer();
mLayer->setRenderer3D( renderer );
// gather different 2d renderers
// gather different 2D renderers
QgsPointCloudExtentRenderer *extent2DRenderer = new QgsPointCloudExtentRenderer();
QgsPointCloudAttributeByRampRenderer *colorramp2DRenderer = new QgsPointCloudAttributeByRampRenderer();
colorramp2DRenderer->setAttribute( QStringLiteral( "Z" ) );
@ -478,14 +478,14 @@ void TestQgsPointCloud3DRendering::testPointCloudSyncedTo2D()
// find a better fix in the future.
scene->cameraController()->resetView( 2.5 );
// 3D symbols should now automatically change to match the 2d renderer
// 3D symbols should now automatically change to match the 2D renderer
mLayer->setSync3DRendererTo2DRenderer( true );
// default 2d renderer is rgb for this pointcloud
// default 2D renderer is rgb for this pointcloud
QImage img = Qgs3DUtils::captureSceneImage( engine, scene );
QVERIFY( renderCheck( "pointcloud_3d_rgb", img, 40 ) );
// extent renderer should not render anythin in 3d
// extent renderer should not render anythin in 3D
mLayer->setRenderer( extent2DRenderer );
QImage img2 = Qgs3DUtils::captureSceneImage( engine, scene );
QVERIFY( renderCheck( "pointcloud_3d_norenderer", img2, 40 ) );
@ -502,7 +502,7 @@ void TestQgsPointCloud3DRendering::testPointCloudSyncedTo2D()
QImage img5 = Qgs3DUtils::captureSceneImage( engine, scene );
QVERIFY( renderCheck( "pointcloud_3d_classification", img5, 40 ) );
// Now let's stop syncing, 3d symbol should stay at the last one used
// Now let's stop syncing, 3D symbol should stay at the last one used
mLayer->setSync3DRendererTo2DRenderer( false );
mLayer->setRenderer( extent2DRenderer_2 );