QGIS API Documentation  3.25.0-Master (10b47c2603)
qgsvectorlayerrenderer.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsvectorlayerrenderer.cpp
3  --------------------------------------
4  Date : December 2013
5  Copyright : (C) 2013 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 
16 #include "qgsvectorlayerrenderer.h"
17 
18 #include "diagram/qgsdiagram.h"
19 
20 #include "qgsdiagramrenderer.h"
21 #include "qgsmessagelog.h"
22 #include "qgspallabeling.h"
23 #include "qgsrenderer.h"
24 #include "qgsrendercontext.h"
26 #include "qgssymbollayer.h"
27 #include "qgssymbollayerutils.h"
28 #include "qgssymbol.h"
29 #include "qgsvectorlayer.h"
32 #include "qgsvectorlayerlabeling.h"
34 #include "qgspainteffect.h"
36 #include "qgsexception.h"
37 #include "qgslabelsink.h"
38 #include "qgslogger.h"
43 #include "qgsmapclippingutils.h"
45 
46 #include <QPicture>
47 #include <QTimer>
48 
50  : QgsMapLayerRenderer( layer->id(), &context )
51  , mFeedback( std::make_unique< QgsFeedback >() )
52  , mLayer( layer )
53  , mFields( layer->fields() )
54  , mSource( std::make_unique< QgsVectorLayerFeatureSource >( layer ) )
55 {
56  std::unique_ptr< QgsFeatureRenderer > mainRenderer( layer->renderer() ? layer->renderer()->clone() : nullptr );
57 
58  if ( !mainRenderer )
59  return;
60 
61  QList< const QgsFeatureRendererGenerator * > generators = layer->featureRendererGenerators();
62  std::sort( generators.begin(), generators.end(), []( const QgsFeatureRendererGenerator * g1, const QgsFeatureRendererGenerator * g2 )
63  {
64  return g1->level() < g2->level();
65  } );
66 
67  bool insertedMainRenderer = false;
68  double prevLevel = std::numeric_limits< double >::lowest();
69  mRenderer = mainRenderer.get();
70  for ( const QgsFeatureRendererGenerator *generator : std::as_const( generators ) )
71  {
72  if ( generator->level() >= 0 && prevLevel < 0 && !insertedMainRenderer )
73  {
74  // insert main renderer when level changes from <0 to >0
75  mRenderers.emplace_back( std::move( mainRenderer ) );
76  insertedMainRenderer = true;
77  }
78  mRenderers.emplace_back( generator->createRenderer() );
79  prevLevel = generator->level();
80  }
81  // cppcheck-suppress accessMoved
82  if ( mainRenderer )
83  {
84  // cppcheck-suppress accessMoved
85  mRenderers.emplace_back( std::move( mainRenderer ) );
86  }
87 
88  mSelectedFeatureIds = layer->selectedFeatureIds();
89 
90  mDrawVertexMarkers = nullptr != layer->editBuffer();
91 
92  mGeometryType = layer->geometryType();
93 
94  mFeatureBlendMode = layer->featureBlendMode();
95 
96  if ( context.isTemporal() )
97  {
98  QgsVectorLayerTemporalContext temporalContext;
99  temporalContext.setLayer( layer );
100  mTemporalFilter = qobject_cast< const QgsVectorLayerTemporalProperties * >( layer->temporalProperties() )->createFilterString( temporalContext, context.temporalRange() );
101  QgsDebugMsgLevel( "Rendering with Temporal Filter: " + mTemporalFilter, 2 );
102  }
103 
104  // if there's already a simplification method specified via the context, we respect that. Otherwise, we fall back
105  // to the layer's individual setting
106  if ( renderContext()->vectorSimplifyMethod().simplifyHints() != QgsVectorSimplifyMethod::NoSimplification )
107  {
108  mSimplifyMethod = renderContext()->vectorSimplifyMethod();
111  }
112  else
113  {
114  mSimplifyMethod = layer->simplifyMethod();
116  }
117 
119 
121  if ( markerTypeString == QLatin1String( "Cross" ) )
122  {
123  mVertexMarkerStyle = Qgis::VertexMarkerType::Cross;
124  }
125  else if ( markerTypeString == QLatin1String( "SemiTransparentCircle" ) )
126  {
128  }
129  else
130  {
131  mVertexMarkerStyle = Qgis::VertexMarkerType::NoMarker;
132  }
133 
135 
136  QgsDebugMsgLevel( "rendering v2:\n " + mRenderer->dump(), 2 );
137 
138  if ( mDrawVertexMarkers )
139  {
140  // set editing vertex markers style (main renderer only)
141  mRenderer->setVertexMarkerAppearance( mVertexMarkerStyle, mVertexMarkerSize );
142  }
144 
145  for ( const std::unique_ptr< QgsFeatureRenderer > &renderer : mRenderers )
146  {
147  mAttrNames.unite( renderer->usedAttributes( context ) );
148  }
149  if ( context.hasRenderedFeatureHandlers() )
150  {
151  const QList< QgsRenderedFeatureHandlerInterface * > handlers = context.renderedFeatureHandlers();
152  for ( QgsRenderedFeatureHandlerInterface *handler : handlers )
153  mAttrNames.unite( handler->usedAttributes( layer, context ) );
154  }
155 
156  //register label and diagram layer to the labeling engine
157  prepareLabeling( layer, mAttrNames );
158  prepareDiagrams( layer, mAttrNames );
159 
160  mClippingRegions = QgsMapClippingUtils::collectClippingRegionsForLayer( context, layer );
161 
162  if ( std::any_of( mRenderers.begin(), mRenderers.end(), []( const auto & renderer ) { return renderer->forceRasterRender(); } ) )
163  {
164  //raster rendering is forced for this layer
165  mForceRasterRender = true;
166  }
167 
169  ( ( layer->blendMode() != QPainter::CompositionMode_SourceOver )
170  || ( layer->featureBlendMode() != QPainter::CompositionMode_SourceOver )
171  || ( !qgsDoubleNear( layer->opacity(), 1.0 ) ) ) )
172  {
173  //layer properties require rasterization
174  mForceRasterRender = true;
175  }
176 
177  mReadyToCompose = false;
178 }
179 
181 
183 {
184  mRenderTimeHint = time;
185 }
186 
188 {
189  return mFeedback.get();
190 }
191 
193 {
194  return mForceRasterRender;
195 }
196 
198 {
199  if ( mGeometryType == QgsWkbTypes::NullGeometry || mGeometryType == QgsWkbTypes::UnknownGeometry )
200  {
201  mReadyToCompose = true;
202  return true;
203  }
204 
205  if ( mRenderers.empty() )
206  {
207  mReadyToCompose = true;
208  mErrors.append( QObject::tr( "No renderer for drawing." ) );
209  return false;
210  }
211 
212  // if the previous layer render was relatively quick (e.g. less than 3 seconds), the we show any previously
213  // cached version of the layer during rendering instead of the usual progressive updates
214  if ( mRenderTimeHint > 0 && mRenderTimeHint <= MAX_TIME_TO_USE_CACHED_PREVIEW_IMAGE )
215  {
216  mBlockRenderUpdates = true;
217  mElapsedTimer.start();
218  }
219 
220  bool res = true;
221  for ( const std::unique_ptr< QgsFeatureRenderer > &renderer : mRenderers )
222  {
223  res = renderInternal( renderer.get() ) && res;
224  }
225 
226  mReadyToCompose = true;
227  return res && !renderContext()->renderingStopped();
228 }
229 
230 bool QgsVectorLayerRenderer::renderInternal( QgsFeatureRenderer *renderer )
231 {
232  const bool isMainRenderer = renderer == mRenderer;
233 
234  QgsRenderContext &context = *renderContext();
235  context.setSymbologyReferenceScale( renderer->referenceScale() );
236 
237  if ( renderer->type() == QLatin1String( "nullSymbol" ) )
238  {
239  // a little shortcut for the null symbol renderer - most of the time it is not going to render anything
240  // so we can even skip the whole loop to fetch features
241  if ( !isMainRenderer ||
242  ( !mDrawVertexMarkers && !mLabelProvider && !mDiagramProvider && mSelectedFeatureIds.isEmpty() ) )
243  return true;
244  }
245 
246  QgsScopedQPainterState painterState( context.painter() );
247 
248  bool usingEffect = false;
249  if ( renderer->paintEffect() && renderer->paintEffect()->enabled() )
250  {
251  usingEffect = true;
252  renderer->paintEffect()->begin( context );
253  }
254 
255  // Per feature blending mode
256  if ( context.useAdvancedEffects() && mFeatureBlendMode != QPainter::CompositionMode_SourceOver )
257  {
258  // set the painter to the feature blend mode, so that features drawn
259  // on this layer will interact and blend with each other
260  context.painter()->setCompositionMode( mFeatureBlendMode );
261  }
262 
263  renderer->startRender( context, mFields );
264 
265  QString rendererFilter = renderer->filter( mFields );
266 
267  QgsRectangle requestExtent = context.extent();
268  if ( !mClippingRegions.empty() )
269  {
270  mClipFilterGeom = QgsMapClippingUtils::calculateFeatureRequestGeometry( mClippingRegions, context, mApplyClipFilter );
271  requestExtent = requestExtent.intersect( mClipFilterGeom.boundingBox() );
272 
273  mClipFeatureGeom = QgsMapClippingUtils::calculateFeatureIntersectionGeometry( mClippingRegions, context, mApplyClipGeometries );
274 
275  bool needsPainterClipPath = false;
276  const QPainterPath path = QgsMapClippingUtils::calculatePainterClipRegion( mClippingRegions, context, QgsMapLayerType::VectorLayer, needsPainterClipPath );
277  if ( needsPainterClipPath )
278  context.painter()->setClipPath( path, Qt::IntersectClip );
279 
280  mLabelClipFeatureGeom = QgsMapClippingUtils::calculateLabelIntersectionGeometry( mClippingRegions, context, mApplyLabelClipGeometries );
281 
282  if ( mDiagramProvider )
283  mDiagramProvider->setClipFeatureGeometry( mLabelClipFeatureGeom );
284  }
285  renderer->modifyRequestExtent( requestExtent, context );
286 
287  QgsFeatureRequest featureRequest = QgsFeatureRequest()
288  .setFilterRect( requestExtent )
289  .setSubsetOfAttributes( mAttrNames, mFields )
291  if ( renderer->orderByEnabled() )
292  {
293  featureRequest.setOrderBy( renderer->orderBy() );
294  }
295 
296  const QgsFeatureFilterProvider *featureFilterProvider = context.featureFilterProvider();
297  if ( featureFilterProvider )
298  {
299  featureFilterProvider->filterFeatures( mLayer, featureRequest );
300  }
301  if ( !rendererFilter.isEmpty() && rendererFilter != QLatin1String( "TRUE" ) )
302  {
303  featureRequest.combineFilterExpression( rendererFilter );
304  }
305  if ( !mTemporalFilter.isEmpty() )
306  {
307  featureRequest.combineFilterExpression( mTemporalFilter );
308  }
309 
310  if ( renderer->usesEmbeddedSymbols() )
311  {
312  featureRequest.setFlags( featureRequest.flags() | QgsFeatureRequest::EmbeddedSymbols );
313  }
314 
315  // enable the simplification of the geometries (Using the current map2pixel context) before send it to renderer engine.
316  if ( mSimplifyGeometry )
317  {
318  double map2pixelTol = mSimplifyMethod.threshold();
319  bool validTransform = true;
320 
321  const QgsMapToPixel &mtp = context.mapToPixel();
322  map2pixelTol *= mtp.mapUnitsPerPixel();
323  const QgsCoordinateTransform ct = context.coordinateTransform();
324 
325  // resize the tolerance using the change of size of an 1-BBOX from the source CoordinateSystem to the target CoordinateSystem
326  if ( ct.isValid() && !ct.isShortCircuited() )
327  {
328  try
329  {
330  QgsCoordinateTransform toleranceTransform = ct;
331  QgsPointXY center = context.extent().center();
332  double rectSize = toleranceTransform.sourceCrs().mapUnits() == QgsUnitTypes::DistanceDegrees ? 0.0008983 /* ~100/(40075014/360=111319.4833) */ : 100;
333 
334  QgsRectangle sourceRect = QgsRectangle( center.x(), center.y(), center.x() + rectSize, center.y() + rectSize );
335  toleranceTransform.setBallparkTransformsAreAppropriate( true );
336  QgsRectangle targetRect = toleranceTransform.transform( sourceRect );
337 
338  QgsDebugMsgLevel( QStringLiteral( "Simplify - SourceTransformRect=%1" ).arg( sourceRect.toString( 16 ) ), 4 );
339  QgsDebugMsgLevel( QStringLiteral( "Simplify - TargetTransformRect=%1" ).arg( targetRect.toString( 16 ) ), 4 );
340 
341  if ( !sourceRect.isEmpty() && sourceRect.isFinite() && !targetRect.isEmpty() && targetRect.isFinite() )
342  {
343  QgsPointXY minimumSrcPoint( sourceRect.xMinimum(), sourceRect.yMinimum() );
344  QgsPointXY maximumSrcPoint( sourceRect.xMaximum(), sourceRect.yMaximum() );
345  QgsPointXY minimumDstPoint( targetRect.xMinimum(), targetRect.yMinimum() );
346  QgsPointXY maximumDstPoint( targetRect.xMaximum(), targetRect.yMaximum() );
347 
348  double sourceHypothenuse = std::sqrt( minimumSrcPoint.sqrDist( maximumSrcPoint ) );
349  double targetHypothenuse = std::sqrt( minimumDstPoint.sqrDist( maximumDstPoint ) );
350 
351  QgsDebugMsgLevel( QStringLiteral( "Simplify - SourceHypothenuse=%1" ).arg( sourceHypothenuse ), 4 );
352  QgsDebugMsgLevel( QStringLiteral( "Simplify - TargetHypothenuse=%1" ).arg( targetHypothenuse ), 4 );
353 
354  if ( !qgsDoubleNear( targetHypothenuse, 0.0 ) )
355  map2pixelTol *= ( sourceHypothenuse / targetHypothenuse );
356  }
357  }
358  catch ( QgsCsException &cse )
359  {
360  QgsMessageLog::logMessage( QObject::tr( "Simplify transform error caught: %1" ).arg( cse.what() ), QObject::tr( "CRS" ) );
361  validTransform = false;
362  }
363  }
364 
365  if ( validTransform )
366  {
367  QgsSimplifyMethod simplifyMethod;
369  simplifyMethod.setTolerance( map2pixelTol );
370  simplifyMethod.setThreshold( mSimplifyMethod.threshold() );
371  simplifyMethod.setForceLocalOptimization( mSimplifyMethod.forceLocalOptimization() );
372  featureRequest.setSimplifyMethod( simplifyMethod );
373 
374  QgsVectorSimplifyMethod vectorMethod = mSimplifyMethod;
375  vectorMethod.setTolerance( map2pixelTol );
376  context.setVectorSimplifyMethod( vectorMethod );
377  }
378  else
379  {
380  QgsVectorSimplifyMethod vectorMethod;
382  context.setVectorSimplifyMethod( vectorMethod );
383  }
384  }
385  else
386  {
387  QgsVectorSimplifyMethod vectorMethod;
389  context.setVectorSimplifyMethod( vectorMethod );
390  }
391 
392  featureRequest.setFeedback( mFeedback.get() );
393  // also set the interruption checker for the expression context, in case the renderer uses some complex expression
394  // which could benefit from early exit paths...
395  context.expressionContext().setFeedback( mFeedback.get() );
396 
397  QgsFeatureIterator fit = mSource->getFeatures( featureRequest );
398  // Attach an interruption checker so that iterators that have potentially
399  // slow fetchFeature() implementations, such as in the WFS provider, can
400  // check it, instead of relying on just the mContext.renderingStopped() check
401  // in drawRenderer()
402  fit.setInterruptionChecker( mFeedback.get() );
403 
404  if ( ( renderer->capabilities() & QgsFeatureRenderer::SymbolLevels ) && renderer->usingSymbolLevels() )
405  drawRendererLevels( renderer, fit );
406  else
407  drawRenderer( renderer, fit );
408 
409  if ( !fit.isValid() )
410  {
411  mErrors.append( QStringLiteral( "Data source invalid" ) );
412  }
413 
414  if ( usingEffect )
415  {
416  renderer->paintEffect()->end( context );
417  }
418 
419  context.expressionContext().setFeedback( nullptr );
420  return true;
421 }
422 
423 
424 void QgsVectorLayerRenderer::drawRenderer( QgsFeatureRenderer *renderer, QgsFeatureIterator &fit )
425 {
426  const bool isMainRenderer = renderer == mRenderer;
427 
429  QgsRenderContext &context = *renderContext();
430  context.expressionContext().appendScope( symbolScope );
431 
432  std::unique_ptr< QgsGeometryEngine > clipEngine;
433  if ( mApplyClipFilter )
434  {
435  clipEngine.reset( QgsGeometry::createGeometryEngine( mClipFilterGeom.constGet() ) );
436  clipEngine->prepareGeometry();
437  }
438 
439  QgsFeature fet;
440  while ( fit.nextFeature( fet ) )
441  {
442  try
443  {
444  if ( context.renderingStopped() )
445  {
446  QgsDebugMsgLevel( QStringLiteral( "Drawing of vector layer %1 canceled." ).arg( layerId() ), 2 );
447  break;
448  }
449 
450  if ( !fet.hasGeometry() || fet.geometry().isEmpty() )
451  continue; // skip features without geometry
452 
453  if ( clipEngine && !clipEngine->intersects( fet.geometry().constGet() ) )
454  continue; // skip features outside of clipping region
455 
456  if ( mApplyClipGeometries )
457  context.setFeatureClipGeometry( mClipFeatureGeom );
458 
459  context.expressionContext().setFeature( fet );
460 
461  bool sel = isMainRenderer && context.showSelection() && mSelectedFeatureIds.contains( fet.id() );
462  bool drawMarker = isMainRenderer && ( mDrawVertexMarkers && context.drawEditingInformation() && ( !mVertexMarkerOnlyForSelection || sel ) );
463 
464  // render feature
465  bool rendered = false;
467  {
468  rendered = renderer->renderFeature( fet, context, -1, sel, drawMarker );
469  }
470  else
471  {
472  rendered = renderer->willRenderFeature( fet, context );
473  }
474 
475  // labeling - register feature
476  if ( rendered )
477  {
478  // as soon as first feature is rendered, we can start showing layer updates.
479  // but if we are blocking render updates (so that a previously cached image is being shown), we wait
480  // at most e.g. 3 seconds before we start forcing progressive updates.
481  if ( !mBlockRenderUpdates || mElapsedTimer.elapsed() > MAX_TIME_TO_USE_CACHED_PREVIEW_IMAGE )
482  {
483  mReadyToCompose = true;
484  }
485 
486  // new labeling engine
487  if ( isMainRenderer && context.labelingEngine() && ( mLabelProvider || mDiagramProvider ) )
488  {
489  QgsGeometry obstacleGeometry;
490  QgsSymbolList symbols = renderer->originalSymbolsForFeature( fet, context );
491  QgsSymbol *symbol = nullptr;
492  if ( !symbols.isEmpty() && fet.geometry().type() == QgsWkbTypes::PointGeometry )
493  {
494  obstacleGeometry = QgsVectorLayerLabelProvider::getPointObstacleGeometry( fet, context, symbols );
495  }
496 
497  if ( !symbols.isEmpty() )
498  {
499  symbol = symbols.at( 0 );
500  QgsExpressionContextUtils::updateSymbolScope( symbol, symbolScope );
501  }
502 
503  if ( mApplyLabelClipGeometries )
504  context.setFeatureClipGeometry( mLabelClipFeatureGeom );
505 
506  if ( mLabelProvider )
507  {
508  mLabelProvider->registerFeature( fet, context, obstacleGeometry, symbol );
509  }
510  if ( mDiagramProvider )
511  {
512  mDiagramProvider->registerFeature( fet, context, obstacleGeometry );
513  }
514 
515  if ( mApplyLabelClipGeometries )
516  context.setFeatureClipGeometry( QgsGeometry() );
517  }
518  }
519  }
520  catch ( const QgsCsException &cse )
521  {
522  Q_UNUSED( cse )
523  QgsDebugMsg( QStringLiteral( "Failed to transform a point while drawing a feature with ID '%1'. Ignoring this feature. %2" )
524  .arg( fet.id() ).arg( cse.what() ) );
525  }
526  }
527 
528  delete context.expressionContext().popScope();
529 
530  stopRenderer( renderer, nullptr );
531 }
532 
533 void QgsVectorLayerRenderer::drawRendererLevels( QgsFeatureRenderer *renderer, QgsFeatureIterator &fit )
534 {
535  const bool isMainRenderer = renderer == mRenderer;
536 
537  QHash< QgsSymbol *, QList<QgsFeature> > features; // key = symbol, value = array of features
538  QgsRenderContext &context = *renderContext();
539 
540  QgsSingleSymbolRenderer *selRenderer = nullptr;
541  if ( !mSelectedFeatureIds.isEmpty() )
542  {
543  selRenderer = new QgsSingleSymbolRenderer( QgsSymbol::defaultSymbol( mGeometryType ) );
544  selRenderer->symbol()->setColor( context.selectionColor() );
545  selRenderer->setVertexMarkerAppearance( mVertexMarkerStyle, mVertexMarkerSize );
546  selRenderer->startRender( context, mFields );
547  }
548 
550  std::unique_ptr< QgsExpressionContextScopePopper > scopePopper = std::make_unique< QgsExpressionContextScopePopper >( context.expressionContext(), symbolScope );
551 
552 
553  std::unique_ptr< QgsGeometryEngine > clipEngine;
554  if ( mApplyClipFilter )
555  {
556  clipEngine.reset( QgsGeometry::createGeometryEngine( mClipFilterGeom.constGet() ) );
557  clipEngine->prepareGeometry();
558  }
559 
560  if ( mApplyLabelClipGeometries )
561  context.setFeatureClipGeometry( mLabelClipFeatureGeom );
562 
563  // 1. fetch features
564  QgsFeature fet;
565  while ( fit.nextFeature( fet ) )
566  {
567  if ( context.renderingStopped() )
568  {
569  qDebug( "rendering stop!" );
570  stopRenderer( renderer, selRenderer );
571  return;
572  }
573 
574  if ( !fet.hasGeometry() )
575  continue; // skip features without geometry
576 
577  if ( clipEngine && !clipEngine->intersects( fet.geometry().constGet() ) )
578  continue; // skip features outside of clipping region
579 
580  context.expressionContext().setFeature( fet );
581  QgsSymbol *sym = renderer->symbolForFeature( fet, context );
582  if ( !sym )
583  {
584  continue;
585  }
586 
588  {
589  if ( !features.contains( sym ) )
590  {
591  features.insert( sym, QList<QgsFeature>() );
592  }
593  features[sym].append( fet );
594  }
595 
596  // new labeling engine
597  if ( isMainRenderer && context.labelingEngine() && ( mLabelProvider || mDiagramProvider ) )
598  {
599  QgsGeometry obstacleGeometry;
600  QgsSymbolList symbols = renderer->originalSymbolsForFeature( fet, context );
601  QgsSymbol *symbol = nullptr;
602  if ( !symbols.isEmpty() && fet.geometry().type() == QgsWkbTypes::PointGeometry )
603  {
604  obstacleGeometry = QgsVectorLayerLabelProvider::getPointObstacleGeometry( fet, context, symbols );
605  }
606 
607  if ( !symbols.isEmpty() )
608  {
609  symbol = symbols.at( 0 );
610  QgsExpressionContextUtils::updateSymbolScope( symbol, symbolScope );
611  }
612 
613  if ( mLabelProvider )
614  {
615  mLabelProvider->registerFeature( fet, context, obstacleGeometry, symbol );
616  }
617  if ( mDiagramProvider )
618  {
619  mDiagramProvider->registerFeature( fet, context, obstacleGeometry );
620  }
621  }
622  }
623 
624  if ( mApplyLabelClipGeometries )
625  context.setFeatureClipGeometry( QgsGeometry() );
626 
627  scopePopper.reset();
628 
629  if ( features.empty() )
630  {
631  // nothing to draw
632  stopRenderer( renderer, selRenderer );
633  return;
634  }
635 
636  // find out the order
637  QgsSymbolLevelOrder levels;
638  QgsSymbolList symbols = renderer->symbols( context );
639  for ( int i = 0; i < symbols.count(); i++ )
640  {
641  QgsSymbol *sym = symbols[i];
642  for ( int j = 0; j < sym->symbolLayerCount(); j++ )
643  {
644  int level = sym->symbolLayer( j )->renderingPass();
645  if ( level < 0 || level >= 1000 ) // ignore invalid levels
646  continue;
647  QgsSymbolLevelItem item( sym, j );
648  while ( level >= levels.count() ) // append new empty levels
649  levels.append( QgsSymbolLevel() );
650  levels[level].append( item );
651  }
652  }
653 
654  if ( mApplyClipGeometries )
655  context.setFeatureClipGeometry( mClipFeatureGeom );
656 
657  // 2. draw features in correct order
658  for ( int l = 0; l < levels.count(); l++ )
659  {
660  QgsSymbolLevel &level = levels[l];
661  for ( int i = 0; i < level.count(); i++ )
662  {
663  QgsSymbolLevelItem &item = level[i];
664  if ( !features.contains( item.symbol() ) )
665  {
666  QgsDebugMsg( QStringLiteral( "level item's symbol not found!" ) );
667  continue;
668  }
669  int layer = item.layer();
670  QList<QgsFeature> &lst = features[item.symbol()];
671  QList<QgsFeature>::iterator fit;
672  for ( fit = lst.begin(); fit != lst.end(); ++fit )
673  {
674  if ( context.renderingStopped() )
675  {
676  stopRenderer( renderer, selRenderer );
677  return;
678  }
679 
680  bool sel = isMainRenderer && context.showSelection() && mSelectedFeatureIds.contains( fit->id() );
681  // maybe vertex markers should be drawn only during the last pass...
682  bool drawMarker = isMainRenderer && ( mDrawVertexMarkers && context.drawEditingInformation() && ( !mVertexMarkerOnlyForSelection || sel ) );
683 
684  context.expressionContext().setFeature( *fit );
685 
686  try
687  {
688  renderer->renderFeature( *fit, context, layer, sel, drawMarker );
689 
690  // as soon as first feature is rendered, we can start showing layer updates.
691  // but if we are blocking render updates (so that a previously cached image is being shown), we wait
692  // at most e.g. 3 seconds before we start forcing progressive updates.
693  if ( !mBlockRenderUpdates || mElapsedTimer.elapsed() > MAX_TIME_TO_USE_CACHED_PREVIEW_IMAGE )
694  {
695  mReadyToCompose = true;
696  }
697  }
698  catch ( const QgsCsException &cse )
699  {
700  Q_UNUSED( cse )
701  QgsDebugMsg( QStringLiteral( "Failed to transform a point while drawing a feature with ID '%1'. Ignoring this feature. %2" )
702  .arg( fet.id() ).arg( cse.what() ) );
703  }
704  }
705  }
706  }
707 
708  stopRenderer( renderer, selRenderer );
709 }
710 
711 void QgsVectorLayerRenderer::stopRenderer( QgsFeatureRenderer *renderer, QgsSingleSymbolRenderer *selRenderer )
712 {
713  QgsRenderContext &context = *renderContext();
714  renderer->stopRender( context );
715  if ( selRenderer )
716  {
717  selRenderer->stopRender( context );
718  delete selRenderer;
719  }
720 }
721 
722 void QgsVectorLayerRenderer::prepareLabeling( QgsVectorLayer *layer, QSet<QString> &attributeNames )
723 {
724  QgsRenderContext &context = *renderContext();
725  // TODO: add attributes for geometry generator
726  if ( QgsLabelingEngine *engine2 = context.labelingEngine() )
727  {
728  if ( layer->labelsEnabled() )
729  {
730  if ( context.labelSink() )
731  {
732  if ( const QgsRuleBasedLabeling *rbl = dynamic_cast<const QgsRuleBasedLabeling *>( layer->labeling() ) )
733  {
734  mLabelProvider = new QgsRuleBasedLabelSinkProvider( *rbl, layer, context.labelSink() );
735  }
736  else
737  {
738  QgsPalLayerSettings settings = layer->labeling()->settings();
739  mLabelProvider = new QgsLabelSinkProvider( layer, QString(), context.labelSink(), &settings );
740  }
741  }
742  else
743  {
744  mLabelProvider = layer->labeling()->provider( layer );
745  }
746  if ( mLabelProvider )
747  {
748  engine2->addProvider( mLabelProvider );
749  if ( !mLabelProvider->prepare( context, attributeNames ) )
750  {
751  engine2->removeProvider( mLabelProvider );
752  mLabelProvider = nullptr; // deleted by engine
753  }
754  }
755  }
756  }
757 
758 #if 0 // TODO: limit of labels, font not found
759  QgsPalLayerSettings &palyr = mContext.labelingEngine()->layer( mLayerID );
760 
761  // see if feature count limit is set for labeling
762  if ( palyr.limitNumLabels && palyr.maxNumLabels > 0 )
763  {
764  QgsFeatureIterator fit = getFeatures( QgsFeatureRequest()
765  .setFilterRect( mContext.extent() )
766  .setNoAttributes() );
767 
768  // total number of features that may be labeled
769  QgsFeature f;
770  int nFeatsToLabel = 0;
771  while ( fit.nextFeature( f ) )
772  {
773  nFeatsToLabel++;
774  }
775  palyr.mFeaturesToLabel = nFeatsToLabel;
776  }
777 
778  // notify user about any font substitution
779  if ( !palyr.mTextFontFound && !mLabelFontNotFoundNotified )
780  {
781  emit labelingFontNotFound( this, palyr.mTextFontFamily );
782  mLabelFontNotFoundNotified = true;
783  }
784 #endif
785 }
786 
787 void QgsVectorLayerRenderer::prepareDiagrams( QgsVectorLayer *layer, QSet<QString> &attributeNames )
788 {
789  QgsRenderContext &context = *renderContext();
790  if ( QgsLabelingEngine *engine2 = context.labelingEngine() )
791  {
792  if ( layer->diagramsEnabled() )
793  {
794  mDiagramProvider = new QgsVectorLayerDiagramProvider( layer );
795  // need to be added before calling prepare() - uses map settings from engine
796  engine2->addProvider( mDiagramProvider );
797  if ( !mDiagramProvider->prepare( context, attributeNames ) )
798  {
799  engine2->removeProvider( mDiagramProvider );
800  mDiagramProvider = nullptr; // deleted by engine
801  }
802  }
803  }
804 }
805 
@ SkipSymbolRendering
Disable symbol rendering while still drawing labels if enabled (since QGIS 3.24)
@ UseAdvancedEffects
Enable layer opacity and blending effects.
@ SemiTransparentCircle
Semi-transparent circle marker.
@ Cross
Cross marker.
virtual QgsPalLayerSettings settings(const QString &providerId=QString()) const =0
Gets associated label settings.
virtual QgsVectorLayerLabelProvider * provider(QgsVectorLayer *layer) const
Factory for label provider implementation.
Q_GADGET QgsUnitTypes::DistanceUnit mapUnits
Class for doing transforms between two map coordinate systems.
QgsCoordinateReferenceSystem sourceCrs() const
Returns the source coordinate reference system, which the transform will transform coordinates from.
void setBallparkTransformsAreAppropriate(bool appropriate)
Sets whether approximate "ballpark" results are appropriate for this coordinate transform.
bool isShortCircuited() const
Returns true if the transform short circuits because the source and destination are equivalent.
bool isValid() const
Returns true if the coordinate transform is valid, ie both the source and destination CRS have been s...
QgsPointXY transform(const QgsPointXY &point, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward) const SIP_THROW(QgsCsException)
Transform the point from the source CRS to the destination CRS.
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:66
QString what() const
Definition: qgsexception.h:48
Single scope for storing variables and functions for use within a QgsExpressionContext.
static QgsExpressionContextScope * updateSymbolScope(const QgsSymbol *symbol, QgsExpressionContextScope *symbolScope=nullptr)
Updates a symbol scope related to a QgsSymbol to an expression context.
static QgsExpressionContextScope * layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
QgsExpressionContextScope * popScope()
Removes the last scope from the expression context and return it.
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
void setFeedback(QgsFeedback *feedback)
Attach a feedback object that can be queried regularly by the expression engine to check if expressio...
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
Abstract interface for use by classes that filter the features or attributes of a layer.
virtual void filterFeatures(const QgsVectorLayer *layer, QgsFeatureRequest &featureRequest) const =0
Add additional filters to the feature request to further restrict the features returned by the reques...
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
void setInterruptionChecker(QgsFeedback *interruptionChecker)
Attach an object that can be queried regularly by the iterator to check if it must stopped.
bool isValid() const
Will return if this iterator is valid.
An interface for objects which generate feature renderers for vector layers.
virtual QgsFeatureRenderer * clone() const =0
Create a deep copy of this renderer.
virtual void modifyRequestExtent(QgsRectangle &extent, QgsRenderContext &context)
Allows for a renderer to modify the extent of a feature request prior to rendering.
virtual QString filter(const QgsFields &fields=QgsFields())
If a renderer does not require all the features this method may be overridden and return an expressio...
Definition: qgsrenderer.h:206
QgsPaintEffect * paintEffect() const
Returns the current paint effect for the renderer.
virtual QgsSymbolList symbols(QgsRenderContext &context) const
Returns list of symbols used by the renderer.
virtual void stopRender(QgsRenderContext &context)
Must be called when a render cycle has finished, to allow the renderer to clean up.
virtual QgsSymbol * symbolForFeature(const QgsFeature &feature, QgsRenderContext &context) const =0
To be overridden.
QString type() const
Definition: qgsrenderer.h:142
virtual bool usesEmbeddedSymbols() const
Returns true if the renderer uses embedded symbols for features.
double referenceScale() const
Returns the symbology reference scale.
Definition: qgsrenderer.h:466
bool usingSymbolLevels() const
Definition: qgsrenderer.h:292
virtual QString dump() const
Returns debug information about this renderer.
virtual QgsFeatureRenderer::Capabilities capabilities()
Returns details about internals of this renderer.
Definition: qgsrenderer.h:283
@ SymbolLevels
Rendering with symbol levels (i.e. implements symbols(), symbolForFeature())
Definition: qgsrenderer.h:263
bool orderByEnabled() const
Returns whether custom ordering will be applied before features are processed by this renderer.
virtual bool willRenderFeature(const QgsFeature &feature, QgsRenderContext &context) const
Returns whether the renderer will render a feature or not.
virtual void startRender(QgsRenderContext &context, const QgsFields &fields)
Must be called when a new render cycle is started.
Definition: qgsrenderer.cpp:96
virtual bool renderFeature(const QgsFeature &feature, QgsRenderContext &context, int layer=-1, bool selected=false, bool drawVertexMarker=false) SIP_THROW(QgsCsException)
Render a feature using this renderer in the given context.
void setVertexMarkerAppearance(Qgis::VertexMarkerType type, double size)
Sets type and size of editing vertex markers for subsequent rendering.
QgsFeatureRequest::OrderBy orderBy() const
Gets the order in which features shall be processed by this renderer.
virtual QgsSymbolList originalSymbolsForFeature(const QgsFeature &feature, QgsRenderContext &context) const
Equivalent of originalSymbolsForFeature() call extended to support renderers that may use more symbol...
This class wraps a request for features to a vector layer (or directly its vector data provider).
QgsFeatureRequest & setSimplifyMethod(const QgsSimplifyMethod &simplifyMethod)
Set a simplification method for geometries that will be fetched.
QgsFeatureRequest & combineFilterExpression(const QString &expression)
Modifies the existing filter expression to add an additional expression filter.
QgsFeatureRequest & setFlags(QgsFeatureRequest::Flags flags)
Sets flags that affect how features will be fetched.
Flags flags() const
Returns the flags which affect how features are fetched.
QgsFeatureRequest & setSubsetOfAttributes(const QgsAttributeList &attrs)
Set a subset of attributes that will be fetched.
void setFeedback(QgsFeedback *feedback)
Attach a feedback object that can be queried regularly by the iterator to check if it should be cance...
@ EmbeddedSymbols
Retrieve any embedded feature symbology (since QGIS 3.20)
QgsFeatureRequest & setExpressionContext(const QgsExpressionContext &context)
Sets the expression context used to evaluate filter expressions.
QgsFeatureRequest & setNoAttributes()
Set that no attributes will be fetched.
QgsFeatureRequest & setOrderBy(const OrderBy &orderBy)
Set a list of order by clauses.
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:56
QgsGeometry geometry
Definition: qgsfeature.h:67
bool hasGeometry() const
Returns true if the feature has an associated geometry.
Definition: qgsfeature.cpp:223
Q_GADGET QgsFeatureId id
Definition: qgsfeature.h:64
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition: qgsfeedback.h:45
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:125
const QgsAbstractGeometry * constGet() const SIP_HOLDGIL
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
QgsWkbTypes::GeometryType type
Definition: qgsgeometry.h:128
static QgsGeometryEngine * createGeometryEngine(const QgsAbstractGeometry *geometry)
Creates and returns a new geometry engine representing the specified geometry.
bool isEmpty() const
Returns true if the geometry is empty (eg a linestring with no vertices, or a collection with no geom...
QgsRectangle boundingBox() const
Returns the bounding box of the geometry.
Implements a derived label provider for use with QgsLabelSink.
Definition: qgslabelsink.h:75
The QgsLabelingEngine class provides map labeling functionality.
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...
static QgsGeometry calculateLabelIntersectionGeometry(const QList< QgsMapClippingRegion > &regions, const QgsRenderContext &context, bool &shouldClip)
Returns the geometry representing the intersection of clipping regions from context which should be u...
static QgsGeometry calculateFeatureIntersectionGeometry(const QList< QgsMapClippingRegion > &regions, const QgsRenderContext &context, bool &shouldClip)
Returns the geometry representing the intersection of clipping regions from context which should be u...
static QgsGeometry calculateFeatureRequestGeometry(const QList< QgsMapClippingRegion > &regions, const QgsRenderContext &context, bool &shouldFilter)
Returns the geometry representing the intersection of clipping regions from context.
Base class for utility classes that encapsulate information necessary for rendering of map layers.
bool mReadyToCompose
The flag must be set to false in renderer's constructor if wants to use the smarter map redraws funct...
static constexpr int MAX_TIME_TO_USE_CACHED_PREVIEW_IMAGE
Maximum time (in ms) to allow display of a previously cached preview image while rendering 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.
QPainter::CompositionMode blendMode() const
Returns the current blending mode for a layer.
double opacity
Definition: qgsmaplayer.h:82
Perform transforms between map coordinates and device coordinates.
Definition: qgsmaptopixel.h:39
double mapUnitsPerPixel() const
Returns the current map units per pixel.
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::MessageLevel::Warning, bool notifyUser=true)
Adds a message to the log instance (and creates it if necessary).
virtual void begin(QgsRenderContext &context)
Begins intercepting paint operations to a render context.
virtual void end(QgsRenderContext &context)
Ends interception of paint operations to a render context, and draws the result to the render context...
bool enabled() const
Returns whether the effect is enabled.
Contains settings for how a map layer will be labeled.
A class to represent a 2D point.
Definition: qgspointxy.h:59
double y
Definition: qgspointxy.h:63
Q_GADGET double x
Definition: qgspointxy.h:62
A rectangle specified with double values.
Definition: qgsrectangle.h:42
QString toString(int precision=16) const
Returns a string representation of form xmin,ymin : xmax,ymax Coordinates will be truncated to the sp...
double yMaximum() const SIP_HOLDGIL
Returns the y maximum value (top side of rectangle).
Definition: qgsrectangle.h:193
double xMaximum() const SIP_HOLDGIL
Returns the x maximum value (right side of rectangle).
Definition: qgsrectangle.h:183
double xMinimum() const SIP_HOLDGIL
Returns the x minimum value (left side of rectangle).
Definition: qgsrectangle.h:188
double yMinimum() const SIP_HOLDGIL
Returns the y minimum value (bottom side of rectangle).
Definition: qgsrectangle.h:198
bool isEmpty() const
Returns true if the rectangle is empty.
Definition: qgsrectangle.h:469
QgsRectangle intersect(const QgsRectangle &rect) const
Returns the intersection with the given rectangle.
Definition: qgsrectangle.h:333
bool isFinite() const
Returns true if the rectangle has finite boundaries.
Definition: qgsrectangle.h:559
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.
bool useAdvancedEffects() const
Returns true if advanced effects such as blend modes such be used.
bool hasRenderedFeatureHandlers() const
Returns true if the context has any rendered feature handlers.
QPainter * painter()
Returns the destination QPainter for the render operation.
QgsExpressionContext & expressionContext()
Gets the expression context.
QgsLabelSink * labelSink() const
Returns the associated label sink, or nullptr if not set.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
void setVectorSimplifyMethod(const QgsVectorSimplifyMethod &simplifyMethod)
Sets the simplification setting to use when rendering vector layers.
bool testFlag(Qgis::RenderContextFlag flag) const
Check whether a particular flag is enabled.
void setFeatureClipGeometry(const QgsGeometry &geometry)
Sets a geometry to use to clip features at render time.
const QgsFeatureFilterProvider * featureFilterProvider() const
Gets the filter feature provider used for additional filtering of rendered features.
QList< QgsRenderedFeatureHandlerInterface * > renderedFeatureHandlers() const
Returns the list of rendered feature handlers to use while rendering map layers.
void setSymbologyReferenceScale(double scale)
Sets the symbology reference scale.
bool showSelection() const
Returns true if vector selections should be shown in the rendered map.
QColor selectionColor() const
Returns the color to use when rendering selected features.
QgsLabelingEngine * labelingEngine() const
Gets access to new labeling engine (may be nullptr).
bool drawEditingInformation() const
Returns true if edit markers should be drawn during the render operation.
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...
const QgsVectorSimplifyMethod & vectorSimplifyMethod() const
Returns the simplification settings to use when rendering vector layers.
An interface for classes which provider custom handlers for features rendered as part of a map render...
Implements a derived label provider for rule based labels for use with QgsLabelSink.
Definition: qgslabelsink.h:95
Rule based labeling for a vector layer.
Scoped object for saving and restoring a QPainter object's state.
T value(const QString &dynamicKeyPart=QString()) const
Returns settings value.
T value(const QString &dynamicKeyPart=QString()) const
Returns settings value.
static const QgsSettingsEntryString settingsDigitizingMarkerStyle
Settings entry digitizing marker style.
static const QgsSettingsEntryDouble settingsDigitizingMarkerSizeMm
Settings entry digitizing marker size mm.
static const QgsSettingsEntryBool settingsDigitizingMarkerOnlyForSelected
Settings entry digitizing marker only for selected.
This class contains information about how to simplify geometries fetched from a QgsFeatureIterator.
void setTolerance(double tolerance)
Sets the tolerance of simplification in map units. Represents the maximum distance in map units betwe...
void setThreshold(float threshold)
Sets the simplification threshold in pixels. Represents the maximum distance in pixels between two co...
void setForceLocalOptimization(bool localOptimization)
Sets whether the simplification executes after fetch the geometries from provider,...
void setMethodType(MethodType methodType)
Sets the simplification type.
@ OptimizeForRendering
Simplify using the map2pixel data to optimize the rendering of geometries.
QgsSymbol * symbol() const
Returns the symbol which will be rendered for every feature.
void stopRender(QgsRenderContext &context) override
Must be called when a render cycle has finished, to allow the renderer to clean up.
void startRender(QgsRenderContext &context, const QgsFields &fields) override
Must be called when a new render cycle is started.
int renderingPass() const
Specifies the rendering pass in which this symbol layer should be rendered.
int layer() const
The layer of this symbol level.
QgsSymbol * symbol() const
The symbol of this symbol level.
Abstract base class for all rendered symbols.
Definition: qgssymbol.h:93
QgsSymbolLayer * symbolLayer(int layer)
Returns the symbol layer at the specified index.
Definition: qgssymbol.cpp:423
static QgsSymbol * defaultSymbol(QgsWkbTypes::GeometryType geomType)
Returns a new default symbol for the specified geometry type.
Definition: qgssymbol.cpp:371
void setColor(const QColor &color) const
Sets the color for the symbol.
Definition: qgssymbol.cpp:565
int symbolLayerCount() const
Returns the total number of symbol layers contained in the symbol.
Definition: qgssymbol.h:215
const QgsDateTimeRange & temporalRange() const
Returns the datetime range for the object.
bool isTemporal() const
Returns true if the object's temporal range is enabled, and the object will be filtered when renderin...
@ DistanceDegrees
Degrees, for planar geographic CRS distance measurements.
Definition: qgsunittypes.h:75
The QgsVectorLayerDiagramProvider class implements support for diagrams within the labeling engine.
virtual bool prepare(const QgsRenderContext &context, QSet< QString > &attributeNames)
Prepare for registration of features.
virtual void registerFeature(QgsFeature &feature, QgsRenderContext &context, const QgsGeometry &obstacleGeometry=QgsGeometry())
Register a feature for labeling as one or more QgsLabelFeature objects stored into mFeatures.
void setClipFeatureGeometry(const QgsGeometry &geometry)
Sets a geometry to use to clip features to when registering them as diagrams.
Partial snapshot of vector layer's state (only the members necessary for access to features)
virtual bool prepare(QgsRenderContext &context, QSet< QString > &attributeNames)
Prepare for registration of features.
static QgsGeometry getPointObstacleGeometry(QgsFeature &fet, QgsRenderContext &context, const QgsSymbolList &symbols)
Returns the geometry for a point feature which should be used as an obstacle for labels.
virtual QList< QgsLabelFeature * > registerFeature(const QgsFeature &feature, QgsRenderContext &context, const QgsGeometry &obstacleGeometry=QgsGeometry(), const QgsSymbol *symbol=nullptr)
Register a feature for labeling as one or more QgsLabelFeature objects stored into mLabels.
bool forceRasterRender() const override
Returns true if the renderer must be rendered to a raster paint device (e.g.
QgsVectorLayerRenderer(QgsVectorLayer *layer, QgsRenderContext &context)
~QgsVectorLayerRenderer() override
void setLayerRenderingTimeHint(int time) override
Sets approximate render time (in ms) for the layer to render.
bool render() override
Do the rendering (based on data stored in the class).
QgsFeedback * feedback() const override
Access to feedback object of the layer renderer (may be nullptr)
Encapsulates the context in which a QgsVectorLayer's temporal capabilities will be applied.
void setLayer(QgsVectorLayer *layer)
Sets the associated layer.
Represents a vector layer which manages a vector based data sets.
bool labelsEnabled() const
Returns whether the layer contains labels which are enabled and should be drawn.
Q_INVOKABLE QgsWkbTypes::GeometryType geometryType() const
Returns point, line or polygon.
QgsMapLayerTemporalProperties * temporalProperties() override
Returns the layer's temporal properties.
QPainter::CompositionMode featureBlendMode() const
Returns the current blending mode for features.
bool diagramsEnabled() const
Returns whether the layer contains diagrams which are enabled and should be drawn.
Q_INVOKABLE const QgsFeatureIds & selectedFeatureIds() const
Returns a list of the selected features IDs in this layer.
bool simplifyDrawingCanbeApplied(const QgsRenderContext &renderContext, QgsVectorSimplifyMethod::SimplifyHint simplifyHint) const
Returns whether the VectorLayer can apply the specified simplification hint.
const QgsAbstractVectorLayerLabeling * labeling() const
Access to const labeling configuration.
Q_INVOKABLE QgsVectorLayerEditBuffer * editBuffer()
Buffer with uncommitted editing operations. Only valid after editing has been turned on.
QList< const QgsFeatureRendererGenerator * > featureRendererGenerators() const
Returns a list of the feature renderer generators owned by the layer.
const QgsVectorSimplifyMethod & simplifyMethod() const
Returns the simplification settings for fast rendering of features.
QgsFeatureRenderer * renderer()
Returns the feature renderer used for rendering the features in the layer in 2D map views.
This class contains information how to simplify geometries fetched from a vector layer.
bool forceLocalOptimization() const
Gets where the simplification executes, after fetch the geometries from provider, or when supported,...
void setSimplifyHints(SimplifyHints simplifyHints)
Sets the simplification hints of the vector layer managed.
SimplifyHints simplifyHints() const
Gets the simplification hints of the vector layer managed.
void setTolerance(double tolerance)
Sets the tolerance of simplification in map units. Represents the maximum distance in map units betwe...
float threshold() const
Gets the simplification threshold of the vector layer managed.
@ GeometrySimplification
The geometries can be simplified using the current map2pixel context state.
@ FullSimplification
All simplification hints can be applied ( Geometry + AA-disabling )
@ NoSimplification
No simplification can be applied.
@ VectorLayer
Vector layer.
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition: qgis.h:2062
#define QgsDebugMsgLevel(str, level)
Definition: qgslogger.h:39
#define QgsDebugMsg(str)
Definition: qgslogger.h:38
QList< QgsSymbolLevel > QgsSymbolLevelOrder
Definition: qgsrenderer.h:88
QList< QgsSymbolLevelItem > QgsSymbolLevel
Definition: qgsrenderer.h:84
QList< QgsSymbol * > QgsSymbolList
Definition: qgsrenderer.h:44