QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
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"
23#include "qgslogger.h"
24#include "qgselevationmap.h"
25#include "qgsunittypes.h"
26#include "qgssymbollayer.h"
28
29#define POINTS_TO_MM 2.83464567
30#define INCH_TO_MM 25.4
31
33 : mFlags( Qgis::RenderContextFlag::DrawEditingInfo | Qgis::RenderContextFlag::UseAdvancedEffects | Qgis::RenderContextFlag::DrawSelection | Qgis::RenderContextFlag::UseRenderingOptimization )
34{
36 // For RenderMetersInMapUnits support, when rendering in Degrees, the Ellipsoid must be set
37 // - for Previews/Icons the default Extent can be used
38 mDistanceArea.setEllipsoid( mDistanceArea.sourceCrs().ellipsoidAcronym() );
39}
40
42
45 , mFlags( rh.mFlags )
46 , mPainter( rh.mPainter )
47 , mPreviewRenderPainter( rh.mPreviewRenderPainter )
48 , mMaskPainter( rh.mMaskPainter )
49
50 // TODO -- these were NOT being copied, but it's unclear if that was intentional or a bug??
51 , mMaskIdProvider( nullptr )
52 , mCurrentMaskId( -1 )
53
54 , mIsGuiPreview( rh.mIsGuiPreview )
55 , mCoordTransform( rh.mCoordTransform )
56 , mDistanceArea( rh.mDistanceArea )
57 , mExtent( rh.mExtent )
58 , mOriginalMapExtent( rh.mOriginalMapExtent )
59 , mMapToPixel( rh.mMapToPixel )
60 , mRenderingStopped( rh.mRenderingStopped )
61 , mFeedback( rh.mFeedback )
62 , mScaleFactor( rh.mScaleFactor )
63 , mDpiTarget( rh.mDpiTarget )
64 , mRendererScale( rh.mRendererScale )
65 , mSymbologyReferenceScale( rh.mSymbologyReferenceScale )
66 , mLabelingEngine( rh.mLabelingEngine )
67 , mLabelSink( rh.mLabelSink )
68 , mSelectionColor( rh.mSelectionColor )
69 , mVectorSimplifyMethod( rh.mVectorSimplifyMethod )
70 , mExpressionContext( rh.mExpressionContext )
71 , mGeometry( rh.mGeometry )
72 , mFeatureFilterProvider( rh.mFeatureFilterProvider ? rh.mFeatureFilterProvider->clone() : nullptr )
73 , mSegmentationTolerance( rh.mSegmentationTolerance )
74 , mSegmentationToleranceType( rh.mSegmentationToleranceType )
75 , mTransformContext( rh.mTransformContext )
76 , mPathResolver( rh.mPathResolver )
77 , mTextRenderFormat( rh.mTextRenderFormat )
78 , mRenderedFeatureHandlers( rh.mRenderedFeatureHandlers )
79 , mHasRenderedFeatureHandlers( rh.mHasRenderedFeatureHandlers )
80 , mCustomProperties( rh.mCustomProperties )
81 , mDisabledSymbolLayers()
82 , mClippingRegions( rh.mClippingRegions )
83 , mFeatureClipGeometry( rh.mFeatureClipGeometry )
84 , mTextureOrigin( rh.mTextureOrigin )
85 , mZRange( rh.mZRange )
86 , mSize( rh.mSize )
87 , mDevicePixelRatio( rh.mDevicePixelRatio )
88 , mImageFormat( rh.mImageFormat )
89 , mRendererUsage( rh.mRendererUsage )
90 , mFrameRate( rh.mFrameRate )
91 , mCurrentFrame( rh.mCurrentFrame )
92 , mSymbolLayerClippingGeometries( rh.mSymbolLayerClippingGeometries )
93 , mMaskRenderSettings( rh.mMaskRenderSettings )
94#ifdef QGISDEBUG
95 , mHasTransformContext( rh.mHasTransformContext )
96#endif
97 , mElevationMap( rh.mElevationMap )
98{
99}
100
102{
103 mFlags = rh.mFlags;
104 mPainter = rh.mPainter;
105 mPreviewRenderPainter = rh.mPreviewRenderPainter;
106 mMaskPainter = rh.mMaskPainter;
107 // TODO -- these were NOT being copied, but it's unclear if that was intentional or a bug??
108 // mMaskIdProvider
109 // mCurrentMaskId
110 mIsGuiPreview = rh.mIsGuiPreview;
111 mCoordTransform = rh.mCoordTransform;
112 mExtent = rh.mExtent;
113 mOriginalMapExtent = rh.mOriginalMapExtent;
114 mMapToPixel = rh.mMapToPixel;
115 mRenderingStopped = rh.mRenderingStopped;
116 mFeedback = rh.mFeedback;
117 mScaleFactor = rh.mScaleFactor;
118 mDpiTarget = rh.mDpiTarget;
119 mRendererScale = rh.mRendererScale;
120 mSymbologyReferenceScale = rh.mSymbologyReferenceScale;
121 mLabelingEngine = rh.mLabelingEngine;
122 mLabelSink = rh.mLabelSink;
123 mSelectionColor = rh.mSelectionColor;
124 mVectorSimplifyMethod = rh.mVectorSimplifyMethod;
125 mExpressionContext = rh.mExpressionContext;
126 mGeometry = rh.mGeometry;
127 mFeatureFilterProvider.reset( rh.mFeatureFilterProvider ? rh.mFeatureFilterProvider->clone() : nullptr );
128 mSegmentationTolerance = rh.mSegmentationTolerance;
129 mSegmentationToleranceType = rh.mSegmentationToleranceType;
130 mDistanceArea = rh.mDistanceArea;
131 mTransformContext = rh.mTransformContext;
132 mPathResolver = rh.mPathResolver;
133 mTextRenderFormat = rh.mTextRenderFormat;
134 mRenderedFeatureHandlers = rh.mRenderedFeatureHandlers;
135 mHasRenderedFeatureHandlers = rh.mHasRenderedFeatureHandlers;
136 mCustomProperties = rh.mCustomProperties;
137 mClippingRegions = rh.mClippingRegions;
138 mFeatureClipGeometry = rh.mFeatureClipGeometry;
139 mTextureOrigin = rh.mTextureOrigin;
140 mZRange = rh.mZRange;
141 mSize = rh.mSize;
142 mDevicePixelRatio = rh.mDevicePixelRatio;
143 mImageFormat = rh.mImageFormat;
145 mRendererUsage = rh.mRendererUsage;
146 mFrameRate = rh.mFrameRate;
147 mCurrentFrame = rh.mCurrentFrame;
148 mSymbolLayerClippingGeometries = rh.mSymbolLayerClippingGeometries;
149 mMaskRenderSettings = rh.mMaskRenderSettings;
150 if ( isTemporal() )
152#ifdef QGISDEBUG
153 mHasTransformContext = rh.mHasTransformContext;
154#endif
155 mElevationMap = rh.elevationMap();
156
157 return *this;
158}
159
161{
162 QgsRenderContext context;
163 context.setPainter( painter );
164 if ( painter && painter->device() )
165 {
166 context.setScaleFactor( painter->device()->physicalDpiX() / 25.4 );
167 }
168 else
169 {
170 context.setScaleFactor( 3.465 ); //assume 88 dpi as standard value
171 }
172
173 if ( painter && painter->renderHints() & QPainter::Antialiasing )
175 if ( painter && painter->renderHints() & QPainter::SmoothPixmapTransform )
177 if ( painter && painter->renderHints() & QPainter::LosslessImageRendering )
179
180 return context;
181}
182
184{
185 if ( !painter )
186 painter = mPainter;
187
188 if ( !painter )
189 return;
190
191 painter->setRenderHint( QPainter::Antialiasing, mFlags & Qgis::RenderContextFlag::Antialiasing );
192 painter->setRenderHint( QPainter::LosslessImageRendering, mFlags & Qgis::RenderContextFlag::LosslessImageRendering );
193 painter->setRenderHint( QPainter::SmoothPixmapTransform, mFlags & Qgis::RenderContextFlag::HighQualityImageTransforms );
194}
195
197{
198#ifdef QGISDEBUG
199 if ( !mHasTransformContext )
200 QgsDebugMsgLevel( QStringLiteral( "No QgsCoordinateTransformContext context set for transform" ), 4 );
201#endif
202 return mTransformContext;
203}
204
206{
207 mTransformContext = context;
208#ifdef QGISDEBUG
209 mHasTransformContext = true;
210#endif
211}
212
214{
215 mFeedback = feedback;
216}
217
219{
220 return mFeedback;
221}
222
224{
225 mFlags = flags;
226}
227
229{
230 if ( on )
231 mFlags |= flag;
232 else
233 mFlags &= ~( static_cast< int >( flag ) );
234}
235
237{
238 return mFlags;
239}
240
242{
243 return mFlags.testFlag( flag );
244}
245
247{
249 QgsRectangle extent = mapSettings.visibleExtent();
250 extent.grow( mapSettings.extentBuffer() );
251 ctx.setMapToPixel( mapSettings.mapToPixel() );
252 ctx.setExtent( extent );
253 ctx.setMapExtent( mapSettings.visibleExtent() );
259 ctx.setSelectionColor( mapSettings.selectionColor() );
273 ctx.setScaleFactor( mapSettings.outputDpi() / 25.4 ); // = pixels per mm
274 ctx.setDpiTarget( mapSettings.dpiTarget() >= 0.0 ? mapSettings.dpiTarget() : -1.0 );
275 ctx.setRendererScale( mapSettings.scale() );
276 ctx.setExpressionContext( mapSettings.expressionContext() );
279 ctx.mDistanceArea.setSourceCrs( mapSettings.destinationCrs(), mapSettings.transformContext() );
280 ctx.mDistanceArea.setEllipsoid( mapSettings.ellipsoid() );
281 ctx.setTransformContext( mapSettings.transformContext() );
282 ctx.setPathResolver( mapSettings.pathResolver() );
283 ctx.setTextRenderFormat( mapSettings.textRenderFormat() );
284 ctx.setVectorSimplifyMethod( mapSettings.simplifyMethod() );
285 ctx.mRenderedFeatureHandlers = mapSettings.renderedFeatureHandlers();
286 ctx.mHasRenderedFeatureHandlers = !mapSettings.renderedFeatureHandlers().isEmpty();
287 //this flag is only for stopping during the current rendering progress,
288 //so must be false at every new render operation
289 ctx.setRenderingStopped( false );
290 ctx.mCustomProperties = mapSettings.customRenderingFlags();
291 ctx.setIsTemporal( mapSettings.isTemporal() );
292 if ( ctx.isTemporal() )
293 ctx.setTemporalRange( mapSettings.temporalRange() );
294
295 ctx.setZRange( mapSettings.zRange() );
296 ctx.setOutputSize( mapSettings.outputSize() );
297 ctx.setDevicePixelRatio( mapSettings.devicePixelRatio() );
298 ctx.setImageFormat( mapSettings.outputImageFormat() );
299
300 ctx.mClippingRegions = mapSettings.clippingRegions();
301
302 ctx.setMaskSettings( mapSettings.maskSettings() );
303
304 ctx.mRendererUsage = mapSettings.rendererUsage();
305 ctx.mFrameRate = mapSettings.frameRate();
306 ctx.mCurrentFrame = mapSettings.currentFrame();
307
308 const QStringList layerIds = mapSettings.layerIds( true );
309 if ( !layerIds.empty() )
310 ctx.setCustomProperty( QStringLiteral( "visible_layer_ids" ), layerIds );
311
312 return ctx;
313}
314
316{
317 return mFlags.testFlag( Qgis::RenderContextFlag::ForceVectorOutput );
318}
319
321{
322 return mFlags.testFlag( Qgis::RenderContextFlag::UseAdvancedEffects );
323}
324
329
331{
332 return mFlags.testFlag( Qgis::RenderContextFlag::DrawEditingInfo );
333}
334
336{
337 return mFlags.testFlag( Qgis::RenderContextFlag::DrawSelection );
338}
339
341{
342 mCoordTransform = t;
343}
344
349
354
359
364
369
371{
372 if ( ffp )
373 {
374 mFeatureFilterProvider.reset( ffp->clone() );
375 }
376 else
377 {
378 mFeatureFilterProvider.reset( nullptr );
379 }
380}
381
383{
384 return mFeatureFilterProvider.get();
385}
386
388{
389 double conversionFactor = 1.0;
390 bool isMapUnitHack = false;
391 switch ( unit )
392 {
394 conversionFactor = mScaleFactor;
395 break;
396
398 conversionFactor = mScaleFactor / POINTS_TO_MM;
399 break;
400
402 conversionFactor = mScaleFactor * INCH_TO_MM;
403 break;
404
406 {
407 if ( mMapToPixel.isValid() )
408 size = convertMetersToMapUnits( size );
410 // Fall through to RenderMapUnits with size in meters converted to size in MapUnits
411 [[fallthrough]];
412 }
414 {
415 if ( mMapToPixel.isValid() )
416 {
417 const double mup = scale.computeMapUnitsPerPixel( *this );
418 if ( mup > 0 )
419 {
420 conversionFactor = 1.0 / mup;
421 }
422 else
423 {
424 conversionFactor = 1.0;
425 }
426 }
427 else
428 {
429 // invalid map to pixel. A size in map units can't be calculated, so treat the size as points
430 // and clamp it to a reasonable range. It's the best we can do in this situation!
431 isMapUnitHack = true;
432 conversionFactor = mScaleFactor / POINTS_TO_MM;
433 }
434 break;
435 }
437 conversionFactor = 1.0;
438 break;
439
442 //no sensible value
443 conversionFactor = 1.0;
444 break;
445 }
446
447 double convertedSize = size * conversionFactor;
448
449 if ( unit == Qgis::RenderUnit::MapUnits )
450 {
451 //check max/min size
452 if ( scale.minSizeMMEnabled )
453 convertedSize = std::max( convertedSize, scale.minSizeMM * mScaleFactor );
454 if ( scale.maxSizeMMEnabled )
455 convertedSize = std::min( convertedSize, scale.maxSizeMM * mScaleFactor );
456 }
457
458 if ( isMapUnitHack )
459 {
460 // since we are arbitrarily treating map units as mm, we need to clamp to an (arbitrary!) reasonable range.
461 convertedSize = std::clamp( convertedSize, 10.0, 100.0 );
462 }
463 else
464 {
465 const double symbologyReferenceScaleFactor = mSymbologyReferenceScale > 0 ? mSymbologyReferenceScale / mRendererScale : 1;
466 convertedSize *= symbologyReferenceScaleFactor;
467 }
468
470 {
471 // apply property based constraints in order to optimise symbol preview rendering
472 switch ( property )
473 {
475 break;
476
478 // excessively large shadow offset in symbol preview icons is undesirable -- it pushes the shadow outside of view
479 convertedSize = std::min( convertedSize, 100.0 );
480 break;
482 // excessively large blur in symbol preview icons is too slow to calculate
483 convertedSize = std::min<double>( convertedSize, 30 );
484 break;
486 // excessively large glow spread in symbol preview icons is too slow to calculate
487 convertedSize = std::min<double>( convertedSize, 50 );
488 break;
489 }
490 }
491
492 return convertedSize;
493}
494
496{
497 double conversionFactor = 1.0;
498 // NOLINTBEGIN(bugprone-branch-clone)
499 switch ( unit )
500 {
502 conversionFactor = 1 / mScaleFactor;
503 break;
504
506 conversionFactor = POINTS_TO_MM / mScaleFactor;
507 break;
508
510 conversionFactor = 1 / ( mScaleFactor * INCH_TO_MM );
511 break;
512
514 {
515 if ( mMapToPixel.isValid() )
516 size = 1 / convertMetersToMapUnits( size );
517 // Fall through to RenderMapUnits with size in meters converted to size in MapUnits
518 [[fallthrough]];
519 }
521 {
522 if ( mMapToPixel.isValid() )
523 {
524 const double mup = mapToPixel().mapUnitsPerPixel();;
525 if ( mup > 0 )
526 {
527 conversionFactor = mup / 1.0;
528 }
529 else
530 {
531 conversionFactor = 1.0;
532 }
533 }
534 else
535 {
536 // invalid map to pixel. A size in map units can't be calculated, so treat the size as points.
537 // It's the best we can do in this situation!
538 conversionFactor = POINTS_TO_MM / mScaleFactor;
539 }
540 break;
541 }
543 conversionFactor = 1.0;
544 break;
545
548 //no sensible value
549 conversionFactor = 1.0;
550 break;
551 }
552 // NOLINTEND(bugprone-branch-clone)
553
554 return size * conversionFactor;
555}
556
557double QgsRenderContext::convertToMapUnits( double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale ) const
558{
559 const double mup = mMapToPixel.mapUnitsPerPixel();
560
561 const double symbologyReferenceScaleFactor = mSymbologyReferenceScale > 0 ? mSymbologyReferenceScale / mRendererScale : 1;
562
563 switch ( unit )
564 {
566 {
567 size = convertMetersToMapUnits( size );
568 // Fall through to RenderMapUnits with values of meters converted to MapUnits
569 [[fallthrough]];
570 }
572 {
573 // check scale
574 double minSizeMU = std::numeric_limits<double>::lowest();
575 if ( scale.minSizeMMEnabled )
576 {
577 minSizeMU = scale.minSizeMM * mScaleFactor * mup;
578 }
579 if ( !qgsDoubleNear( scale.minScale, 0.0 ) )
580 {
581 minSizeMU = std::max( minSizeMU, size * ( mRendererScale / scale.minScale ) );
582 }
583 size = std::max( size, minSizeMU );
584
585 double maxSizeMU = std::numeric_limits<double>::max();
586 if ( scale.maxSizeMMEnabled )
587 {
588 maxSizeMU = scale.maxSizeMM * mScaleFactor * mup;
589 }
590 if ( !qgsDoubleNear( scale.maxScale, 0.0 ) )
591 {
592 maxSizeMU = std::min( maxSizeMU, size * ( mRendererScale / scale.maxScale ) );
593 }
594 size = std::min( size, maxSizeMU );
595
596 return size;
597 }
599 {
600 return size * mScaleFactor * mup / symbologyReferenceScaleFactor;
601 }
603 {
604 return size * mScaleFactor * mup / POINTS_TO_MM / symbologyReferenceScaleFactor;
605 }
607 {
608 return size * mScaleFactor * mup * INCH_TO_MM / symbologyReferenceScaleFactor;
609 }
611 {
612 return size * mup / symbologyReferenceScaleFactor;
613 }
614
617 //no sensible value
618 return 0.0;
619 }
620 return 0.0;
621}
622
623double QgsRenderContext::convertFromMapUnits( double sizeInMapUnits, Qgis::RenderUnit outputUnit ) const
624{
625 const double mup = mMapToPixel.mapUnitsPerPixel();
626 const double symbologyReferenceScaleFactor = mSymbologyReferenceScale > 0 ? mSymbologyReferenceScale / mRendererScale : 1;
627
628 switch ( outputUnit )
629 {
631 {
632 return sizeInMapUnits / convertMetersToMapUnits( 1.0 );
633 }
635 {
636 return sizeInMapUnits;
637 }
639 {
640 return sizeInMapUnits / ( mScaleFactor * mup ) * symbologyReferenceScaleFactor;
641 }
643 {
644 return sizeInMapUnits / ( mScaleFactor * mup / POINTS_TO_MM ) * symbologyReferenceScaleFactor;
645 }
647 {
648 return sizeInMapUnits / ( mScaleFactor * mup * INCH_TO_MM ) * symbologyReferenceScaleFactor;
649 }
651 {
652 return sizeInMapUnits / mup * symbologyReferenceScaleFactor;
653 }
654
657 //no sensible value
658 return 0.0;
659 }
660 return 0.0;
661}
662
663double QgsRenderContext::convertMetersToMapUnits( double meters ) const
664{
665 switch ( mDistanceArea.sourceCrs().mapUnits() )
666 {
668 return meters;
670 {
671 if ( mExtent.isNull() )
672 {
673 // we don't have an extent to calculate exactly -- so just use a very rough approximation
675 }
676
677 QgsPointXY pointCenter = mExtent.center();
678 // The Extent is in the sourceCrs(), when different from destinationCrs()
679 // - the point must be transformed, since DistanceArea uses the destinationCrs()
680 // Note: the default QgsCoordinateTransform() : authid() will return an empty String
681 if ( !mCoordTransform.isShortCircuited() )
682 {
683 try
684 {
685 pointCenter = mCoordTransform.transform( pointCenter );
686 }
687 catch ( const QgsCsException & )
688 {
689 QgsDebugError( QStringLiteral( "QgsRenderContext::convertMetersToMapUnits(): failed to reproject pointCenter" ) );
690 // what should we return;.. ?
691 return meters;
692 }
693 }
694
695 const int multiplier = meters < 0 ? -1 : 1;
696 return multiplier * mDistanceArea.measureLineProjected( pointCenter, std::fabs( meters ) );
697 }
747 }
748 return meters;
749}
750
751QList<QgsRenderedFeatureHandlerInterface *> QgsRenderContext::renderedFeatureHandlers() const
752{
753 return mRenderedFeatureHandlers;
754}
755
756QList<QgsMapClippingRegion> QgsRenderContext::clippingRegions() const
757{
758 return mClippingRegions;
759}
760
762{
763 return mFeatureClipGeometry;
764}
765
767{
768 mFeatureClipGeometry = geometry;
769}
770
772{
773 return mTextureOrigin;
774}
775
776void QgsRenderContext::setTextureOrigin( const QPointF &origin )
777{
778 mTextureOrigin = origin;
779}
780
782{
783 mMaskRenderSettings = settings;
784}
785
787{
788 return mZRange;
789}
790
792{
793 mZRange = range;
794}
795
797{
798 return mSize;
799}
800
802{
803 mSize = size;
804}
805
807{
808 return mDevicePixelRatio;
809}
810
812{
813 mDevicePixelRatio = ratio;
814}
815
817{
818 return outputSize() * mDevicePixelRatio;
819}
820
822{
823 return mFrameRate;
824}
825
827{
828 mFrameRate = rate;
829}
830
832{
833 return mCurrentFrame;
834}
835
837{
838 mCurrentFrame = frame;
839}
840
842{
843 return mElevationMap;
844}
845
847{
848 mElevationMap = map;
849}
850
851void QgsRenderContext::addSymbolLayerClipPath( const QString &symbolLayerId, QPainterPath path )
852{
854 if ( !geometry.isEmpty() )
855 addSymbolLayerClipGeometry( symbolLayerId, geometry );
856}
857
858QList<QPainterPath> QgsRenderContext::symbolLayerClipPaths( const QString &symbolLayerId ) const
859{
860 const QVector<QgsGeometry> geometries = symbolLayerClipGeometries( symbolLayerId );
861 QList<QPainterPath> res;
862 res.reserve( geometries.size() );
863 for ( const QgsGeometry &geometry : geometries )
864 {
865 res << geometry.constGet()->asQPainterPath();
866 }
867 return res;
868}
869
870void QgsRenderContext::addSymbolLayerClipGeometry( const QString &symbolLayerId, const QgsGeometry &geometry )
871{
872 if ( geometry.isMultipart() )
873 {
874 mSymbolLayerClippingGeometries[ symbolLayerId ].append( geometry.asGeometryCollection() );
875 }
876 else
877 {
878 mSymbolLayerClippingGeometries[ symbolLayerId ].append( geometry );
879 }
880}
881
882bool QgsRenderContext::symbolLayerHasClipGeometries( const QString &symbolLayerId ) const
883{
884 auto it = mSymbolLayerClippingGeometries.constFind( symbolLayerId );
885 if ( it == mSymbolLayerClippingGeometries.constEnd() )
886 return false;
887 return !it.value().isEmpty();
888}
889
890QVector<QgsGeometry> QgsRenderContext::symbolLayerClipGeometries( const QString &symbolLayerId ) const
891{
892 return mSymbolLayerClippingGeometries[ symbolLayerId ];
893}
894
895void QgsRenderContext::setDisabledSymbolLayers( const QSet<const QgsSymbolLayer *> &symbolLayers )
896{
897 mDisabledSymbolLayers.clear();
898 for ( const QgsSymbolLayer *symbolLayer : symbolLayers )
899 mDisabledSymbolLayers << symbolLayer->id();
900}
901
902void QgsRenderContext::setDisabledSymbolLayersV2( const QSet<QString> &symbolLayers )
903{
904 mDisabledSymbolLayers = symbolLayers;
905}
906
907QSet<const QgsSymbolLayer *> QgsRenderContext::disabledSymbolLayers() const
908{
909 return QSet<const QgsSymbolLayer *>();
910}
911
913{
914 return mDisabledSymbolLayers;
915}
916
918{
919 return !mDisabledSymbolLayers.contains( layer->id() );
920}
The Qgis class provides global constants for use throughout the application.
Definition qgis.h:54
RenderSubcomponentProperty
Rendering subcomponent properties.
Definition qgis.h:2822
@ Generic
Generic subcomponent property.
@ NoSimplification
No simplification can be applied.
@ YardsBritishSears1922Truncated
British yards (Sears 1922 truncated)
@ Feet
Imperial feet.
@ MilesUSSurvey
US Survey miles.
@ LinksBritishSears1922
British links (Sears 1922)
@ YardsBritishBenoit1895A
British yards (Benoit 1895 A)
@ LinksBritishBenoit1895A
British links (Benoit 1895 A)
@ Centimeters
Centimeters.
@ YardsIndian1975
Indian yards (1975)
@ FeetUSSurvey
US Survey feet.
@ Millimeters
Millimeters.
@ FeetBritishSears1922
British feet (Sears 1922)
@ YardsClarkes
Clarke's yards.
@ YardsIndian
Indian yards.
@ FeetBritishBenoit1895B
British feet (Benoit 1895 B)
@ Miles
Terrestrial miles.
@ LinksUSSurvey
US Survey links.
@ ChainsUSSurvey
US Survey chains.
@ FeetClarkes
Clarke's feet.
@ Unknown
Unknown distance unit.
@ Yards
Imperial yards.
@ FeetBritish1936
British feet (1936)
@ FeetIndian1962
Indian feet (1962)
@ YardsBritishSears1922
British yards (Sears 1922)
@ FeetIndian1937
Indian feet (1937)
@ YardsIndian1937
Indian yards (1937)
@ Degrees
Degrees, for planar geographic CRS distance measurements.
@ ChainsBritishBenoit1895B
British chains (Benoit 1895 B)
@ LinksBritishSears1922Truncated
British links (Sears 1922 truncated)
@ ChainsBritishBenoit1895A
British chains (Benoit 1895 A)
@ YardsBritishBenoit1895B
British yards (Benoit 1895 B)
@ FeetBritish1865
British feet (1865)
@ YardsIndian1962
Indian yards (1962)
@ FeetBritishSears1922Truncated
British feet (Sears 1922 truncated)
@ MetersGermanLegal
German legal meter.
@ LinksBritishBenoit1895B
British links (Benoit 1895 B)
@ ChainsInternational
International chains.
@ LinksInternational
International links.
@ ChainsBritishSears1922Truncated
British chains (Sears 1922 truncated)
@ FeetIndian
Indian (geodetic) feet.
@ NauticalMiles
Nautical miles.
@ ChainsClarkes
Clarke's chains.
@ LinksClarkes
Clarke's links.
@ ChainsBritishSears1922
British chains (Sears 1922)
@ Kilometers
Kilometers.
@ FeetIndian1975
Indian feet (1975)
@ FeetGoldCoast
Gold Coast feet.
@ FeetBritishBenoit1895A
British feet (Benoit 1895 A)
QFlags< RenderContextFlag > RenderContextFlags
Render context flags.
Definition qgis.h:2591
RenderUnit
Rendering size units.
Definition qgis.h:4839
@ Percentage
Percentage of another measurement (e.g., canvas size, feature size)
@ Millimeters
Millimeters.
@ Points
Points (e.g., for font sizes)
@ Unknown
Mixed or unknown units.
@ MapUnits
Map units.
@ MetersInMapUnits
Meters value as Map units.
RenderContextFlag
Flags which affect rendering operations.
Definition qgis.h:2566
@ 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.
@ RecordProfile
Enable run-time profiling while rendering.
@ 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...
@ AlwaysUseGlobalMasks
When applying clipping paths for selective masking, always use global ("entire map") paths,...
@ 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.
@ 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.
@ RecordProfile
Enable run-time profiling while rendering.
@ 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...
@ AlwaysUseGlobalMasks
When applying clipping paths for selective masking, always use global ("entire map") paths,...
@ 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.
@ 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)...
virtual bool isEmpty() const
Returns true if the geometry is empty.
virtual QPainterPath asQPainterPath() const =0
Returns the geometry represented as a QPainterPath.
QString ellipsoidAcronym() const
Returns the ellipsoid acronym for the ellipsoid used by the CRS.
Contains information about the context in which a coordinate transform is executed.
Class for doing transforms between two map coordinate systems.
QgsPointXY transform(const QgsPointXY &point, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward) const
Transform the point from the source CRS to the destination CRS.
bool isShortCircuited() const
Returns true if the transform short circuits because the source and destination are equivalent.
Custom exception class for Coordinate Reference System related exceptions.
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:231
Stores digital elevation model in a raster image which may get updated as a part of map layer renderi...
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:44
static QgsGeometry painterPathToGeometry(const QPainterPath &path)
Converts a painter path to a QgsGeometry.
A geometry is the spatial representation of a feature.
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.
QStringList layerIds(bool expandGroupLayers=false) const
Returns the list of layer IDs which will be rendered in the map.
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.
const QgsMaskRenderSettings & maskSettings() const
Returns a reference to the mask render settings, which control how masks are drawn and behave during ...
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.
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.
Contains settings regarding how masks are calculated and handled during a map render.
A class to represent a 2D point.
Definition qgspointxy.h:60
A rectangle specified with double values.
bool isNull() const
Test if the rectangle is null (holding no spatial information).
QgsPointXY center() const
Returns the center point of the rectangle.
void grow(double delta)
Grows the rectangle in place by the specified amount.
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...
bool symbolLayerHasClipGeometries(const QString &symbolLayerId) const
Returns true if the symbol layer with matching ID has any associated clip geometries.
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.
double convertToMapUnits(double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale()) const
Converts a size from the specified units to map units.
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.
double convertFromPainterUnits(double size, Qgis::RenderUnit unit) const
Converts a size from painter units (pixels) to the specified render unit.
void setSegmentationToleranceType(QgsAbstractGeometry::SegmentationToleranceType type)
Sets segmentation tolerance type (maximum angle or maximum difference between curve and approximation...
QSet< QString > disabledSymbolLayersV2() const
When rendering a map layer in a second pass (for selective masking), some symbol layers may be disabl...
void setDevicePixelRatio(float ratio)
Sets the device pixel ratio.
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.
double convertToPainterUnits(double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property=Qgis::RenderSubcomponentProperty::Generic) const
Converts a size from the specified units to painter units (pixels).
QPainter * painter()
Returns the destination QPainter for the render operation.
void setMaskSettings(const QgsMaskRenderSettings &settings)
Sets the mask render settings, which control how masks are drawn and behave during render operations.
void setPainterFlagsUsingContext(QPainter *painter=nullptr) const
Sets relevant flags on a destination painter, using the flags and settings currently defined for the ...
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.
double convertFromMapUnits(double sizeInMapUnits, Qgis::RenderUnit outputUnit) const
Converts a size from map units to the specified units.
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.
QgsElevationMap * elevationMap() const
Returns the destination elevation map for the render operation.
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...
Q_DECL_DEPRECATED void setDisabledSymbolLayers(const QSet< const QgsSymbolLayer * > &symbolLayers)
When rendering a map layer in a second pass (for selective masking), some symbol layers may be disabl...
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 ...
Q_DECL_DEPRECATED void addSymbolLayerClipPath(const QString &symbolLayerId, QPainterPath path)
Add a clip path to be applied to the symbolLayer before rendering.
void setFeatureClipGeometry(const QgsGeometry &geometry)
Sets a geometry to use to clip features at render time.
void setDisabledSymbolLayersV2(const QSet< QString > &symbolLayers)
When rendering a map layer in a second pass (for selective masking), some symbol layers may be disabl...
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)
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.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
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...
Q_DECL_DEPRECATED QSet< const QgsSymbolLayer * > disabledSymbolLayers() const
When rendering a map layer in a second pass (for selective masking), some symbol layers may be disabl...
void setOutputSize(QSize size)
Sets the size of the resulting rendered image, in pixels.
void setCustomProperty(const QString &property, const QVariant &value)
Sets a custom rendering property.
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...
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.
bool isSymbolLayerEnabled(const QgsSymbolLayer *layer) const
When rendering a map layer in a second pass (for selective masking), some symbol layers may be disabl...
QSize deviceOutputSize() const
Returns the device output size of the render.
QVector< QgsGeometry > symbolLayerClipGeometries(const QString &symbolLayerId) const
Returns clipping geometries to be applied to the symbolLayer before rendering.
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.
void addSymbolLayerClipGeometry(const QString &symbolLayerId, const QgsGeometry &geometry)
Add a clip geometry to be applied to the symbolLayer before rendering.
Qgis::RenderContextFlags flags() const
Returns combination of flags used for rendering.
Q_DECL_DEPRECATED QList< QPainterPath > symbolLayerClipPaths(const QString &symbolLayerId) const
Returns clip paths to be applied to the symbolLayer before rendering.
const QgsAbstractGeometry * geometry() const
Returns pointer to the unsegmentized geometry.
void setElevationMap(QgsElevationMap *map)
Sets the destination elevation map for the render operation.
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 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.
QString id() const
Returns symbol layer identifier This id is unique in the whole project.
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.
static Q_INVOKABLE double fromUnitToUnitFactor(Qgis::DistanceUnit fromUnit, Qgis::DistanceUnit toUnit)
Returns the conversion factor between the specified distance units.
void setSimplifyHints(Qgis::VectorRenderingSimplificationFlags simplifyHints)
Sets the simplification hints of the vector layer managed.
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition qgis.h:5917
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:39
#define QgsDebugError(str)
Definition qgslogger.h:38
#define INCH_TO_MM
#define POINTS_TO_MM