QGIS API Documentation 3.41.0-Master (3440c17df1d)
Loading...
Searching...
No Matches
qgsvectorlayerchunkloader_p.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsvectorlayerchunkloader_p.cpp
3 --------------------------------------
4 Date : July 2019
5 Copyright : (C) 2019 by Martin Dobias
6 Email : wonder dot sk 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#include "moc_qgsvectorlayerchunkloader_p.cpp"
18#include "qgs3dutils.h"
19#include "qgsline3dsymbol.h"
20#include "qgspoint3dsymbol.h"
21#include "qgspolygon3dsymbol.h"
25#include "qgschunknode.h"
26#include "qgseventtracing.h"
27#include "qgslogger.h"
28#include "qgsvectorlayer.h"
30#include "qgsapplication.h"
31#include "qgs3dsymbolregistry.h"
32#include "qgsabstract3dsymbol.h"
33
34#include <QtConcurrent>
35#include <Qt3DCore/QTransform>
36
38
39
40QgsVectorLayerChunkLoader::QgsVectorLayerChunkLoader( const QgsVectorLayerChunkLoaderFactory *factory, QgsChunkNode *node )
41 : QgsChunkLoader( node )
42 , mFactory( factory )
43 , mRenderContext( factory->mRenderContext )
44 , mSource( new QgsVectorLayerFeatureSource( factory->mLayer ) )
45{
46 if ( node->level() < mFactory->mLeafLevel )
47 {
48 QTimer::singleShot( 0, this, &QgsVectorLayerChunkLoader::finished );
49 return;
50 }
51
52 QgsVectorLayer *layer = mFactory->mLayer;
53 mLayerName = mFactory->mLayer->name();
54
55 QgsFeature3DHandler *handler = QgsApplication::symbol3DRegistry()->createHandlerForSymbol( layer, mFactory->mSymbol.get() );
56 if ( !handler )
57 {
58 QgsDebugError( QStringLiteral( "Unknown 3D symbol type for vector layer: " ) + mFactory->mSymbol->type() );
59 return;
60 }
61 mHandler.reset( handler );
62
63 // only a subset of data to be queried
64 const QgsRectangle rect = node->box3D().toRectangle();
65 // origin for coordinates of the chunk - it is kind of arbitrary, but it should be
66 // picked so that the coordinates are relatively small to avoid numerical precision issues
67 QgsVector3D chunkOrigin( rect.center().x(), rect.center().y(), 0 );
68
70 exprContext.setFields( layer->fields() );
71 mRenderContext.setExpressionContext( exprContext );
72
73 QSet<QString> attributeNames;
74 if ( !mHandler->prepare( mRenderContext, attributeNames, chunkOrigin ) )
75 {
76 QgsDebugError( QStringLiteral( "Failed to prepare 3D feature handler!" ) );
77 return;
78 }
79
80 // build the feature request
83 QgsCoordinateTransform( layer->crs3D(), mRenderContext.crs(), mRenderContext.transformContext() )
84 );
85 req.setSubsetOfAttributes( attributeNames, layer->fields() );
86 req.setFilterRect( rect );
87
88 //
89 // this will be run in a background thread
90 //
91 mFutureWatcher = new QFutureWatcher<void>( this );
92 connect( mFutureWatcher, &QFutureWatcher<void>::finished, this, &QgsChunkQueueJob::finished );
93
94 const QFuture<void> future = QtConcurrent::run( [req, this]
95 {
96 const QgsEventTracing::ScopedEvent e( QStringLiteral( "3D" ), QStringLiteral( "VL chunk load" ) );
97
98 QgsFeature f;
99 QgsFeatureIterator fi = mSource->getFeatures( req );
100 while ( fi.nextFeature( f ) )
101 {
102 if ( mCanceled )
103 break;
104 mRenderContext.expressionContext().setFeature( f );
105 mHandler->processFeature( f, mRenderContext );
106 }
107 } );
108
109 // emit finished() as soon as the handler is populated with features
110 mFutureWatcher->setFuture( future );
111}
112
113QgsVectorLayerChunkLoader::~QgsVectorLayerChunkLoader()
114{
115 if ( mFutureWatcher && !mFutureWatcher->isFinished() )
116 {
117 disconnect( mFutureWatcher, &QFutureWatcher<void>::finished, this, &QgsChunkQueueJob::finished );
118 mFutureWatcher->waitForFinished();
119 }
120}
121
122void QgsVectorLayerChunkLoader::cancel()
123{
124 mCanceled = true;
125}
126
127Qt3DCore::QEntity *QgsVectorLayerChunkLoader::createEntity( Qt3DCore::QEntity *parent )
128{
129 if ( mNode->level() < mFactory->mLeafLevel )
130 {
131 Qt3DCore::QEntity *entity = new Qt3DCore::QEntity( parent ); // dummy entity
132 entity->setObjectName( mLayerName + "_CONTAINER_" + mNode->tileId().text() );
133 return entity;
134 }
135
136 if ( mHandler->featureCount() == 0 )
137 {
138 // an empty node, so we return no entity. This tags the node as having no data and effectively removes it.
139 // we just make sure first that its initial estimated vertical range does not affect its parents' bboxes calculation
140 mNode->setExactBox3D( QgsBox3D() );
141 mNode->updateParentBoundingBoxesRecursively();
142 return nullptr;
143 }
144
145 Qt3DCore::QEntity *entity = new Qt3DCore::QEntity( parent );
146 entity->setObjectName( mLayerName + "_" + mNode->tileId().text() );
147 mHandler->finalize( entity, mRenderContext );
148
149 // fix the vertical range of the node from the estimated vertical range to the true range
150 if ( mHandler->zMinimum() != std::numeric_limits<float>::max() && mHandler->zMaximum() != std::numeric_limits<float>::lowest() )
151 {
152 QgsBox3D box = mNode->box3D();
153 box.setZMinimum( mHandler->zMinimum() );
154 box.setZMaximum( mHandler->zMaximum() );
155 mNode->setExactBox3D( box );
156 mNode->updateParentBoundingBoxesRecursively();
157 }
158
159 return entity;
160}
161
162
164
165
166QgsVectorLayerChunkLoaderFactory::QgsVectorLayerChunkLoaderFactory( const Qgs3DRenderContext &context, QgsVectorLayer *vl, QgsAbstract3DSymbol *symbol, int leafLevel, double zMin, double zMax )
167 : mRenderContext( context )
168 , mLayer( vl )
169 , mSymbol( symbol->clone() )
170 , mLeafLevel( leafLevel )
171{
172 QgsBox3D rootBox3D( context.extent(), zMin, zMax );
173 // add small padding to avoid clipping of point features located at the edge of the bounding box
174 rootBox3D.grow( 1.0 );
175 setupQuadtree( rootBox3D, -1, leafLevel ); // negative root error means that the node does not contain anything
176}
177
178QgsChunkLoader *QgsVectorLayerChunkLoaderFactory::createChunkLoader( QgsChunkNode *node ) const
179{
180 return new QgsVectorLayerChunkLoader( this, node );
181}
182
183
185
186
187QgsVectorLayerChunkedEntity::QgsVectorLayerChunkedEntity( Qgs3DMapSettings *map, QgsVectorLayer *vl, double zMin, double zMax, const QgsVectorLayer3DTilingSettings &tilingSettings, QgsAbstract3DSymbol *symbol )
188 : QgsChunkedEntity( map,
189 -1, // max. allowed screen error (negative tau means that we need to go until leaves are reached)
190 new QgsVectorLayerChunkLoaderFactory( Qgs3DRenderContext::fromMapSettings( map ), vl, symbol, tilingSettings.zoomLevelsCount() - 1, zMin, zMax ), true )
191{
192 mTransform = new Qt3DCore::QTransform;
193 if ( applyTerrainOffset() )
194 {
195 mTransform->setTranslation( QVector3D( 0.0f, map->terrainElevationOffset(), 0.0f ) );
196 }
197 this->addComponent( mTransform );
198
199 connect( map, &Qgs3DMapSettings::terrainElevationOffsetChanged, this, &QgsVectorLayerChunkedEntity::onTerrainElevationOffsetChanged );
200
201 setShowBoundingBoxes( tilingSettings.showBoundingBoxes() );
202}
203
204QgsVectorLayerChunkedEntity::~QgsVectorLayerChunkedEntity()
205{
206 // cancel / wait for jobs
207 cancelActiveJobs();
208}
209
210// if the AltitudeClamping is `Absolute`, do not apply the offset
211bool QgsVectorLayerChunkedEntity::applyTerrainOffset() const
212{
213 QgsVectorLayerChunkLoaderFactory *loaderFactory = static_cast<QgsVectorLayerChunkLoaderFactory *>( mChunkLoaderFactory );
214 if ( loaderFactory )
215 {
216 QString symbolType = loaderFactory->mSymbol.get()->type();
217 if ( symbolType == "line" )
218 {
219 QgsLine3DSymbol *lineSymbol = static_cast<QgsLine3DSymbol *>( loaderFactory->mSymbol.get() );
220 if ( lineSymbol && lineSymbol->altitudeClamping() == Qgis::AltitudeClamping::Absolute )
221 {
222 return false;
223 }
224 }
225 else if ( symbolType == "point" )
226 {
227 QgsPoint3DSymbol *pointSymbol = static_cast<QgsPoint3DSymbol *>( loaderFactory->mSymbol.get() );
228 if ( pointSymbol && pointSymbol->altitudeClamping() == Qgis::AltitudeClamping::Absolute )
229 {
230 return false;
231 }
232 }
233 else if ( symbolType == "polygon" )
234 {
235 QgsPolygon3DSymbol *polygonSymbol = static_cast<QgsPolygon3DSymbol *>( loaderFactory->mSymbol.get() );
236 if ( polygonSymbol && polygonSymbol->altitudeClamping() == Qgis::AltitudeClamping::Absolute )
237 {
238 return false;
239 }
240 }
241 else
242 {
243 QgsDebugMsgLevel( QStringLiteral( "QgsVectorLayerChunkedEntity::applyTerrainOffset, unhandled symbol type %1" ).arg( symbolType ), 2 );
244 }
245 }
246
247 return true;
248}
249
250void QgsVectorLayerChunkedEntity::onTerrainElevationOffsetChanged( float newOffset )
251{
252 QgsDebugMsgLevel( QStringLiteral( "QgsVectorLayerChunkedEntity::onTerrainElevationOffsetChanged" ), 2 );
253 if ( !applyTerrainOffset() )
254 {
255 newOffset = 0.0;
256 }
257 mTransform->setTranslation( QVector3D( 0.0f, newOffset, 0.0f ) );
258}
259
260QVector<QgsRayCastingUtils::RayHit> QgsVectorLayerChunkedEntity::rayIntersection( const QgsRayCastingUtils::Ray3D &ray, const QgsRayCastingUtils::RayCastContext &context ) const
261{
262 return QgsVectorLayerChunkedEntity::rayIntersection( activeNodes(), mTransform->matrix(), ray, context, mMapSettings->origin() );
263}
264
265QVector<QgsRayCastingUtils::RayHit> QgsVectorLayerChunkedEntity::rayIntersection( const QList<QgsChunkNode *> &activeNodes, const QMatrix4x4 &transformMatrix, const QgsRayCastingUtils::Ray3D &ray, const QgsRayCastingUtils::RayCastContext &context, const QgsVector3D &origin )
266{
267 Q_UNUSED( context )
268 QgsDebugMsgLevel( QStringLiteral( "Ray cast on vector layer" ), 2 );
269#ifdef QGISDEBUG
270 int nodeUsed = 0;
271 int nodesAll = 0;
272 int hits = 0;
273 int ignoredGeometries = 0;
274#endif
275 QVector<QgsRayCastingUtils::RayHit> result;
276
277 float minDist = -1;
278 QVector3D intersectionPoint;
279 QgsFeatureId nearestFid = FID_NULL;
280
281 for ( QgsChunkNode *node : activeNodes )
282 {
283#ifdef QGISDEBUG
284 nodesAll++;
285#endif
286
287 QgsAABB nodeBbox = Qgs3DUtils::mapToWorldExtent( node->box3D(), origin );
288
289 if ( node->entity() &&
290 ( minDist < 0 || nodeBbox.distanceFromPoint( ray.origin() ) < minDist ) &&
291 QgsRayCastingUtils::rayBoxIntersection( ray, nodeBbox ) )
292 {
293#ifdef QGISDEBUG
294 nodeUsed++;
295#endif
296 const QList<Qt3DRender::QGeometryRenderer *> rendLst = node->entity()->findChildren<Qt3DRender::QGeometryRenderer *>();
297 for ( const auto &rend : rendLst )
298 {
299 auto *geom = rend->geometry();
300 QgsTessellatedPolygonGeometry *polygonGeom = qobject_cast<QgsTessellatedPolygonGeometry *>( geom );
301 if ( !polygonGeom )
302 {
303#ifdef QGISDEBUG
304 ignoredGeometries++;
305#endif
306 continue; // other QGeometry types are not supported for now
307 }
308
309 QVector3D nodeIntPoint;
310 int triangleIndex = -1;
311
312 if ( QgsRayCastingUtils::rayMeshIntersection( rend, ray, transformMatrix, nodeIntPoint, triangleIndex ) )
313 {
314#ifdef QGISDEBUG
315 hits++;
316#endif
317 float dist = ( ray.origin() - nodeIntPoint ).length();
318 if ( minDist < 0 || dist < minDist )
319 {
320 minDist = dist;
321 intersectionPoint = nodeIntPoint;
322 nearestFid = polygonGeom->triangleIndexToFeatureId( triangleIndex );
323 }
324 }
325 }
326 }
327 }
328 if ( !FID_IS_NULL( nearestFid ) )
329 {
330 QgsRayCastingUtils::RayHit hit( minDist, intersectionPoint, nearestFid );
331 result.append( hit );
332 }
333 QgsDebugMsgLevel( QStringLiteral( "Active Nodes: %1, checked nodes: %2, hits found: %3, incompatible geometries: %4" ).arg( nodesAll ).arg( nodeUsed ).arg( hits ).arg( ignoredGeometries ), 2 );
334 return result;
335}
336
@ Absolute
Elevation is taken directly from feature and is independent of terrain height (final elevation = feat...
float terrainElevationOffset() const
Returns the elevation offset of the terrain (used to move the terrain up or down)
void terrainElevationOffsetChanged(float newElevation)
Emitted when the terrain elevation offset is changed.
QgsRectangle extent() const
Returns the 3D scene's 2D extent in the 3D scene's CRS.
QgsFeature3DHandler * createHandlerForSymbol(QgsVectorLayer *layer, const QgsAbstract3DSymbol *symbol)
Creates a feature handler for a symbol, for the specified vector layer.
static QgsAABB mapToWorldExtent(const QgsRectangle &extent, double zMin, double zMax, const QgsVector3D &mapOrigin)
Converts map extent to axis aligned bounding box in 3D world coordinates.
static QgsExpressionContext globalProjectLayerExpressionContext(QgsVectorLayer *layer)
Returns expression context for use in preparation of 3D data of a layer.
float distanceFromPoint(float x, float y, float z) const
Returns shortest distance from the box to a point.
Definition qgsaabb.cpp:50
static Qgs3DSymbolRegistry * symbol3DRegistry()
Returns registry of available 3D symbols.
A 3-dimensional box composed of x, y, z coordinates.
Definition qgsbox3d.h:43
void setZMinimum(double z)
Sets the minimum z value.
Definition qgsbox3d.cpp:88
void setZMaximum(double z)
Sets the maximum z value.
Definition qgsbox3d.cpp:93
Class for doing transforms between two map coordinate systems.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
This class wraps a request for features to a vector layer (or directly its vector data provider).
QgsFeatureRequest & setCoordinateTransform(const QgsCoordinateTransform &transform)
Sets the coordinate transform which will be used to transform the feature's geometries.
QgsFeatureRequest & setSubsetOfAttributes(const QgsAttributeList &attrs)
Set a subset of attributes that will be fetched.
QgsFeatureRequest & setFilterRect(const QgsRectangle &rectangle)
Sets the rectangle from which features will be taken.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:58
Qgis::AltitudeClamping altitudeClamping() const
Returns method that determines altitude (whether to clamp to feature to terrain)
QString name
Definition qgsmaplayer.h:80
QgsCoordinateReferenceSystem crs3D
Definition qgsmaplayer.h:85
Qgis::AltitudeClamping altitudeClamping() const
Returns method that determines altitude (whether to clamp to feature to terrain)
double y
Definition qgspointxy.h:64
double x
Definition qgspointxy.h:63
Qgis::AltitudeClamping altitudeClamping() const
Returns method that determines altitude (whether to clamp to feature to terrain)
A rectangle specified with double values.
QgsPointXY center
QgsFeatureId triangleIndexToFeatureId(uint triangleIndex) const
Returns ID of the feature to which given triangle index belongs (used for picking).
Class for storage of 3D vectors similar to QVector3D, with the difference that it uses double precisi...
Definition qgsvector3d.h:31
bool showBoundingBoxes() const
Returns whether to display bounding boxes of entity's tiles (for debugging)
Partial snapshot of vector layer's state (only the members necessary for access to features)
Represents a vector layer which manages a vector based data sets.
#define FID_NULL
#define FID_IS_NULL(fid)
qint64 QgsFeatureId
64 bit feature ids negative numbers are used for uncommitted/newly added features
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:39
#define QgsDebugError(str)
Definition qgslogger.h:38
Helper struct to store ray casting parameters.
Helper struct to store ray casting results.