QGIS API Documentation 3.37.0-Master (614ebf5f6b2)
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 , mDrawTileBoundaries( layer->isTileBorderRenderingEnabled() )
42 , mLabelsEnabled( layer->labelsEnabled() )
43 , mFeedback( new QgsFeedback )
44 , mSelectedFeatures( layer->selectedFeatures() )
45 , mLayerOpacity( layer->opacity() )
46 , mTileMatrixSet( layer->tileMatrixSet() )
47 , mEnableProfile( context.flags() & Qgis::RenderContextFlag::RecordProfile )
48{
49 QElapsedTimer timer;
50 timer.start();
51
52 if ( QgsLabelingEngine *engine = context.labelingEngine() )
53 {
54 if ( layer->labelsEnabled() )
55 {
56 mLabelProvider = layer->labeling()->provider( layer );
57 if ( mLabelProvider )
58 {
59 engine->addProvider( mLabelProvider );
60 }
61 }
62 }
63
65
66 mDataProvider->moveToThread( nullptr );
67
68 mPreparationTime = timer.elapsed();
69}
70
72
74{
75 std::unique_ptr< QgsScopedRuntimeProfile > profile;
76 if ( mEnableProfile )
77 {
78 profile = std::make_unique< QgsScopedRuntimeProfile >( mLayerName, QStringLiteral( "rendering" ), layerId() );
79 if ( mPreparationTime > 0 )
80 QgsApplication::profiler()->record( QObject::tr( "Create renderer" ), mPreparationTime / 1000.0, QStringLiteral( "rendering" ) );
81 }
82
84
85 if ( ctx.renderingStopped() )
86 return false;
87
88 std::unique_ptr< QgsScopedRuntimeProfile > preparingProfile;
89 if ( mEnableProfile )
90 {
91 preparingProfile = std::make_unique< QgsScopedRuntimeProfile >( QObject::tr( "Preparing render" ), QStringLiteral( "rendering" ) );
92 }
93
94 mDataProvider->moveToThread( QThread::currentThread() );
95
96 const QgsScopedQPainterState painterState( ctx.painter() );
97
98 if ( !mClippingRegions.empty() )
99 {
100 bool needsPainterClipPath = false;
101 const QPainterPath path = QgsMapClippingUtils::calculatePainterClipRegion( mClippingRegions, *renderContext(), Qgis::LayerType::VectorTile, needsPainterClipPath );
102 if ( needsPainterClipPath )
103 renderContext()->painter()->setClipPath( path, Qt::IntersectClip );
104 }
105
106 QElapsedTimer tTotal;
107 tTotal.start();
108
109 const double tileRenderScale = mTileMatrixSet.scaleForRenderContext( ctx );
110 QgsDebugMsgLevel( QStringLiteral( "Vector tiles rendering extent: " ) + ctx.extent().toString( -1 ), 2 );
111 QgsDebugMsgLevel( QStringLiteral( "Vector tiles map scale 1 : %1" ).arg( tileRenderScale ), 2 );
112
113 mTileZoomToFetch = mTileMatrixSet.scaleToZoomLevel( tileRenderScale );
114 QgsDebugMsgLevel( QStringLiteral( "Vector tiles zoom level: %1" ).arg( mTileZoomToFetch ), 2 );
115 mTileZoomToRender = mTileMatrixSet.scaleToZoomLevel( tileRenderScale, false );
116 QgsDebugMsgLevel( QStringLiteral( "Render zoom level: %1" ).arg( mTileZoomToRender ), 2 );
117
118 mTileMatrix = mTileMatrixSet.tileMatrix( mTileZoomToFetch );
119
120 mTileRange = mTileMatrix.tileRangeFromExtent( ctx.extent() );
121 QgsDebugMsgLevel( QStringLiteral( "Vector tiles range X: %1 - %2 Y: %3 - %4" )
122 .arg( mTileRange.startColumn() ).arg( mTileRange.endColumn() )
123 .arg( mTileRange.startRow() ).arg( mTileRange.endRow() ), 2 );
124
125 // view center is used to sort the order of tiles for fetching and rendering
126 const QPointF viewCenter = mTileMatrix.mapToTileCoordinates( ctx.extent().center() );
127
128 if ( !mTileRange.isValid() )
129 {
130 QgsDebugMsgLevel( QStringLiteral( "Vector tiles - outside of range" ), 2 );
131 return true; // nothing to do
132 }
133
134 preparingProfile.reset();
135 std::unique_ptr< QgsScopedRuntimeProfile > renderingProfile;
136 if ( mEnableProfile )
137 {
138 renderingProfile = std::make_unique< QgsScopedRuntimeProfile >( QObject::tr( "Rendering" ), QStringLiteral( "rendering" ) );
139 }
140
141 std::unique_ptr<QgsVectorTileLoader> asyncLoader;
142 QList<QgsVectorTileRawData> rawTiles;
143 if ( !mDataProvider->supportsAsync() )
144 {
145 QElapsedTimer tFetch;
146 tFetch.start();
147 rawTiles = QgsVectorTileLoader::blockingFetchTileRawData( mDataProvider.get(), mTileMatrixSet, viewCenter, mTileRange, mTileZoomToFetch, mFeedback.get() );
148 QgsDebugMsgLevel( QStringLiteral( "Tile fetching time: %1" ).arg( tFetch.elapsed() / 1000. ), 2 );
149 QgsDebugMsgLevel( QStringLiteral( "Fetched tiles: %1" ).arg( rawTiles.count() ), 2 );
150 }
151 else
152 {
153 asyncLoader.reset( new QgsVectorTileLoader( mDataProvider.get(), mTileMatrixSet, mTileRange, mTileZoomToFetch, viewCenter, mFeedback.get(), renderContext()->rendererUsage() ) );
154 QObject::connect( asyncLoader.get(), &QgsVectorTileLoader::tileRequestFinished, asyncLoader.get(), [this]( const QgsVectorTileRawData & rawTile )
155 {
156 QgsDebugMsgLevel( QStringLiteral( "Got tile asynchronously: " ) + rawTile.id.toString(), 2 );
157 if ( !rawTile.data.isEmpty() )
158 decodeAndDrawTile( rawTile );
159 } );
160 }
161
162 if ( ctx.renderingStopped() )
163 return false;
164
165 // add @zoom_level and @vector_tile_zoom variables which can be used in styling
166 QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Tiles" ) ); // will be deleted by popper
167 scope->setVariable( QStringLiteral( "zoom_level" ), mTileZoomToRender, true );
168 scope->setVariable( QStringLiteral( "vector_tile_zoom" ), mTileMatrixSet.scaleToZoom( tileRenderScale ), true );
169 const QgsExpressionContextScopePopper popper( ctx.expressionContext(), scope );
170
171 mRenderer->startRender( *renderContext(), mTileZoomToRender, mTileRange );
172
173 // Draw background style if present
174 mRenderer->renderBackground( ctx );
175
176 QMap<QString, QSet<QString> > requiredFields = mRenderer->usedAttributes( ctx );
177
178 if ( mLabelProvider )
179 {
180 const QMap<QString, QSet<QString> > requiredFieldsLabeling = mLabelProvider->usedAttributes( ctx, mTileZoomToRender );
181 for ( auto it = requiredFieldsLabeling.begin(); it != requiredFieldsLabeling.end(); ++it )
182 {
183 requiredFields[it.key()].unite( it.value() );
184 }
185 }
186
187 for ( auto it = requiredFields.constBegin(); it != requiredFields.constEnd(); ++it )
188 mPerLayerFields[it.key()] = QgsVectorTileUtils::makeQgisFields( it.value() );
189
190 mRequiredLayers = mRenderer->requiredLayers( ctx, mTileZoomToRender );
191
192 if ( mLabelProvider )
193 {
194 mLabelProvider->setFields( mPerLayerFields );
195 QSet<QString> attributeNames; // we don't need this - already got referenced columns in provider constructor
196 if ( !mLabelProvider->prepare( ctx, attributeNames ) )
197 {
198 ctx.labelingEngine()->removeProvider( mLabelProvider );
199 mLabelProvider = nullptr; // provider is deleted by the engine
200 }
201 else
202 {
203 mRequiredLayers.unite( mLabelProvider->requiredLayers( ctx, mTileZoomToRender ) );
204 }
205 }
206
207 if ( !mDataProvider->supportsAsync() )
208 {
209 for ( const QgsVectorTileRawData &rawTile : std::as_const( rawTiles ) )
210 {
211 if ( ctx.renderingStopped() )
212 break;
213
214 decodeAndDrawTile( rawTile );
215 }
216 }
217 else
218 {
219 // Block until tiles are fetched and rendered. If the rendering gets canceled at some point,
220 // the async loader will catch the signal, abort requests and return from downloadBlocking()
221 asyncLoader->downloadBlocking();
222 if ( !asyncLoader->error().isEmpty() )
223 mErrors.append( asyncLoader->error() );
224 }
225
227 mRenderer->renderSelectedFeatures( mSelectedFeatures, ctx );
228
229 mRenderer->stopRender( ctx );
230
231 QgsDebugMsgLevel( QStringLiteral( "Total time for decoding: %1" ).arg( mTotalDecodeTime / 1000. ), 2 );
232 QgsDebugMsgLevel( QStringLiteral( "Drawing time: %1" ).arg( mTotalDrawTime / 1000. ), 2 );
233 QgsDebugMsgLevel( QStringLiteral( "Total time: %1" ).arg( tTotal.elapsed() / 1000. ), 2 );
234
235 return !ctx.renderingStopped();
236}
237
242
243void QgsVectorTileLayerRenderer::decodeAndDrawTile( const QgsVectorTileRawData &rawTile )
244{
246
247 QgsDebugMsgLevel( QStringLiteral( "Drawing tile " ) + rawTile.id.toString(), 2 );
248
249 QElapsedTimer tLoad;
250 tLoad.start();
251
252 // currently only MVT encoding supported
253 QgsVectorTileMVTDecoder decoder( mTileMatrixSet );
254 if ( !decoder.decode( rawTile ) )
255 {
256 QgsDebugMsgLevel( QStringLiteral( "Failed to parse raw tile data! " ) + rawTile.id.toString(), 2 );
257 return;
258 }
259
260 if ( ctx.renderingStopped() )
261 return;
262
264
265 QgsVectorTileRendererData tile( rawTile.id );
266 tile.setRenderZoomLevel( mTileZoomToRender );
267
268 tile.setFields( mPerLayerFields );
269 tile.setFeatures( decoder.layerFeatures( mPerLayerFields, ct, &mRequiredLayers ) );
270
271 try
272 {
273 tile.setTilePolygon( QgsVectorTileUtils::tilePolygon( rawTile.id, ct, mTileMatrixSet.tileMatrix( rawTile.id.zoomLevel() ), ctx.mapToPixel() ) );
274 }
275 catch ( QgsCsException & )
276 {
277 QgsDebugMsgLevel( QStringLiteral( "Failed to generate tile polygon " ) + rawTile.id.toString(), 2 );
278 return;
279 }
280
281 mTotalDecodeTime += tLoad.elapsed();
282
283 // calculate tile polygon in screen coordinates
284
285 if ( ctx.renderingStopped() )
286 return;
287
288 {
289 // set up clipping so that rendering does not go behind tile's extent
290 const QgsScopedQPainterState savePainterState( ctx.painter() );
291 // we have to intersect with any existing painter clip regions, or we risk overwriting valid clip
292 // regions setup outside of the vector tile renderer (e.g. layout map clip region)
293 ctx.painter()->setClipRegion( QRegion( tile.tilePolygon() ), Qt::IntersectClip );
294
295 QElapsedTimer tDraw;
296 tDraw.start();
297
298 mRenderer->renderTile( tile, ctx );
299 mTotalDrawTime += tDraw.elapsed();
300 }
301
302 if ( mLabelProvider )
303 mLabelProvider->registerTileFeatures( tile, ctx );
304
305 if ( mDrawTileBoundaries )
306 {
307 const QgsScopedQPainterState savePainterState( ctx.painter() );
308 ctx.painter()->setClipping( false );
309
310 QPen pen( Qt::red );
311 pen.setWidth( 3 );
312 QBrush brush( QColor( 255, 0, 0, 40 ), Qt::BrushStyle::Dense3Pattern );
313
314 ctx.painter()->setPen( pen );
315 ctx.painter()->setBrush( brush );
316 ctx.painter()->drawPolygon( tile.tilePolygon() );
317#if 1
318 QgsTextFormat format;
319 format.setColor( QColor( 255, 0, 0 ) );
320 format.buffer().setEnabled( true );
321
322 QgsTextRenderer::drawText( QRectF( QPoint( 0, 0 ), ctx.outputSize() ).intersected( tile.tilePolygon().boundingRect() ),
323 0, Qgis::TextHorizontalAlignment::Center, { tile.id().toString() },
325#endif
326 }
327}
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.
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() const
Returns the center point of the rectangle.
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...
bool testFlag(Qgis::RenderContextFlag flag) const
Check whether a particular flag is enabled.
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:109
int endRow() const
Returns index of the last row in the range.
Definition qgstiles.h:113
int startRow() const
Returns index of the first row in the range.
Definition qgstiles.h:111
int startColumn() const
Returns index of the first column in the range.
Definition qgstiles.h:107
bool isValid() const
Returns whether the range is valid (when all row/column numbers are not negative)
Definition qgstiles.h:104
QString toString() const
Returns tile coordinates in a formatted string.
Definition qgstiles.h:54
int zoomLevel() const
Returns tile's zoom level (Z)
Definition qgstiles.h:51
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 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:5445
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:39