QGIS API Documentation  3.23.0-Master (7c4a6de034)
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 
17 
18 #include <QElapsedTimer>
19 
21 #include "qgsfeedback.h"
22 #include "qgslogger.h"
23 
25 #include "qgsvectortilelayer.h"
26 #include "qgsvectortileloader.h"
27 #include "qgsvectortileutils.h"
28 
29 #include "qgslabelingengine.h"
30 #include "qgsvectortilelabeling.h"
31 #include "qgsmapclippingutils.h"
32 #include "qgsrendercontext.h"
33 
35  : QgsMapLayerRenderer( layer->id(), &context )
36  , mSourceType( layer->sourceType() )
37  , mSourcePath( layer->sourcePath() )
38  , mSourceMinZoom( layer->sourceMinZoom() )
39  , mSourceMaxZoom( layer->sourceMaxZoom() )
40  , mRenderer( layer->renderer()->clone() )
41  , mDrawTileBoundaries( layer->isTileBorderRenderingEnabled() )
42  , mFeedback( new QgsFeedback )
43  , mLayerOpacity( layer->opacity() )
44 {
45 
46  QgsDataSourceUri dsUri;
47  dsUri.setEncodedUri( layer->source() );
48  mAuthCfg = dsUri.authConfigId();
49  mHeaders [QStringLiteral( "referer" ) ] = dsUri.param( QStringLiteral( "referer" ) );
50 
51  if ( QgsLabelingEngine *engine = context.labelingEngine() )
52  {
53  if ( layer->labeling() )
54  {
55  mLabelProvider = layer->labeling()->provider( layer );
56  if ( mLabelProvider )
57  {
58  engine->addProvider( mLabelProvider );
59  }
60  }
61  }
62 
64 }
65 
67 {
69 
70  if ( ctx.renderingStopped() )
71  return false;
72 
73  const QgsScopedQPainterState painterState( ctx.painter() );
74 
75  if ( !mClippingRegions.empty() )
76  {
77  bool needsPainterClipPath = false;
78  const QPainterPath path = QgsMapClippingUtils::calculatePainterClipRegion( mClippingRegions, *renderContext(), QgsMapLayerType::VectorTileLayer, needsPainterClipPath );
79  if ( needsPainterClipPath )
80  renderContext()->painter()->setClipPath( path, Qt::IntersectClip );
81  }
82 
83  QElapsedTimer tTotal;
84  tTotal.start();
85 
86  QgsDebugMsgLevel( QStringLiteral( "Vector tiles rendering extent: " ) + ctx.extent().toString( -1 ), 2 );
87  QgsDebugMsgLevel( QStringLiteral( "Vector tiles map scale 1 : %1" ).arg( ctx.rendererScale() ), 2 );
88 
89  mTileZoom = QgsVectorTileUtils::scaleToZoomLevel( ctx.rendererScale(), mSourceMinZoom, mSourceMaxZoom );
90  QgsDebugMsgLevel( QStringLiteral( "Vector tiles zoom level: %1" ).arg( mTileZoom ), 2 );
91 
92  mTileMatrix = QgsTileMatrix::fromWebMercator( mTileZoom );
93 
94  mTileRange = mTileMatrix.tileRangeFromExtent( ctx.extent() );
95  QgsDebugMsgLevel( QStringLiteral( "Vector tiles range X: %1 - %2 Y: %3 - %4" )
96  .arg( mTileRange.startColumn() ).arg( mTileRange.endColumn() )
97  .arg( mTileRange.startRow() ).arg( mTileRange.endRow() ), 2 );
98 
99  // view center is used to sort the order of tiles for fetching and rendering
100  const QPointF viewCenter = mTileMatrix.mapToTileCoordinates( ctx.extent().center() );
101 
102  if ( !mTileRange.isValid() )
103  {
104  QgsDebugMsgLevel( QStringLiteral( "Vector tiles - outside of range" ), 2 );
105  return true; // nothing to do
106  }
107 
108  const bool isAsync = ( mSourceType == QLatin1String( "xyz" ) );
109 
110  if ( mSourceType == QLatin1String( "xyz" ) && mSourcePath.contains( QLatin1String( "{usage}" ) ) )
111  {
112  switch ( renderContext()->rendererUsage() )
113  {
115  mSourcePath.replace( QLatin1String( "{usage}" ), QLatin1String( "view" ) );
116  break;
118  mSourcePath.replace( QLatin1String( "{usage}" ), QLatin1String( "export" ) );
119  break;
121  mSourcePath.replace( QLatin1String( "{usage}" ), QString() );
122  break;
123  }
124  }
125 
126  std::unique_ptr<QgsVectorTileLoader> asyncLoader;
127  QList<QgsVectorTileRawData> rawTiles;
128  if ( !isAsync )
129  {
130  QElapsedTimer tFetch;
131  tFetch.start();
132  rawTiles = QgsVectorTileLoader::blockingFetchTileRawData( mSourceType, mSourcePath, mTileMatrix, viewCenter, mTileRange, mAuthCfg, mHeaders );
133  QgsDebugMsgLevel( QStringLiteral( "Tile fetching time: %1" ).arg( tFetch.elapsed() / 1000. ), 2 );
134  QgsDebugMsgLevel( QStringLiteral( "Fetched tiles: %1" ).arg( rawTiles.count() ), 2 );
135  }
136  else
137  {
138  asyncLoader.reset( new QgsVectorTileLoader( mSourcePath, mTileMatrix, mTileRange, viewCenter, mAuthCfg, mHeaders, mFeedback.get() ) );
139  QObject::connect( asyncLoader.get(), &QgsVectorTileLoader::tileRequestFinished, asyncLoader.get(), [this]( const QgsVectorTileRawData & rawTile )
140  {
141  QgsDebugMsgLevel( QStringLiteral( "Got tile asynchronously: " ) + rawTile.id.toString(), 2 );
142  if ( !rawTile.data.isEmpty() )
143  decodeAndDrawTile( rawTile );
144  } );
145  }
146 
147  if ( ctx.renderingStopped() )
148  return false;
149 
150  // add @zoom_level variable which can be used in styling
151  QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Tiles" ) ); // will be deleted by popper
152  scope->setVariable( QStringLiteral( "zoom_level" ), mTileZoom, true );
153  scope->setVariable( QStringLiteral( "vector_tile_zoom" ), QgsVectorTileUtils::scaleToZoom( ctx.rendererScale() ), true );
154  const QgsExpressionContextScopePopper popper( ctx.expressionContext(), scope );
155 
156  mRenderer->startRender( *renderContext(), mTileZoom, mTileRange );
157 
158  QMap<QString, QSet<QString> > requiredFields = mRenderer->usedAttributes( ctx );
159 
160  if ( mLabelProvider )
161  {
162  const QMap<QString, QSet<QString> > requiredFieldsLabeling = mLabelProvider->usedAttributes( ctx, mTileZoom );
163  for ( auto it = requiredFieldsLabeling.begin(); it != requiredFieldsLabeling.end(); ++it )
164  {
165  requiredFields[it.key()].unite( it.value() );
166  }
167  }
168 
169  for ( auto it = requiredFields.constBegin(); it != requiredFields.constEnd(); ++it )
170  mPerLayerFields[it.key()] = QgsVectorTileUtils::makeQgisFields( it.value() );
171 
172  mRequiredLayers = mRenderer->requiredLayers( ctx, mTileZoom );
173 
174  if ( mLabelProvider )
175  {
176  mLabelProvider->setFields( mPerLayerFields );
177  QSet<QString> attributeNames; // we don't need this - already got referenced columns in provider constructor
178  if ( !mLabelProvider->prepare( ctx, attributeNames ) )
179  {
180  ctx.labelingEngine()->removeProvider( mLabelProvider );
181  mLabelProvider = nullptr; // provider is deleted by the engine
182  }
183 
184  mRequiredLayers.unite( mLabelProvider->requiredLayers( ctx, mTileZoom ) );
185  }
186 
187  if ( !isAsync )
188  {
189  for ( const QgsVectorTileRawData &rawTile : rawTiles )
190  {
191  if ( ctx.renderingStopped() )
192  break;
193 
194  decodeAndDrawTile( rawTile );
195  }
196  }
197  else
198  {
199  // Block until tiles are fetched and rendered. If the rendering gets canceled at some point,
200  // the async loader will catch the signal, abort requests and return from downloadBlocking()
201  asyncLoader->downloadBlocking();
202  if ( !asyncLoader->error().isEmpty() )
203  mErrors.append( asyncLoader->error() );
204  }
205 
206  mRenderer->stopRender( ctx );
207 
208  QgsDebugMsgLevel( QStringLiteral( "Total time for decoding: %1" ).arg( mTotalDecodeTime / 1000. ), 2 );
209  QgsDebugMsgLevel( QStringLiteral( "Drawing time: %1" ).arg( mTotalDrawTime / 1000. ), 2 );
210  QgsDebugMsgLevel( QStringLiteral( "Total time: %1" ).arg( tTotal.elapsed() / 1000. ), 2 );
211 
212  return !ctx.renderingStopped();
213 }
214 
216 {
217  return renderContext()->testFlag( Qgis::RenderContextFlag::UseAdvancedEffects ) && ( !qgsDoubleNear( mLayerOpacity, 1.0 ) );
218 }
219 
220 void QgsVectorTileLayerRenderer::decodeAndDrawTile( const QgsVectorTileRawData &rawTile )
221 {
223 
224  QgsDebugMsgLevel( QStringLiteral( "Drawing tile " ) + rawTile.id.toString(), 2 );
225 
226  QElapsedTimer tLoad;
227  tLoad.start();
228 
229  // currently only MVT encoding supported
230  QgsVectorTileMVTDecoder decoder;
231  if ( !decoder.decode( rawTile.id, rawTile.data ) )
232  {
233  QgsDebugMsgLevel( QStringLiteral( "Failed to parse raw tile data! " ) + rawTile.id.toString(), 2 );
234  return;
235  }
236 
237  if ( ctx.renderingStopped() )
238  return;
239 
241 
242  QgsVectorTileRendererData tile( rawTile.id );
243  tile.setFields( mPerLayerFields );
244  tile.setFeatures( decoder.layerFeatures( mPerLayerFields, ct, &mRequiredLayers ) );
245 
246  try
247  {
248  tile.setTilePolygon( QgsVectorTileUtils::tilePolygon( rawTile.id, ct, mTileMatrix, ctx.mapToPixel() ) );
249  }
250  catch ( QgsCsException & )
251  {
252  QgsDebugMsgLevel( QStringLiteral( "Failed to generate tile polygon " ) + rawTile.id.toString(), 2 );
253  return;
254  }
255 
256  mTotalDecodeTime += tLoad.elapsed();
257 
258  // calculate tile polygon in screen coordinates
259 
260  if ( ctx.renderingStopped() )
261  return;
262 
263  // set up clipping so that rendering does not go behind tile's extent
264  const QgsScopedQPainterState savePainterState( ctx.painter() );
265  // we have to intersect with any existing painter clip regions, or we risk overwriting valid clip
266  // regions setup outside of the vector tile renderer (e.g. layout map clip region)
267  ctx.painter()->setClipRegion( QRegion( tile.tilePolygon() ), Qt::IntersectClip );
268 
269  QElapsedTimer tDraw;
270  tDraw.start();
271 
272  mRenderer->renderTile( tile, ctx );
273  mTotalDrawTime += tDraw.elapsed();
274 
275  if ( mLabelProvider )
276  mLabelProvider->registerTileFeatures( tile, ctx );
277 
278  if ( mDrawTileBoundaries )
279  {
280  const QgsScopedQPainterState savePainterState( ctx.painter() );
281  ctx.painter()->setClipping( false );
282 
283  QPen pen( Qt::red );
284  pen.setWidth( 3 );
285  ctx.painter()->setPen( pen );
286  ctx.painter()->drawPolygon( tile.tilePolygon() );
287  }
288 }
@ UseAdvancedEffects
Enable layer opacity and blending effects.
@ Export
Renderer used for printing or exporting to a file.
@ View
Renderer used for displaying on screen.
@ Unknown
Renderer used for unknown usage.
Class for doing transforms between two map coordinate systems.
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:66
Class for storing the component parts of a RDBMS data source URI (e.g.
void setEncodedUri(const QByteArray &uri)
Sets the complete encoded uri.
QString param(const QString &key) const
Returns a generic parameter value corresponding to the specified key.
QString authConfigId() const
Returns any associated authentication configuration ID stored in the URI.
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:45
The QgsLabelingEngine class provides map labeling functionality.
void removeProvider(QgsAbstractLabelProvider *provider)
Remove provider if the provider's initialization failed. Provider instance is deleted.
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.
static QPainterPath calculatePainterClipRegion(const QList< QgsMapClippingRegion > &regions, const QgsRenderContext &context, QgsMapLayerType layerType, bool &shouldClip)
Returns a QPainterPath representing the intersection of clipping regions from context which should be...
Base class for utility classes that encapsulate information necessary for rendering of map layers.
QgsRenderContext * renderContext()
Returns the render context associated with the renderer.
QString source() const
Returns the source for the layer.
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 SIP_HOLDGIL
Returns the center point of the rectangle.
Definition: qgsrectangle.h:251
Contains information about the context of a rendering operation.
Qgis::RendererUsage rendererUsage() const
Returns the renderer usage.
QPainter * painter()
Returns the destination QPainter for the render operation.
double rendererScale() const
Returns the renderer map scale.
QgsExpressionContext & expressionContext()
Gets the expression context.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
bool testFlag(Qgis::RenderContextFlag flag) const
Check whether a particular flag is enabled.
QgsLabelingEngine * labelingEngine() const
Gets access to new labeling engine (may be nullptr).
bool renderingStopped() const
Returns true if the rendering operation has been stopped and any ongoing rendering should be canceled...
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context.
const QgsRectangle & extent() const
When rendering a map layer, calling this method returns the "clipping" extent for the layer (in the l...
Scoped object for saving and restoring a QPainter object's state.
QPointF mapToTileCoordinates(const QgsPointXY &mapPoint) const
Returns row/column coordinates (floating point number) from the given point in map coordinates.
Definition: qgstiles.cpp:120
QgsTileRange tileRangeFromExtent(const QgsRectangle &mExtent) const
Returns tile range that fully covers the given extent.
Definition: qgstiles.cpp:96
static QgsTileMatrix fromWebMercator(int zoomLevel)
Returns a tile matrix for the usual web mercator.
Definition: qgstiles.cpp:22
int endColumn() const
Returns index of the last column in the range.
Definition: qgstiles.h:79
int endRow() const
Returns index of the last row in the range.
Definition: qgstiles.h:83
int startRow() const
Returns index of the first row in the range.
Definition: qgstiles.h:81
int startColumn() const
Returns index of the first column in the range.
Definition: qgstiles.h:77
bool isValid() const
Returns whether the range is valid (when all row/column numbers are not negative)
Definition: qgstiles.h:74
QString toString() const
Returns tile coordinates in a formatted string.
Definition: qgstiles.h:50
virtual bool prepare(QgsRenderContext &context, QSet< QString > &attributeNames)
Prepare for registration of features.
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 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 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(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.
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 QString &sourceType, const QString &sourcePath, const QgsTileMatrix &tileMatrix, const QPointF &viewCenter, const QgsTileRange &range, const QString &authid, const QgsHttpHeaders &headers)
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.
QgsVectorTileFeatures layerFeatures(const QMap< QString, QgsFields > &perLayerFields, const QgsCoordinateTransform &ct, const QSet< QString > *layerSubset=nullptr) const
Returns decoded features grouped by sub-layers.
bool decode(QgsTileXYZ tileID, const QByteArray &rawTileData)
Tries to decode raw tile data, returns true on success.
Keeps track of raw tile data that need to be decoded.
QByteArray data
Raw tile data.
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 int scaleToZoomLevel(double mapScale, int sourceMinZoom, int sourceMaxZoom)
Finds best fitting zoom level (assuming GoogleCRS84Quad tile matrix set) given map scale denominator ...
static double scaleToZoom(double mapScale)
Finds zoom level (assuming GoogleCRS84Quad tile matrix set) given map scale denominator.
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(QSet< QString > flds)
Returns QgsFields instance based on the set of field names.
@ VectorTileLayer
Vector tile layer. Added in QGIS 3.14.
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition: qgis.h:1546
#define QgsDebugMsgLevel(str, level)
Definition: qgslogger.h:39