QGIS API Documentation 3.27.0-Master (75dc696944)
qgsrendercontext.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsrendercontext.cpp
3 --------------------
4 begin : March 16, 2008
5 copyright : (C) 2008 by Marco Hugentobler
6 email : marco dot hugentobler at karto dot baug dot ethz dot ch
7 ***************************************************************************/
8
9/***************************************************************************
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 ***************************************************************************/
17
18
19#include "qgsrendercontext.h"
20
21#include "qgsmapsettings.h"
22#include "qgsexpression.h"
23#include "qgsvectorlayer.h"
25#include "qgslogger.h"
26#include "qgspoint.h"
27
28#define POINTS_TO_MM 2.83464567
29#define INCH_TO_MM 25.4
30
32 : mFlags( Qgis::RenderContextFlag::DrawEditingInfo | Qgis::RenderContextFlag::UseAdvancedEffects | Qgis::RenderContextFlag::DrawSelection | Qgis::RenderContextFlag::UseRenderingOptimization )
33{
35 // For RenderMetersInMapUnits support, when rendering in Degrees, the Ellipsoid must be set
36 // - for Previews/Icons the default Extent can be used
37 mDistanceArea.setEllipsoid( mDistanceArea.sourceCrs().ellipsoidAcronym() );
38}
39
41
44 , mFlags( rh.mFlags )
45 , mPainter( rh.mPainter )
46 , mMaskPainter( rh.mMaskPainter )
47 , mCoordTransform( rh.mCoordTransform )
48 , mDistanceArea( rh.mDistanceArea )
49 , mExtent( rh.mExtent )
50 , mOriginalMapExtent( rh.mOriginalMapExtent )
51 , mMapToPixel( rh.mMapToPixel )
52 , mRenderingStopped( rh.mRenderingStopped )
53 , mFeedback( rh.mFeedback )
54 , mScaleFactor( rh.mScaleFactor )
55 , mDpiTarget( rh.mDpiTarget )
56 , mRendererScale( rh.mRendererScale )
57 , mSymbologyReferenceScale( rh.mSymbologyReferenceScale )
58 , mLabelingEngine( rh.mLabelingEngine )
59 , mLabelSink( rh.mLabelSink )
60 , mSelectionColor( rh.mSelectionColor )
61 , mVectorSimplifyMethod( rh.mVectorSimplifyMethod )
62 , mExpressionContext( rh.mExpressionContext )
63 , mGeometry( rh.mGeometry )
64 , mFeatureFilterProvider( rh.mFeatureFilterProvider ? rh.mFeatureFilterProvider->clone() : nullptr )
65 , mSegmentationTolerance( rh.mSegmentationTolerance )
66 , mSegmentationToleranceType( rh.mSegmentationToleranceType )
67 , mTransformContext( rh.mTransformContext )
68 , mPathResolver( rh.mPathResolver )
69 , mTextRenderFormat( rh.mTextRenderFormat )
70 , mRenderedFeatureHandlers( rh.mRenderedFeatureHandlers )
71 , mHasRenderedFeatureHandlers( rh.mHasRenderedFeatureHandlers )
72 , mCustomRenderingFlags( rh.mCustomRenderingFlags )
73 , mDisabledSymbolLayers()
74 , mClippingRegions( rh.mClippingRegions )
75 , mFeatureClipGeometry( rh.mFeatureClipGeometry )
76 , mTextureOrigin( rh.mTextureOrigin )
77 , mZRange( rh.mZRange )
78 , mSize( rh.mSize )
79 , mDevicePixelRatio( rh.mDevicePixelRatio )
80 , mImageFormat( rh.mImageFormat )
81 , mRendererUsage( rh.mRendererUsage )
82 , mFrameRate( rh.mFrameRate )
83 , mCurrentFrame( rh.mCurrentFrame )
84 , mSymbolLayerClipPaths( rh.mSymbolLayerClipPaths )
85#ifdef QGISDEBUG
86 , mHasTransformContext( rh.mHasTransformContext )
87#endif
88{
89}
90
92{
93 mFlags = rh.mFlags;
94 mPainter = rh.mPainter;
95 mMaskPainter = rh.mMaskPainter;
96 mCoordTransform = rh.mCoordTransform;
97 mExtent = rh.mExtent;
98 mOriginalMapExtent = rh.mOriginalMapExtent;
99 mMapToPixel = rh.mMapToPixel;
100 mRenderingStopped = rh.mRenderingStopped;
101 mFeedback = rh.mFeedback;
102 mScaleFactor = rh.mScaleFactor;
103 mDpiTarget = rh.mDpiTarget;
104 mRendererScale = rh.mRendererScale;
105 mSymbologyReferenceScale = rh.mSymbologyReferenceScale;
106 mLabelingEngine = rh.mLabelingEngine;
107 mLabelSink = rh.mLabelSink;
108 mSelectionColor = rh.mSelectionColor;
109 mVectorSimplifyMethod = rh.mVectorSimplifyMethod;
110 mExpressionContext = rh.mExpressionContext;
111 mGeometry = rh.mGeometry;
112 mFeatureFilterProvider.reset( rh.mFeatureFilterProvider ? rh.mFeatureFilterProvider->clone() : nullptr );
113 mSegmentationTolerance = rh.mSegmentationTolerance;
114 mSegmentationToleranceType = rh.mSegmentationToleranceType;
115 mDistanceArea = rh.mDistanceArea;
116 mTransformContext = rh.mTransformContext;
117 mPathResolver = rh.mPathResolver;
118 mTextRenderFormat = rh.mTextRenderFormat;
119 mRenderedFeatureHandlers = rh.mRenderedFeatureHandlers;
120 mHasRenderedFeatureHandlers = rh.mHasRenderedFeatureHandlers;
121 mCustomRenderingFlags = rh.mCustomRenderingFlags;
122 mClippingRegions = rh.mClippingRegions;
123 mFeatureClipGeometry = rh.mFeatureClipGeometry;
124 mTextureOrigin = rh.mTextureOrigin;
125 mZRange = rh.mZRange;
126 mSize = rh.mSize;
127 mDevicePixelRatio = rh.mDevicePixelRatio;
128 mImageFormat = rh.mImageFormat;
130 mRendererUsage = rh.mRendererUsage;
131 mFrameRate = rh.mFrameRate;
132 mCurrentFrame = rh.mCurrentFrame;
133 mSymbolLayerClipPaths = rh.mSymbolLayerClipPaths;
134 if ( isTemporal() )
136#ifdef QGISDEBUG
137 mHasTransformContext = rh.mHasTransformContext;
138#endif
139
140 return *this;
141}
142
144{
145 QgsRenderContext context;
146 context.setPainter( painter );
147 if ( painter && painter->device() )
148 {
149 context.setScaleFactor( painter->device()->logicalDpiX() / 25.4 );
150 }
151 else
152 {
153 context.setScaleFactor( 3.465 ); //assume 88 dpi as standard value
154 }
155
156 if ( painter && painter->renderHints() & QPainter::Antialiasing )
158 if ( painter && painter->renderHints() & QPainter::SmoothPixmapTransform )
160 if ( painter && painter->renderHints() & QPainter::LosslessImageRendering )
162
163 return context;
164}
165
167{
168 if ( !painter )
169 painter = mPainter;
170
171 if ( !painter )
172 return;
173
174 painter->setRenderHint( QPainter::Antialiasing, mFlags & Qgis::RenderContextFlag::Antialiasing );
175 painter->setRenderHint( QPainter::LosslessImageRendering, mFlags & Qgis::RenderContextFlag::LosslessImageRendering );
176 painter->setRenderHint( QPainter::SmoothPixmapTransform, mFlags & Qgis::RenderContextFlag::HighQualityImageTransforms );
177}
178
180{
181#ifdef QGISDEBUG
182 if ( !mHasTransformContext )
183 QgsDebugMsgLevel( QStringLiteral( "No QgsCoordinateTransformContext context set for transform" ), 4 );
184#endif
185 return mTransformContext;
186}
187
189{
190 mTransformContext = context;
191#ifdef QGISDEBUG
192 mHasTransformContext = true;
193#endif
194}
195
197{
198 mFeedback = feedback;
199}
200
202{
203 return mFeedback;
204}
205
206void QgsRenderContext::setFlags( Qgis::RenderContextFlags flags )
207{
208 mFlags = flags;
209}
210
212{
213 if ( on )
214 mFlags |= flag;
215 else
216 mFlags &= ~( static_cast< int >( flag ) );
217}
218
219Qgis::RenderContextFlags QgsRenderContext::flags() const
220{
221 return mFlags;
222}
223
225{
226 return mFlags.testFlag( flag );
227}
228
230{
232 QgsRectangle extent = mapSettings.visibleExtent();
233 extent.grow( mapSettings.extentBuffer() );
234 ctx.setMapToPixel( mapSettings.mapToPixel() );
235 ctx.setExtent( extent );
236 ctx.setMapExtent( mapSettings.visibleExtent() );
242 ctx.setSelectionColor( mapSettings.selectionColor() );
254 ctx.setScaleFactor( mapSettings.outputDpi() / 25.4 ); // = pixels per mm
255 ctx.setDpiTarget( mapSettings.dpiTarget() >= 0.0 ? mapSettings.dpiTarget() : -1.0 );
256 ctx.setRendererScale( mapSettings.scale() );
257 ctx.setExpressionContext( mapSettings.expressionContext() );
260 ctx.mDistanceArea.setSourceCrs( mapSettings.destinationCrs(), mapSettings.transformContext() );
261 ctx.mDistanceArea.setEllipsoid( mapSettings.ellipsoid() );
262 ctx.setTransformContext( mapSettings.transformContext() );
263 ctx.setPathResolver( mapSettings.pathResolver() );
264 ctx.setTextRenderFormat( mapSettings.textRenderFormat() );
265 ctx.setVectorSimplifyMethod( mapSettings.simplifyMethod() );
266 ctx.mRenderedFeatureHandlers = mapSettings.renderedFeatureHandlers();
267 ctx.mHasRenderedFeatureHandlers = !mapSettings.renderedFeatureHandlers().isEmpty();
268 //this flag is only for stopping during the current rendering progress,
269 //so must be false at every new render operation
270 ctx.setRenderingStopped( false );
271 ctx.mCustomRenderingFlags = mapSettings.customRenderingFlags();
272 ctx.setIsTemporal( mapSettings.isTemporal() );
273 if ( ctx.isTemporal() )
274 ctx.setTemporalRange( mapSettings.temporalRange() );
275
276 ctx.setZRange( mapSettings.zRange() );
277 ctx.setOutputSize( mapSettings.outputSize() );
278 ctx.setDevicePixelRatio( mapSettings.devicePixelRatio() );
279 ctx.setImageFormat( mapSettings.outputImageFormat() );
280
281 ctx.mClippingRegions = mapSettings.clippingRegions();
282
283 ctx.mRendererUsage = mapSettings.rendererUsage();
284 ctx.mFrameRate = mapSettings.frameRate();
285 ctx.mCurrentFrame = mapSettings.currentFrame();
286
287 return ctx;
288}
289
291{
292 return mFlags.testFlag( Qgis::RenderContextFlag::ForceVectorOutput );
293}
294
296{
297 return mFlags.testFlag( Qgis::RenderContextFlag::UseAdvancedEffects );
298}
299
301{
303}
304
306{
307 return mFlags.testFlag( Qgis::RenderContextFlag::DrawEditingInfo );
308}
309
311{
312 return mFlags.testFlag( Qgis::RenderContextFlag::DrawSelection );
313}
314
316{
317 mCoordTransform = t;
318}
319
321{
323}
324
326{
328}
329
330void QgsRenderContext::setShowSelection( const bool showSelection )
331{
333}
334
336{
338}
339
341{
343}
344
346{
347 if ( ffp )
348 {
349 mFeatureFilterProvider.reset( ffp->clone() );
350 }
351 else
352 {
353 mFeatureFilterProvider.reset( nullptr );
354 }
355}
356
358{
359 return mFeatureFilterProvider.get();
360}
361
363{
364 double conversionFactor = 1.0;
365 bool isMapUnitHack = false;
366 switch ( unit )
367 {
369 conversionFactor = mScaleFactor;
370 break;
371
373 conversionFactor = mScaleFactor / POINTS_TO_MM;
374 break;
375
377 conversionFactor = mScaleFactor * INCH_TO_MM;
378 break;
379
381 {
382 if ( mMapToPixel.isValid() )
383 size = convertMetersToMapUnits( size );
385 // Fall through to RenderMapUnits with size in meters converted to size in MapUnits
387 }
389 {
390 if ( mMapToPixel.isValid() )
391 {
392 const double mup = scale.computeMapUnitsPerPixel( *this );
393 if ( mup > 0 )
394 {
395 conversionFactor = 1.0 / mup;
396 }
397 else
398 {
399 conversionFactor = 1.0;
400 }
401 }
402 else
403 {
404 // invalid map to pixel. A size in map units can't be calculated, so treat the size as points
405 // and clamp it to a reasonable range. It's the best we can do in this situation!
406 isMapUnitHack = true;
407 conversionFactor = mScaleFactor / POINTS_TO_MM;
408 }
409 break;
410 }
412 conversionFactor = 1.0;
413 break;
414
417 //no sensible value
418 conversionFactor = 1.0;
419 break;
420 }
421
422 double convertedSize = size * conversionFactor;
423
424 if ( unit == QgsUnitTypes::RenderMapUnits )
425 {
426 //check max/min size
427 if ( scale.minSizeMMEnabled )
428 convertedSize = std::max( convertedSize, scale.minSizeMM * mScaleFactor );
429 if ( scale.maxSizeMMEnabled )
430 convertedSize = std::min( convertedSize, scale.maxSizeMM * mScaleFactor );
431 }
432
433 if ( isMapUnitHack )
434 {
435 // since we are arbitrarily treating map units as mm, we need to clamp to an (arbitrary!) reasonable range.
436 convertedSize = std::clamp( convertedSize, 10.0, 100.0 );
437 }
438 else
439 {
440 const double symbologyReferenceScaleFactor = mSymbologyReferenceScale > 0 ? mSymbologyReferenceScale / mRendererScale : 1;
441 convertedSize *= symbologyReferenceScaleFactor;
442 }
443
445 {
446 // apply property based constraints in order to optimise symbol preview rendering
447 switch ( property )
448 {
450 break;
451
453 // excessively large shadow offset in symbol preview icons is undesirable -- it pushes the shadow outside of view
454 convertedSize = std::min( convertedSize, 100.0 );
455 break;
457 // excessively large blur in symbol preview icons is too slow to calculate
458 convertedSize = std::min<double>( convertedSize, 30 );
459 break;
461 // excessively large glow spread in symbol preview icons is too slow to calculate
462 convertedSize = std::min<double>( convertedSize, 50 );
463 break;
464 }
465 }
466
467 return convertedSize;
468}
469
471{
472 const double mup = mMapToPixel.mapUnitsPerPixel();
473
474 const double symbologyReferenceScaleFactor = mSymbologyReferenceScale > 0 ? mSymbologyReferenceScale / mRendererScale : 1;
475
476 switch ( unit )
477 {
479 {
480 size = convertMetersToMapUnits( size );
481 // Fall through to RenderMapUnits with values of meters converted to MapUnits
483 }
485 {
486 // check scale
487 double minSizeMU = std::numeric_limits<double>::lowest();
488 if ( scale.minSizeMMEnabled )
489 {
490 minSizeMU = scale.minSizeMM * mScaleFactor * mup;
491 }
492 if ( !qgsDoubleNear( scale.minScale, 0.0 ) )
493 {
494 minSizeMU = std::max( minSizeMU, size * ( mRendererScale / scale.minScale ) );
495 }
496 size = std::max( size, minSizeMU );
497
498 double maxSizeMU = std::numeric_limits<double>::max();
499 if ( scale.maxSizeMMEnabled )
500 {
501 maxSizeMU = scale.maxSizeMM * mScaleFactor * mup;
502 }
503 if ( !qgsDoubleNear( scale.maxScale, 0.0 ) )
504 {
505 maxSizeMU = std::min( maxSizeMU, size * ( mRendererScale / scale.maxScale ) );
506 }
507 size = std::min( size, maxSizeMU );
508
509 return size;
510 }
512 {
513 return size * mScaleFactor * mup / symbologyReferenceScaleFactor;
514 }
516 {
517 return size * mScaleFactor * mup / POINTS_TO_MM / symbologyReferenceScaleFactor;
518 }
520 {
521 return size * mScaleFactor * mup * INCH_TO_MM / symbologyReferenceScaleFactor;
522 }
524 {
525 return size * mup / symbologyReferenceScaleFactor;
526 }
527
530 //no sensible value
531 return 0.0;
532 }
533 return 0.0;
534}
535
536double QgsRenderContext::convertFromMapUnits( double sizeInMapUnits, QgsUnitTypes::RenderUnit outputUnit ) const
537{
538 const double mup = mMapToPixel.mapUnitsPerPixel();
539 const double symbologyReferenceScaleFactor = mSymbologyReferenceScale > 0 ? mSymbologyReferenceScale / mRendererScale : 1;
540
541 switch ( outputUnit )
542 {
544 {
545 return sizeInMapUnits / convertMetersToMapUnits( 1.0 );
546 }
548 {
549 return sizeInMapUnits;
550 }
552 {
553 return sizeInMapUnits / ( mScaleFactor * mup ) * symbologyReferenceScaleFactor;
554 }
556 {
557 return sizeInMapUnits / ( mScaleFactor * mup / POINTS_TO_MM ) * symbologyReferenceScaleFactor;
558 }
560 {
561 return sizeInMapUnits / ( mScaleFactor * mup * INCH_TO_MM ) * symbologyReferenceScaleFactor;
562 }
564 {
565 return sizeInMapUnits / mup * symbologyReferenceScaleFactor;
566 }
567
570 //no sensible value
571 return 0.0;
572 }
573 return 0.0;
574}
575
576double QgsRenderContext::convertMetersToMapUnits( double meters ) const
577{
578 switch ( mDistanceArea.sourceCrs().mapUnits() )
579 {
581 return meters;
583 {
584 if ( mExtent.isNull() )
585 {
586 // we don't have an extent to calculate exactly -- so just use a very rough approximation
588 }
589
590 QgsPointXY pointCenter = mExtent.center();
591 // The Extent is in the sourceCrs(), when different from destinationCrs()
592 // - the point must be transformed, since DistanceArea uses the destinationCrs()
593 // Note: the default QgsCoordinateTransform() : authid() will return an empty String
594 if ( !mCoordTransform.isShortCircuited() )
595 {
596 pointCenter = mCoordTransform.transform( pointCenter );
597 }
598
599 const int multiplier = meters < 0 ? -1 : 1;
600 return multiplier * mDistanceArea.measureLineProjected( pointCenter, std::fabs( meters ) );
601 }
611 }
612 return meters;
613}
614
615QList<QgsRenderedFeatureHandlerInterface *> QgsRenderContext::renderedFeatureHandlers() const
616{
617 return mRenderedFeatureHandlers;
618}
619
620QList<QgsMapClippingRegion> QgsRenderContext::clippingRegions() const
621{
622 return mClippingRegions;
623}
624
626{
627 return mFeatureClipGeometry;
628}
629
631{
632 mFeatureClipGeometry = geometry;
633}
634
636{
637 return mTextureOrigin;
638}
639
640void QgsRenderContext::setTextureOrigin( const QPointF &origin )
641{
642 mTextureOrigin = origin;
643}
644
646{
647 return mZRange;
648}
649
651{
652 mZRange = range;
653}
654
656{
657 return mSize;
658}
659
661{
662 mSize = size;
663}
664
666{
667 return mDevicePixelRatio;
668}
669
671{
672 mDevicePixelRatio = ratio;
673}
674
676{
677 return outputSize() * mDevicePixelRatio;
678}
679
681{
682 return mFrameRate;
683}
684
686{
687 mFrameRate = rate;
688}
689
691{
692 return mCurrentFrame;
693}
694
696{
697 mCurrentFrame = frame;
698}
699
700void QgsRenderContext::addSymbolLayerClipPath( const QgsSymbolLayer *symbolLayer, QPainterPath path )
701{
702 mSymbolLayerClipPaths[ symbolLayer ].append( path );
703}
704
705QList<QPainterPath> QgsRenderContext::symbolLayerClipPaths( const QgsSymbolLayer *symbolLayer ) const
706{
707 return mSymbolLayerClipPaths[ symbolLayer ];
708}
The Qgis class provides global constants for use throughout the application.
Definition: qgis.h:72
RenderSubcomponentProperty
Rendering subcomponent properties.
Definition: qgis.h:1396
@ Generic
Generic subcomponent property.
RenderContextFlag
Flags which affect rendering operations.
Definition: qgis.h:1350
@ DrawEditingInfo
Enable drawing of vertex markers for layers in editing mode.
@ RenderSymbolPreview
The render is for a symbol preview only and map based properties may not be available,...
@ DrawSymbolBounds
Draw bounds of symbols (for debugging/testing)
@ RenderPreviewJob
Render is a 'canvas preview' render, and shortcuts should be taken to ensure fast rendering.
@ RenderMapTile
Draw map such that there are no problems between adjacent tiles.
@ UseRenderingOptimization
Enable vector simplification and other rendering optimizations.
@ ForceVectorOutput
Vector graphics should not be cached and drawn as raster images.
@ RenderPartialOutput
Whether to make extra effort to update map image with partially rendered layers (better for interacti...
@ LosslessImageRendering
Render images losslessly whenever possible, instead of the default lossy jpeg rendering used for some...
@ DrawSelection
Whether vector selections should be shown in the rendered map.
@ Antialiasing
Use antialiasing while drawing.
@ SkipSymbolRendering
Disable symbol rendering while still drawing labels if enabled (since QGIS 3.24)
@ Render3DMap
Render is for a 3D map.
@ UseAdvancedEffects
Enable layer opacity and blending effects.
@ HighQualityImageTransforms
Enable high quality image transformations, which results in better appearance of scaled or rotated ra...
@ RenderBlocking
Render and load remote sources in the same thread to ensure rendering remote sources (svg and images)...
@ DrawEditingInfo
Enable drawing of vertex markers for layers in editing mode.
@ DrawSymbolBounds
Draw bounds of symbols (for debugging/testing)
@ RenderPreviewJob
Render is a 'canvas preview' render, and shortcuts should be taken to ensure fast rendering.
@ RenderMapTile
Draw map such that there are no problems between adjacent tiles.
@ UseRenderingOptimization
Enable vector simplification and other rendering optimizations.
@ ForceVectorOutput
Vector graphics should not be cached and drawn as raster images.
@ RenderPartialOutput
Whether to make extra effort to update map image with partially rendered layers (better for interacti...
@ LosslessImageRendering
Render images losslessly whenever possible, instead of the default lossy jpeg rendering used for some...
@ DrawSelection
Whether vector selections should be shown in the rendered map.
@ Antialiasing
Enable anti-aliasing for map rendering.
@ SkipSymbolRendering
Disable symbol rendering while still drawing labels if enabled (since QGIS 3.24)
@ Render3DMap
Render is for a 3D map.
@ UseAdvancedEffects
Enable layer opacity and blending effects.
@ HighQualityImageTransforms
Enable high quality image transformations, which results in better appearance of scaled or rotated ra...
@ RenderBlocking
Render and load remote sources in the same thread to ensure rendering remote sources (svg and images)...
QString ellipsoidAcronym() const
Returns the ellipsoid acronym for the ellipsoid used by the CRS.
Q_GADGET QgsUnitTypes::DistanceUnit mapUnits
Contains information about the context in which a coordinate transform is executed.
Class for doing transforms between two map coordinate systems.
bool isShortCircuited() const
Returns true if the transform short circuits because the source and destination are equivalent.
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.
QgsCoordinateReferenceSystem sourceCrs() const
Returns the source spatial reference system.
void setSourceCrs(const QgsCoordinateReferenceSystem &crs, const QgsCoordinateTransformContext &context)
Sets source spatial reference system crs.
double measureLineProjected(const QgsPointXY &p1, double distance=1, double azimuth=M_PI_2, QgsPointXY *projectedPoint=nullptr) const
Calculates the distance from one point with distance in meters and azimuth (direction) When the sourc...
bool setEllipsoid(const QString &ellipsoid)
Sets the ellipsoid by its acronym.
QgsRange which stores a range of double values.
Definition: qgsrange.h:203
Abstract interface for use by classes that filter the features or attributes of a layer.
virtual QgsFeatureFilterProvider * clone() const =0
Create a clone of the feature filter provider.
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
The QgsMapSettings class contains configuration for rendering of the map.
Qgis::RendererUsage rendererUsage() const
Returns the rendering usage.
double scale() const
Returns the calculated map scale.
double segmentationTolerance() const
Gets the segmentation tolerance applied when rendering curved geometries.
QgsDoubleRange zRange() const
Returns the range of z-values which will be visible in the map.
const QgsVectorSimplifyMethod & simplifyMethod() const
Returns the simplification settings to use when rendering vector layers.
QList< QgsRenderedFeatureHandlerInterface * > renderedFeatureHandlers() const
Returns the list of rendered feature handlers to use while rendering the map settings.
double dpiTarget() const
Returns the target DPI (dots per inch) to be taken into consideration when rendering.
long long currentFrame() const
Returns the current frame number of the map, for maps which are part of an animation.
const QgsMapToPixel & mapToPixel() const
float devicePixelRatio() const
Returns the device pixel ratio.
QSize outputSize() const
Returns the size of the resulting map image, in pixels.
QImage::Format outputImageFormat() const
format of internal QImage, default QImage::Format_ARGB32_Premultiplied
double extentBuffer() const
Returns the buffer in map units to use around the visible extent for rendering symbols whose correspo...
double frameRate() const
Returns the frame rate of the map (in frames per second), for maps which are part of an animation.
QColor selectionColor() const
Returns the color that is used for drawing of selected vector features.
QgsAbstractGeometry::SegmentationToleranceType segmentationToleranceType() const
Gets segmentation tolerance type (maximum angle or maximum difference between curve and approximation...
QgsRectangle visibleExtent() const
Returns the actual extent derived from requested extent that takes output image size into account.
QVariantMap customRenderingFlags() const
Returns any custom rendering flags.
QString ellipsoid() const
Returns ellipsoid's acronym.
Qgis::TextRenderFormat textRenderFormat() const
Returns the text render format, which dictates how text is rendered (e.g.
double outputDpi() const
Returns the DPI (dots per inch) used for conversion between real world units (e.g.
bool testFlag(Qgis::MapSettingsFlag flag) const
Check whether a particular flag is enabled.
QList< QgsMapClippingRegion > clippingRegions() const
Returns the list of clipping regions to apply to the map.
const QgsPathResolver & pathResolver() const
Returns the path resolver for conversion between relative and absolute paths during rendering operati...
QgsCoordinateReferenceSystem destinationCrs() const
Returns the destination coordinate reference system for the map render.
const QgsExpressionContext & expressionContext() const
Gets the expression context.
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context, which stores various information regarding which datum tran...
bool isValid() const
Returns true if the object is valid (i.e.
Definition: qgsmaptopixel.h:83
double mapUnitsPerPixel() const
Returns the current map units per pixel.
Struct for storing maximum and minimum scales for measurements in map units.
double computeMapUnitsPerPixel(const QgsRenderContext &c) const
Computes a map units per pixel scaling factor, respecting the minimum and maximum scales set for the ...
bool minSizeMMEnabled
Whether the minimum size in mm should be respected.
double maxScale
The maximum scale, or 0.0 if unset.
double minScale
The minimum scale, or 0.0 if unset.
double maxSizeMM
The maximum size in millimeters, or 0.0 if unset.
bool maxSizeMMEnabled
Whether the maximum size in mm should be respected.
double minSizeMM
The minimum size in millimeters, or 0.0 if unset.
A class to represent a 2D point.
Definition: qgspointxy.h:59
A rectangle specified with double values.
Definition: qgsrectangle.h:42
bool isNull() const
Test if the rectangle is null (all coordinates zero or after call to setMinimal()).
Definition: qgsrectangle.h:479
void grow(double delta)
Grows the rectangle in place by the specified amount.
Definition: qgsrectangle.h:296
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.
void setForceVectorOutput(bool force)
Sets whether rendering operations should use vector operations instead of any faster raster shortcuts...
void setMapExtent(const QgsRectangle &extent)
Sets the original extent of the map being rendered.
void setTextureOrigin(const QPointF &origin)
Sets the texture origin, which should be used as a brush transform when rendering using QBrush object...
void setRenderingStopped(bool stopped)
Sets whether the rendering operation has been stopped and any ongoing rendering should be canceled im...
void setCoordinateTransform(const QgsCoordinateTransform &t)
Sets the current coordinate transform for the context.
void setShowSelection(bool showSelection)
Sets whether vector selections should be shown in the rendered map.
void setDrawEditingInformation(bool b)
Sets whether edit markers should be drawn during the render operation.
bool useAdvancedEffects() const
Returns true if advanced effects such as blend modes such be used.
void setScaleFactor(double factor)
Sets the scaling factor for the render to convert painter units to physical sizes.
void setImageFormat(QImage::Format format)
Sets QImage format which should be used for QImages created during rendering.
void setSegmentationToleranceType(QgsAbstractGeometry::SegmentationToleranceType type)
Sets segmentation tolerance type (maximum angle or maximum difference between curve and approximation...
void setDevicePixelRatio(float ratio)
Sets the device pixel ratio.
double convertFromMapUnits(double sizeInMapUnits, QgsUnitTypes::RenderUnit outputUnit) const
Converts a size from map units to the specified units.
void setUseAdvancedEffects(bool enabled)
Used to enable or disable advanced effects such as blend modes.
void setCurrentFrame(long long frame)
Sets the current frame of the map, for maps which are part of an animation.
QPainter * painter()
Returns the destination QPainter for the render operation.
void setPainterFlagsUsingContext(QPainter *painter=nullptr) const
Sets relevant flags on a destination painter, using the flags and settings currently defined for the ...
double convertToPainterUnits(double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property=Qgis::RenderSubcomponentProperty::Generic) const
Converts a size from the specified units to painter units (pixels).
void setTextRenderFormat(Qgis::TextRenderFormat format)
Sets the text render format, which dictates how text is rendered (e.g.
void setVectorSimplifyMethod(const QgsVectorSimplifyMethod &simplifyMethod)
Sets the simplification setting to use when rendering vector layers.
QgsCoordinateTransformContext transformContext() const
Returns the context's coordinate transform context, which stores various information regarding which ...
QSize outputSize() const
Returns the size of the resulting rendered image, in pixels.
QgsGeometry featureClipGeometry() const
Returns the geometry to use to clip features at render time.
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.
bool forceVectorOutput() const
Returns true if rendering operations should use vector operations instead of any faster raster shortc...
long long currentFrame() const
Returns the current frame number of the map (in frames per second), for maps which are part of an ani...
void setDpiTarget(double dpi)
Sets the targeted dpi for rendering.
~QgsRenderContext() override
void setPathResolver(const QgsPathResolver &resolver)
Sets the path resolver for conversion between relative and absolute paths during rendering operations...
float devicePixelRatio() const
Returns the device pixel ratio.
void setFeedback(QgsFeedback *feedback)
Attach a feedback object that can be queried regularly during rendering to check if rendering should ...
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 setFlag(Qgis::RenderContextFlag flag, bool on=true)
Enable or disable a particular flag (other flags are not affected)
QList< QPainterPath > symbolLayerClipPaths(const QgsSymbolLayer *symbolLayer) const
Returns clip paths to be applied to the symbolLayer before rendering.
double frameRate() const
Returns the frame rate of the map, for maps which are part of an animation.
bool showSelection() const
Returns true if vector selections should be shown in the rendered map.
QList< QgsMapClippingRegion > clippingRegions() const
Returns the list of clipping regions to apply during the render.
void setFrameRate(double rate)
Sets the frame rate of the map (in frames per second), for maps which are part of an animation.
void setTransformContext(const QgsCoordinateTransformContext &context)
Sets the context's coordinate transform context, which stores various information regarding which dat...
void setFlags(Qgis::RenderContextFlags flags)
Set combination of flags that will be used for rendering.
void setExtent(const QgsRectangle &extent)
When rendering a map layer, calling this method sets the "clipping" extent for the layer (in the laye...
void setMapToPixel(const QgsMapToPixel &mtp)
Sets the context's map to pixel transform, which transforms between map coordinates and device coordi...
void setOutputSize(QSize size)
Sets the size of the resulting rendered image, in pixels.
QgsFeedback * feedback() const
Returns the feedback object that can be queried regularly during rendering to check if rendering shou...
QPointF textureOrigin() const
Returns the texture origin, which should be used as a brush transform when rendering using QBrush obj...
double convertToMapUnits(double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale()) const
Converts a size from the specified units to map units.
void setPainter(QPainter *p)
Sets the destination QPainter for the render operation.
QgsDoubleRange zRange() const
Returns the range of z-values which should be rendered.
QSize deviceOutputSize() const
Returns the device output size of the render.
static QgsRenderContext fromMapSettings(const QgsMapSettings &mapSettings)
create initialized QgsRenderContext instance from given QgsMapSettings
bool drawEditingInformation() const
Returns true if edit markers should be drawn during the render operation.
static QgsRenderContext fromQPainter(QPainter *painter)
Creates a default render context given a pixel based QPainter destination.
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
void setUseRenderingOptimization(bool enabled)
Sets whether the rendering optimization (geometry simplification) should be executed.
void setRendererScale(double scale)
Sets the renderer map scale.
void setZRange(const QgsDoubleRange &range)
Sets the range of z-values which should be rendered.
double convertMetersToMapUnits(double meters) const
Convert meter distances to active MapUnit values for QgsUnitTypes::RenderMetersInMapUnits.
Qgis::RenderContextFlags flags() const
Returns combination of flags used for rendering.
const QgsAbstractGeometry * geometry() const
Returns pointer to the unsegmentized geometry.
QgsRenderContext & operator=(const QgsRenderContext &rh)
bool useRenderingOptimization() const
Returns true if the rendering optimization (geometry simplification) can be executed.
void setSelectionColor(const QColor &color)
Sets the color to use when rendering selected features.
void addSymbolLayerClipPath(const QgsSymbolLayer *symbolLayer, QPainterPath path)
Add a clip path to be applied to the symbolLayer before rendering.
void setSegmentationTolerance(double tolerance)
Sets the segmentation tolerance applied when rendering curved geometries.
void setFeatureFilterProvider(const QgsFeatureFilterProvider *ffp)
Set a filter feature provider used for additional filtering of rendered features.
Base class for objects with an associated (optional) temporal range.
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...
void setIsTemporal(bool enabled)
Sets whether the temporal range is enabled (i.e.
void setTemporalRange(const QgsDateTimeRange &range)
Sets the temporal range for the object.
@ DistanceMeters
Meters.
Definition: qgsunittypes.h:69
@ DistanceDegrees
Degrees, for planar geographic CRS distance measurements.
Definition: qgsunittypes.h:75
@ DistanceKilometers
Kilometers.
Definition: qgsunittypes.h:70
@ DistanceMiles
Terrestrial miles.
Definition: qgsunittypes.h:74
@ DistanceUnknownUnit
Unknown distance unit.
Definition: qgsunittypes.h:78
@ DistanceMillimeters
Millimeters.
Definition: qgsunittypes.h:77
@ DistanceYards
Imperial yards.
Definition: qgsunittypes.h:73
@ DistanceFeet
Imperial feet.
Definition: qgsunittypes.h:71
@ DistanceNauticalMiles
Nautical miles.
Definition: qgsunittypes.h:72
@ DistanceCentimeters
Centimeters.
Definition: qgsunittypes.h:76
static Q_INVOKABLE double fromUnitToUnitFactor(QgsUnitTypes::DistanceUnit fromUnit, QgsUnitTypes::DistanceUnit toUnit)
Returns the conversion factor between the specified distance units.
RenderUnit
Rendering size units.
Definition: qgsunittypes.h:168
@ RenderUnknownUnit
Mixed or unknown units.
Definition: qgsunittypes.h:175
@ RenderMetersInMapUnits
Meters value as Map units.
Definition: qgsunittypes.h:176
@ RenderPercentage
Percentage of another measurement (e.g., canvas size, feature size)
Definition: qgsunittypes.h:172
@ RenderPoints
Points (e.g., for font sizes)
Definition: qgsunittypes.h:173
@ RenderPixels
Pixels.
Definition: qgsunittypes.h:171
@ RenderInches
Inches.
Definition: qgsunittypes.h:174
@ RenderMillimeters
Millimeters.
Definition: qgsunittypes.h:169
@ RenderMapUnits
Map units.
Definition: qgsunittypes.h:170
void setSimplifyHints(SimplifyHints simplifyHints)
Sets the simplification hints of the vector layer managed.
@ NoSimplification
No simplification can be applied.
#define FALLTHROUGH
Definition: qgis.h:2986
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition: qgis.h:2404
#define QgsDebugMsgLevel(str, level)
Definition: qgslogger.h:39
#define INCH_TO_MM
#define POINTS_TO_MM