QGIS API Documentation  3.22.4-Białowieża (ce8e65e95e)
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  mReferer = 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  std::unique_ptr<QgsVectorTileLoader> asyncLoader;
111  QList<QgsVectorTileRawData> rawTiles;
112  if ( !isAsync )
113  {
114  QElapsedTimer tFetch;
115  tFetch.start();
116  rawTiles = QgsVectorTileLoader::blockingFetchTileRawData( mSourceType, mSourcePath, mTileMatrix, viewCenter, mTileRange, mAuthCfg, mReferer );
117  QgsDebugMsgLevel( QStringLiteral( "Tile fetching time: %1" ).arg( tFetch.elapsed() / 1000. ), 2 );
118  QgsDebugMsgLevel( QStringLiteral( "Fetched tiles: %1" ).arg( rawTiles.count() ), 2 );
119  }
120  else
121  {
122  asyncLoader.reset( new QgsVectorTileLoader( mSourcePath, mTileMatrix, mTileRange, viewCenter, mAuthCfg, mReferer, mFeedback.get() ) );
123  QObject::connect( asyncLoader.get(), &QgsVectorTileLoader::tileRequestFinished, asyncLoader.get(), [this]( const QgsVectorTileRawData & rawTile )
124  {
125  QgsDebugMsgLevel( QStringLiteral( "Got tile asynchronously: " ) + rawTile.id.toString(), 2 );
126  if ( !rawTile.data.isEmpty() )
127  decodeAndDrawTile( rawTile );
128  } );
129  }
130 
131  if ( ctx.renderingStopped() )
132  return false;
133 
134  // add @zoom_level variable which can be used in styling
135  QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Tiles" ) ); // will be deleted by popper
136  scope->setVariable( QStringLiteral( "zoom_level" ), mTileZoom, true );
137  scope->setVariable( QStringLiteral( "vector_tile_zoom" ), QgsVectorTileUtils::scaleToZoom( ctx.rendererScale() ), true );
138  const QgsExpressionContextScopePopper popper( ctx.expressionContext(), scope );
139 
140  mRenderer->startRender( *renderContext(), mTileZoom, mTileRange );
141 
142  QMap<QString, QSet<QString> > requiredFields = mRenderer->usedAttributes( ctx );
143 
144  if ( mLabelProvider )
145  {
146  const QMap<QString, QSet<QString> > requiredFieldsLabeling = mLabelProvider->usedAttributes( ctx, mTileZoom );
147  for ( auto it = requiredFieldsLabeling.begin(); it != requiredFieldsLabeling.end(); ++it )
148  {
149  requiredFields[it.key()].unite( it.value() );
150  }
151  }
152 
153  for ( auto it = requiredFields.constBegin(); it != requiredFields.constEnd(); ++it )
154  mPerLayerFields[it.key()] = QgsVectorTileUtils::makeQgisFields( it.value() );
155 
156  mRequiredLayers = mRenderer->requiredLayers( ctx, mTileZoom );
157 
158  if ( mLabelProvider )
159  {
160  mLabelProvider->setFields( mPerLayerFields );
161  QSet<QString> attributeNames; // we don't need this - already got referenced columns in provider constructor
162  if ( !mLabelProvider->prepare( ctx, attributeNames ) )
163  {
164  ctx.labelingEngine()->removeProvider( mLabelProvider );
165  mLabelProvider = nullptr; // provider is deleted by the engine
166  }
167  else
168  {
169  mRequiredLayers.unite( mLabelProvider->requiredLayers( ctx, mTileZoom ) );
170  }
171  }
172 
173  if ( !isAsync )
174  {
175  for ( const QgsVectorTileRawData &rawTile : rawTiles )
176  {
177  if ( ctx.renderingStopped() )
178  break;
179 
180  decodeAndDrawTile( rawTile );
181  }
182  }
183  else
184  {
185  // Block until tiles are fetched and rendered. If the rendering gets canceled at some point,
186  // the async loader will catch the signal, abort requests and return from downloadBlocking()
187  asyncLoader->downloadBlocking();
188  }
189 
190  mRenderer->stopRender( ctx );
191 
192  QgsDebugMsgLevel( QStringLiteral( "Total time for decoding: %1" ).arg( mTotalDecodeTime / 1000. ), 2 );
193  QgsDebugMsgLevel( QStringLiteral( "Drawing time: %1" ).arg( mTotalDrawTime / 1000. ), 2 );
194  QgsDebugMsgLevel( QStringLiteral( "Total time: %1" ).arg( tTotal.elapsed() / 1000. ), 2 );
195 
196  return !ctx.renderingStopped();
197 }
198 
200 {
201  return renderContext()->testFlag( Qgis::RenderContextFlag::UseAdvancedEffects ) && ( !qgsDoubleNear( mLayerOpacity, 1.0 ) );
202 }
203 
204 void QgsVectorTileLayerRenderer::decodeAndDrawTile( const QgsVectorTileRawData &rawTile )
205 {
207 
208  QgsDebugMsgLevel( QStringLiteral( "Drawing tile " ) + rawTile.id.toString(), 2 );
209 
210  QElapsedTimer tLoad;
211  tLoad.start();
212 
213  // currently only MVT encoding supported
214  QgsVectorTileMVTDecoder decoder;
215  if ( !decoder.decode( rawTile.id, rawTile.data ) )
216  {
217  QgsDebugMsgLevel( QStringLiteral( "Failed to parse raw tile data! " ) + rawTile.id.toString(), 2 );
218  return;
219  }
220 
221  if ( ctx.renderingStopped() )
222  return;
223 
225 
226  QgsVectorTileRendererData tile( rawTile.id );
227  tile.setFields( mPerLayerFields );
228  tile.setFeatures( decoder.layerFeatures( mPerLayerFields, ct, &mRequiredLayers ) );
229 
230  try
231  {
232  tile.setTilePolygon( QgsVectorTileUtils::tilePolygon( rawTile.id, ct, mTileMatrix, ctx.mapToPixel() ) );
233  }
234  catch ( QgsCsException & )
235  {
236  QgsDebugMsgLevel( QStringLiteral( "Failed to generate tile polygon " ) + rawTile.id.toString(), 2 );
237  return;
238  }
239 
240  mTotalDecodeTime += tLoad.elapsed();
241 
242  // calculate tile polygon in screen coordinates
243 
244  if ( ctx.renderingStopped() )
245  return;
246 
247  // set up clipping so that rendering does not go behind tile's extent
248  const QgsScopedQPainterState savePainterState( ctx.painter() );
249  // we have to intersect with any existing painter clip regions, or we risk overwriting valid clip
250  // regions setup outside of the vector tile renderer (e.g. layout map clip region)
251  ctx.painter()->setClipRegion( QRegion( tile.tilePolygon() ), Qt::IntersectClip );
252 
253  QElapsedTimer tDraw;
254  tDraw.start();
255 
256  mRenderer->renderTile( tile, ctx );
257  mTotalDrawTime += tDraw.elapsed();
258 
259  if ( mLabelProvider )
260  mLabelProvider->registerTileFeatures( tile, ctx );
261 
262  if ( mDrawTileBoundaries )
263  {
264  const QgsScopedQPainterState savePainterState( ctx.painter() );
265  ctx.painter()->setClipping( false );
266 
267  QPen pen( Qt::red );
268  pen.setWidth( 3 );
269  ctx.painter()->setPen( pen );
270  ctx.painter()->drawPolygon( tile.tilePolygon() );
271  }
272 }
@ UseAdvancedEffects
Enable layer opacity and blending effects.
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.
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)
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 QString &referer)
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
Added in 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:1246
#define QgsDebugMsgLevel(str, level)
Definition: qgslogger.h:39