QGIS API Documentation 3.41.0-Master (3c143d501a8)
Loading...
Searching...
No Matches
qgsvectortilelayerrenderer.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsvectortilelayerrenderer.cpp
3 --------------------------------------
4 Date : March 2020
5 Copyright : (C) 2020 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
18#include "qgsfeedback.h"
19#include "qgslogger.h"
21#include "qgsvectortilelayer.h"
22#include "qgsvectortileloader.h"
23#include "qgsvectortileutils.h"
24#include "qgslabelingengine.h"
26#include "qgsmapclippingutils.h"
27#include "qgsrendercontext.h"
29#include "qgstextrenderer.h"
30#include "qgsruntimeprofiler.h"
31#include "qgsapplication.h"
32
33#include <QElapsedTimer>
34#include <QThread>
35
37 : QgsMapLayerRenderer( layer->id(), &context )
38 , mLayerName( layer->name() )
39 , mDataProvider( qgis::down_cast< const QgsVectorTileDataProvider* >( layer->dataProvider() )->clone() )
40 , mRenderer( layer->renderer()->clone() )
41 , mLayerBlendMode( layer->blendMode() )
42 , mDrawTileBoundaries( layer->isTileBorderRenderingEnabled() )
43 , mLabelsEnabled( layer->labelsEnabled() )
44 , mFeedback( new QgsFeedback )
45 , mSelectedFeatures( layer->selectedFeatures() )
46 , mLayerOpacity( layer->opacity() )
47 , mTileMatrixSet( layer->tileMatrixSet() )
48 , mEnableProfile( context.flags() & Qgis::RenderContextFlag::RecordProfile )
49{
50 QElapsedTimer timer;
51 timer.start();
52
53 if ( QgsLabelingEngine *engine = context.labelingEngine() )
54 {
55 if ( layer->labelsEnabled() )
56 {
57 mLabelProvider = layer->labeling()->provider( layer );
58 if ( mLabelProvider )
59 {
60 engine->addProvider( mLabelProvider );
61 }
62 }
63 }
64
66
67 mDataProvider->moveToThread( nullptr );
68
69 mPreparationTime = timer.elapsed();
70}
71
73
75{
76 std::unique_ptr< QgsScopedRuntimeProfile > profile;
77 if ( mEnableProfile )
78 {
79 profile = std::make_unique< QgsScopedRuntimeProfile >( mLayerName, QStringLiteral( "rendering" ), layerId() );
80 if ( mPreparationTime > 0 )
81 QgsApplication::profiler()->record( QObject::tr( "Create renderer" ), mPreparationTime / 1000.0, QStringLiteral( "rendering" ) );
82 }
83
85
86 if ( ctx.renderingStopped() )
87 return false;
88
89 std::unique_ptr< QgsScopedRuntimeProfile > preparingProfile;
90 if ( mEnableProfile )
91 {
92 preparingProfile = std::make_unique< QgsScopedRuntimeProfile >( QObject::tr( "Preparing render" ), QStringLiteral( "rendering" ) );
93 }
94
95 mDataProvider->moveToThread( QThread::currentThread() );
96
97 const QgsScopedQPainterState painterState( ctx.painter() );
98
99 if ( !mClippingRegions.empty() )
100 {
101 bool needsPainterClipPath = false;
102 const QPainterPath path = QgsMapClippingUtils::calculatePainterClipRegion( mClippingRegions, *renderContext(), Qgis::LayerType::VectorTile, needsPainterClipPath );
103 if ( needsPainterClipPath )
104 renderContext()->painter()->setClipPath( path, Qt::IntersectClip );
105 }
106
107 QElapsedTimer tTotal;
108 tTotal.start();
109
110 const double tileRenderScale = mTileMatrixSet.scaleForRenderContext( ctx );
111 QgsDebugMsgLevel( QStringLiteral( "Vector tiles rendering extent: " ) + ctx.extent().toString( -1 ), 2 );
112 QgsDebugMsgLevel( QStringLiteral( "Vector tiles map scale 1 : %1" ).arg( tileRenderScale ), 2 );
113
114 mTileZoomToFetch = mTileMatrixSet.scaleToZoomLevel( tileRenderScale );
115 QgsDebugMsgLevel( QStringLiteral( "Vector tiles zoom level: %1" ).arg( mTileZoomToFetch ), 2 );
116 mTileZoomToRender = mTileMatrixSet.scaleToZoomLevel( tileRenderScale, false );
117 QgsDebugMsgLevel( QStringLiteral( "Render zoom level: %1" ).arg( mTileZoomToRender ), 2 );
118
119 mTileMatrix = mTileMatrixSet.tileMatrix( mTileZoomToFetch );
120
121 mTileRange = mTileMatrix.tileRangeFromExtent( ctx.extent() );
122 QgsDebugMsgLevel( QStringLiteral( "Vector tiles range X: %1 - %2 Y: %3 - %4" )
123 .arg( mTileRange.startColumn() ).arg( mTileRange.endColumn() )
124 .arg( mTileRange.startRow() ).arg( mTileRange.endRow() ), 2 );
125
126 // view center is used to sort the order of tiles for fetching and rendering
127 const QPointF viewCenter = mTileMatrix.mapToTileCoordinates( ctx.extent().center() );
128
129 if ( !mTileRange.isValid() )
130 {
131 QgsDebugMsgLevel( QStringLiteral( "Vector tiles - outside of range" ), 2 );
132 return true; // nothing to do
133 }
134
135 preparingProfile.reset();
136 std::unique_ptr< QgsScopedRuntimeProfile > renderingProfile;
137 if ( mEnableProfile )
138 {
139 renderingProfile = std::make_unique< QgsScopedRuntimeProfile >( QObject::tr( "Rendering" ), QStringLiteral( "rendering" ) );
140 }
141
142 std::unique_ptr<QgsVectorTileLoader> asyncLoader;
143 QList<QgsVectorTileRawData> rawTiles;
144 if ( !mDataProvider->supportsAsync() )
145 {
146 QElapsedTimer tFetch;
147 tFetch.start();
148 rawTiles = QgsVectorTileLoader::blockingFetchTileRawData( mDataProvider.get(), mTileMatrixSet, viewCenter, mTileRange, mTileZoomToFetch, mFeedback.get() );
149 QgsDebugMsgLevel( QStringLiteral( "Tile fetching time: %1" ).arg( tFetch.elapsed() / 1000. ), 2 );
150 QgsDebugMsgLevel( QStringLiteral( "Fetched tiles: %1" ).arg( rawTiles.count() ), 2 );
151 }
152 else
153 {
154 asyncLoader.reset( new QgsVectorTileLoader( mDataProvider.get(), mTileMatrixSet, mTileRange, mTileZoomToFetch, viewCenter, mFeedback.get(), renderContext()->rendererUsage() ) );
155 QObject::connect( asyncLoader.get(), &QgsVectorTileLoader::tileRequestFinished, asyncLoader.get(), [this]( const QgsVectorTileRawData & rawTile )
156 {
157 QgsDebugMsgLevel( QStringLiteral( "Got tile asynchronously: " ) + rawTile.id.toString(), 2 );
158 if ( !rawTile.data.isEmpty() )
159 decodeAndDrawTile( rawTile );
160 } );
161 }
162
163 if ( ctx.renderingStopped() )
164 return false;
165
166 // add @zoom_level and @vector_tile_zoom variables which can be used in styling
167 QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Tiles" ) ); // will be deleted by popper
168 scope->setVariable( QStringLiteral( "zoom_level" ), mTileZoomToRender, true );
169 scope->setVariable( QStringLiteral( "vector_tile_zoom" ), mTileMatrixSet.scaleToZoom( tileRenderScale ), true );
170 const QgsExpressionContextScopePopper popper( ctx.expressionContext(), scope );
171
172 mRenderer->startRender( *renderContext(), mTileZoomToRender, mTileRange );
173
174 // Draw background style if present
175 mRenderer->renderBackground( ctx );
176
177 QMap<QString, QSet<QString> > requiredFields = mRenderer->usedAttributes( ctx );
178
179 if ( mLabelProvider )
180 {
181 const QMap<QString, QSet<QString> > requiredFieldsLabeling = mLabelProvider->usedAttributes( ctx, mTileZoomToRender );
182 for ( auto it = requiredFieldsLabeling.begin(); it != requiredFieldsLabeling.end(); ++it )
183 {
184 requiredFields[it.key()].unite( it.value() );
185 }
186 }
187
188 for ( auto it = requiredFields.constBegin(); it != requiredFields.constEnd(); ++it )
189 mPerLayerFields[it.key()] = QgsVectorTileUtils::makeQgisFields( it.value() );
190
191 mRequiredLayers = mRenderer->requiredLayers( ctx, mTileZoomToRender );
192
193 if ( mLabelProvider )
194 {
195 mLabelProvider->setFields( mPerLayerFields );
196 QSet<QString> attributeNames; // we don't need this - already got referenced columns in provider constructor
197 if ( !mLabelProvider->prepare( ctx, attributeNames ) )
198 {
199 ctx.labelingEngine()->removeProvider( mLabelProvider );
200 mLabelProvider = nullptr; // provider is deleted by the engine
201 }
202 else
203 {
204 mRequiredLayers.unite( mLabelProvider->requiredLayers( ctx, mTileZoomToRender ) );
205 }
206 }
207
208 if ( !mDataProvider->supportsAsync() )
209 {
210 for ( const QgsVectorTileRawData &rawTile : std::as_const( rawTiles ) )
211 {
212 if ( ctx.renderingStopped() )
213 break;
214
215 decodeAndDrawTile( rawTile );
216 }
217 }
218 else
219 {
220 // Block until tiles are fetched and rendered. If the rendering gets canceled at some point,
221 // the async loader will catch the signal, abort requests and return from downloadBlocking()
222 asyncLoader->downloadBlocking();
223 if ( !asyncLoader->error().isEmpty() )
224 mErrors.append( asyncLoader->error() );
225 }
226
228 mRenderer->renderSelectedFeatures( mSelectedFeatures, ctx );
229
230 mRenderer->stopRender( ctx );
231
232 QgsDebugMsgLevel( QStringLiteral( "Total time for decoding: %1" ).arg( mTotalDecodeTime / 1000. ), 2 );
233 QgsDebugMsgLevel( QStringLiteral( "Drawing time: %1" ).arg( mTotalDrawTime / 1000. ), 2 );
234 QgsDebugMsgLevel( QStringLiteral( "Total time: %1" ).arg( tTotal.elapsed() / 1000. ), 2 );
235
236 return !ctx.renderingStopped();
237}
238
240{
242 return false;
243
244 if ( !qgsDoubleNear( mLayerOpacity, 1.0 ) )
245 return true;
246
247 if ( mLayerBlendMode != QPainter::CompositionMode_SourceOver )
248 return true;
249
250 return false;
251}
252
253void QgsVectorTileLayerRenderer::decodeAndDrawTile( const QgsVectorTileRawData &rawTile )
254{
256
257 QgsDebugMsgLevel( QStringLiteral( "Drawing tile " ) + rawTile.id.toString(), 2 );
258
259 QElapsedTimer tLoad;
260 tLoad.start();
261
262 // currently only MVT encoding supported
263 QgsVectorTileMVTDecoder decoder( mTileMatrixSet );
264 if ( !decoder.decode( rawTile ) )
265 {
266 QgsDebugMsgLevel( QStringLiteral( "Failed to parse raw tile data! " ) + rawTile.id.toString(), 2 );
267 return;
268 }
269
270 if ( ctx.renderingStopped() )
271 return;
272
274
275 QgsVectorTileRendererData tile( rawTile.id );
276 tile.setRenderZoomLevel( mTileZoomToRender );
277
278 tile.setFields( mPerLayerFields );
279 tile.setFeatures( decoder.layerFeatures( mPerLayerFields, ct, &mRequiredLayers ) );
280
281 try
282 {
283 tile.setTilePolygon( QgsVectorTileUtils::tilePolygon( rawTile.id, ct, mTileMatrixSet.tileMatrix( rawTile.id.zoomLevel() ), ctx.mapToPixel() ) );
284 }
285 catch ( QgsCsException & )
286 {
287 QgsDebugMsgLevel( QStringLiteral( "Failed to generate tile polygon " ) + rawTile.id.toString(), 2 );
288 return;
289 }
290
291 mTotalDecodeTime += tLoad.elapsed();
292
293 // calculate tile polygon in screen coordinates
294
295 if ( ctx.renderingStopped() )
296 return;
297
298 {
299 // set up clipping so that rendering does not go behind tile's extent
300 const QgsScopedQPainterState savePainterState( ctx.painter() );
301 // we have to intersect with any existing painter clip regions, or we risk overwriting valid clip
302 // regions setup outside of the vector tile renderer (e.g. layout map clip region)
303 ctx.painter()->setClipRegion( QRegion( tile.tilePolygon() ), Qt::IntersectClip );
304
305 QElapsedTimer tDraw;
306 tDraw.start();
307
308 mRenderer->renderTile( tile, ctx );
309 mTotalDrawTime += tDraw.elapsed();
310 }
311
312 if ( mLabelProvider )
313 mLabelProvider->registerTileFeatures( tile, ctx );
314
315 if ( mDrawTileBoundaries )
316 {
317 const QgsScopedQPainterState savePainterState( ctx.painter() );
318 ctx.painter()->setClipping( false );
319
320 QPen pen( Qt::red );
321 pen.setWidth( 3 );
322 QBrush brush( QColor( 255, 0, 0, 40 ), Qt::BrushStyle::Dense3Pattern );
323
324 ctx.painter()->setPen( pen );
325 ctx.painter()->setBrush( brush );
326 ctx.painter()->drawPolygon( tile.tilePolygon() );
327#if 1
328 QgsTextFormat format;
329 format.setColor( QColor( 255, 0, 0 ) );
330 format.buffer().setEnabled( true );
331
332 QgsTextRenderer::drawText( QRectF( QPoint( 0, 0 ), ctx.outputSize() ).intersected( tile.tilePolygon().boundingRect() ),
333 0, Qgis::TextHorizontalAlignment::Center, { tile.id().toString() },
335#endif
336 }
337}
The Qgis class provides global constants for use throughout the application.
Definition qgis.h:54
@ VectorTile
Vector tile layer. Added in QGIS 3.14.
@ DrawSelection
Whether vector selections should be shown in the rendered map.
@ UseAdvancedEffects
Enable layer opacity and blending effects.
@ VerticalCenter
Center align.
static QgsRuntimeProfiler * profiler()
Returns the application runtime profiler.
Class for doing transforms between two map coordinate systems.
Custom exception class for Coordinate Reference System related exceptions.
RAII class to pop scope from an expression context on destruction.
Single scope for storing variables and functions for use within a QgsExpressionContext.
void setVariable(const QString &name, const QVariant &value, bool isStatic=false)
Convenience method for setting a variable in the context scope by name name and value.
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition qgsfeedback.h:44
The QgsLabelingEngine class provides map labeling functionality.
void removeProvider(QgsAbstractLabelProvider *provider)
Remove provider if the provider's initialization failed. Provider instance is deleted.
static QPainterPath calculatePainterClipRegion(const QList< QgsMapClippingRegion > &regions, const QgsRenderContext &context, Qgis::LayerType layerType, bool &shouldClip)
Returns a QPainterPath representing the intersection of clipping regions from context which should be...
static QList< QgsMapClippingRegion > collectClippingRegionsForLayer(const QgsRenderContext &context, const QgsMapLayer *layer)
Collects the list of map clipping regions from a context which apply to a map layer.
Base class for utility classes that encapsulate information necessary for rendering of map layers.
QString layerId() const
Gets access to the ID of the layer rendered by this class.
QgsRenderContext * renderContext()
Returns the render context associated with the renderer.
Q_INVOKABLE QString toString(int precision=16) const
Returns a string representation of form xmin,ymin : xmax,ymax Coordinates will be truncated to the sp...
QgsPointXY center
Contains information about the context of a rendering operation.
QPainter * painter()
Returns the destination QPainter for the render operation.
QgsExpressionContext & expressionContext()
Gets the expression context.
QSize outputSize() const
Returns the size of the resulting rendered image, in pixels.
const QgsRectangle & extent() const
When rendering a map layer, calling this method returns the "clipping" extent for the layer (in the l...
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
bool renderingStopped() const
Returns true if the rendering operation has been stopped and any ongoing rendering should be canceled...
QgsLabelingEngine * labelingEngine() const
Gets access to new labeling engine (may be nullptr).
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context.
Qgis::RenderContextFlags flags() const
Returns combination of flags used for rendering.
void record(const QString &name, double time, const QString &group="startup", const QString &id=QString())
Manually adds a profile event with the given name and total time (in seconds).
Scoped object for saving and restoring a QPainter object's state.
void setEnabled(bool enabled)
Sets whether the text buffer will be drawn.
Container for all settings relating to text rendering.
void setColor(const QColor &color)
Sets the color that text will be rendered in.
QgsTextBufferSettings & buffer()
Returns a reference to the text buffer settings.
static void drawText(const QRectF &rect, double rotation, Qgis::TextHorizontalAlignment alignment, const QStringList &textLines, QgsRenderContext &context, const QgsTextFormat &format, bool drawAsOutlines=true, Qgis::TextVerticalAlignment vAlignment=Qgis::TextVerticalAlignment::Top, Qgis::TextRendererFlags flags=Qgis::TextRendererFlags(), Qgis::TextLayoutMode mode=Qgis::TextLayoutMode::Rectangle)
Draws text within a rectangle using the specified settings.
double scaleForRenderContext(const QgsRenderContext &context) const
Calculates the correct scale to use for the tiles when rendered using the specified render context.
Definition qgstiles.cpp:299
double scaleToZoom(double scale) const
Calculates a fractional zoom level given a map scale denominator.
Definition qgstiles.cpp:226
QgsTileMatrix tileMatrix(int zoom) const
Returns the tile matrix corresponding to the specified zoom.
Definition qgstiles.cpp:156
int scaleToZoomLevel(double scale, bool clamp=true) const
Finds the best fitting (integer) zoom level given a map scale denominator.
Definition qgstiles.cpp:283
QPointF mapToTileCoordinates(const QgsPointXY &mapPoint) const
Returns row/column coordinates (floating point number) from the given point in map coordinates.
Definition qgstiles.cpp:121
QgsTileRange tileRangeFromExtent(const QgsRectangle &mExtent) const
Returns tile range that fully covers the given extent.
Definition qgstiles.cpp:97
int endColumn() const
Returns index of the last column in the range.
Definition qgstiles.h:111
int endRow() const
Returns index of the last row in the range.
Definition qgstiles.h:115
int startRow() const
Returns index of the first row in the range.
Definition qgstiles.h:113
int startColumn() const
Returns index of the first column in the range.
Definition qgstiles.h:109
bool isValid() const
Returns whether the range is valid (when all row/column numbers are not negative)
Definition qgstiles.h:106
QString toString() const
Returns tile coordinates in a formatted string.
Definition qgstiles.h:56
int zoomLevel() const
Returns tile's zoom level (Z)
Definition qgstiles.h:53
virtual bool prepare(QgsRenderContext &context, QSet< QString > &attributeNames)
Prepare for registration of features.
Base class for vector tile layer data providers.
virtual QMap< QString, QSet< QString > > usedAttributes(const QgsRenderContext &context, int tileZoom) const =0
Returns field names for each sub-layer that are required for labeling.
virtual void setFields(const QMap< QString, QgsFields > &perLayerFields)=0
Sets fields for each sub-layer.
virtual QSet< QString > requiredLayers(QgsRenderContext &context, int tileZoom) const
Returns a list of the layers required for labeling.
virtual void registerTileFeatures(const QgsVectorTileRendererData &tile, QgsRenderContext &context)=0
Registers label features for given tile to the labeling engine.
virtual QgsVectorTileLabelProvider * provider(QgsVectorTileLayer *layer) const SIP_SKIP
Factory for label provider implementation.
bool forceRasterRender() const override
Returns true if the renderer must be rendered to a raster paint device (e.g.
~QgsVectorTileLayerRenderer() override
QgsVectorTileLayerRenderer(QgsVectorTileLayer *layer, QgsRenderContext &context)
Creates the renderer. Always called from main thread, should copy whatever necessary from the layer.
virtual bool render() override
Do the rendering (based on data stored in the class).
Implements a map layer that is dedicated to rendering of vector tiles.
bool labelsEnabled() const
Returns whether the layer contains labels which are enabled and should be drawn.
QgsVectorTileLabeling * labeling() const
Returns currently assigned labeling.
The loader class takes care of loading raw vector tile data from a tile source.
void tileRequestFinished(const QgsVectorTileRawData &rawTile)
Emitted when a tile request has finished. If a tile request has failed, the returned raw tile byte ar...
static QList< QgsVectorTileRawData > blockingFetchTileRawData(const QgsVectorTileDataProvider *provider, const QgsTileMatrixSet &tileMatrixSet, const QPointF &viewCenter, const QgsTileRange &range, int zoomLevel, QgsFeedback *feedback=nullptr, Qgis::RendererUsage usage=Qgis::RendererUsage::Unknown)
Returns raw tile data for the specified range of tiles. Blocks the caller until all tiles are fetched...
This class is responsible for decoding raw tile data written with Mapbox Vector Tiles encoding.
Keeps track of raw tile data from one or more sources that need to be decoded.
QgsTileXYZ id
Tile position in tile matrix set.
Contains decoded features of a single vector tile and any other data necessary for rendering of it.
static QPolygon tilePolygon(QgsTileXYZ id, const QgsCoordinateTransform &ct, const QgsTileMatrix &tm, const QgsMapToPixel &mtp)
Returns polygon (made by four corners of the tile) in screen coordinates.
static QgsFields makeQgisFields(const QSet< QString > &flds)
Returns QgsFields instance based on the set of field names.
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition qgis.h:6024
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:39