Branch data Line data Source code
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"
24 : : #include "qgsfeaturefilterprovider.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 : :
31 : 0 : QgsRenderContext::QgsRenderContext()
32 : 0 : : mFlags( DrawEditingInfo | UseAdvancedEffects | DrawSelection | UseRenderingOptimization )
33 : 0 : {
34 : 0 : mVectorSimplifyMethod.setSimplifyHints( QgsVectorSimplifyMethod::NoSimplification );
35 : : // For RenderMetersInMapUnits support, when rendering in Degrees, the Ellipsoid must be set
36 : : // - for Previews/Icons the default Extent can be used
37 : 0 : mDistanceArea.setEllipsoid( mDistanceArea.sourceCrs().ellipsoidAcronym() );
38 : 0 : }
39 : :
40 : 0 : QgsRenderContext::~QgsRenderContext() = default;
41 : :
42 : 0 : QgsRenderContext::QgsRenderContext( const QgsRenderContext &rh )
43 : 0 : : QgsTemporalRangeObject( rh )
44 : 0 : , mFlags( rh.mFlags )
45 : 0 : , mPainter( rh.mPainter )
46 : 0 : , mMaskPainter( rh.mMaskPainter )
47 : 0 : , mCoordTransform( rh.mCoordTransform )
48 : 0 : , mDistanceArea( rh.mDistanceArea )
49 : 0 : , mExtent( rh.mExtent )
50 : 0 : , mOriginalMapExtent( rh.mOriginalMapExtent )
51 : 0 : , mMapToPixel( rh.mMapToPixel )
52 : 0 : , mRenderingStopped( rh.mRenderingStopped )
53 : 0 : , mScaleFactor( rh.mScaleFactor )
54 : 0 : , mRendererScale( rh.mRendererScale )
55 : 0 : , mLabelingEngine( rh.mLabelingEngine )
56 : 0 : , mSelectionColor( rh.mSelectionColor )
57 : 0 : , mVectorSimplifyMethod( rh.mVectorSimplifyMethod )
58 : 0 : , mExpressionContext( rh.mExpressionContext )
59 : 0 : , mGeometry( rh.mGeometry )
60 : 0 : , mFeatureFilterProvider( rh.mFeatureFilterProvider ? rh.mFeatureFilterProvider->clone() : nullptr )
61 : 0 : , mSegmentationTolerance( rh.mSegmentationTolerance )
62 : 0 : , mSegmentationToleranceType( rh.mSegmentationToleranceType )
63 : 0 : , mTransformContext( rh.mTransformContext )
64 : 0 : , mPathResolver( rh.mPathResolver )
65 : 0 : , mTextRenderFormat( rh.mTextRenderFormat )
66 : 0 : , mRenderedFeatureHandlers( rh.mRenderedFeatureHandlers )
67 : 0 : , mHasRenderedFeatureHandlers( rh.mHasRenderedFeatureHandlers )
68 : 0 : , mCustomRenderingFlags( rh.mCustomRenderingFlags )
69 : 0 : , mDisabledSymbolLayers()
70 : 0 : , mClippingRegions( rh.mClippingRegions )
71 : 0 : , mFeatureClipGeometry( rh.mFeatureClipGeometry )
72 : 0 : , mTextureOrigin( rh.mTextureOrigin )
73 : 0 : , mZRange( rh.mZRange )
74 : : #ifdef QGISDEBUG
75 : : , mHasTransformContext( rh.mHasTransformContext )
76 : : #endif
77 : 0 : {
78 : 0 : }
79 : :
80 : 0 : QgsRenderContext &QgsRenderContext::operator=( const QgsRenderContext &rh )
81 : : {
82 : 0 : mFlags = rh.mFlags;
83 : 0 : mPainter = rh.mPainter;
84 : 0 : mMaskPainter = rh.mMaskPainter;
85 : 0 : mCoordTransform = rh.mCoordTransform;
86 : 0 : mExtent = rh.mExtent;
87 : 0 : mOriginalMapExtent = rh.mOriginalMapExtent;
88 : 0 : mMapToPixel = rh.mMapToPixel;
89 : 0 : mRenderingStopped = rh.mRenderingStopped;
90 : 0 : mScaleFactor = rh.mScaleFactor;
91 : 0 : mRendererScale = rh.mRendererScale;
92 : 0 : mLabelingEngine = rh.mLabelingEngine;
93 : 0 : mSelectionColor = rh.mSelectionColor;
94 : 0 : mVectorSimplifyMethod = rh.mVectorSimplifyMethod;
95 : 0 : mExpressionContext = rh.mExpressionContext;
96 : 0 : mGeometry = rh.mGeometry;
97 : 0 : mFeatureFilterProvider.reset( rh.mFeatureFilterProvider ? rh.mFeatureFilterProvider->clone() : nullptr );
98 : 0 : mSegmentationTolerance = rh.mSegmentationTolerance;
99 : 0 : mSegmentationToleranceType = rh.mSegmentationToleranceType;
100 : 0 : mDistanceArea = rh.mDistanceArea;
101 : 0 : mTransformContext = rh.mTransformContext;
102 : 0 : mPathResolver = rh.mPathResolver;
103 : 0 : mTextRenderFormat = rh.mTextRenderFormat;
104 : 0 : mRenderedFeatureHandlers = rh.mRenderedFeatureHandlers;
105 : 0 : mHasRenderedFeatureHandlers = rh.mHasRenderedFeatureHandlers;
106 : 0 : mCustomRenderingFlags = rh.mCustomRenderingFlags;
107 : 0 : mClippingRegions = rh.mClippingRegions;
108 : 0 : mFeatureClipGeometry = rh.mFeatureClipGeometry;
109 : 0 : mTextureOrigin = rh.mTextureOrigin;
110 : 0 : mZRange = rh.mZRange;
111 : 0 : setIsTemporal( rh.isTemporal() );
112 : 0 : if ( isTemporal() )
113 : 0 : setTemporalRange( rh.temporalRange() );
114 : : #ifdef QGISDEBUG
115 : : mHasTransformContext = rh.mHasTransformContext;
116 : : #endif
117 : :
118 : 0 : return *this;
119 : : }
120 : :
121 : 0 : QgsRenderContext QgsRenderContext::fromQPainter( QPainter *painter )
122 : : {
123 : 0 : QgsRenderContext context;
124 : 0 : context.setPainter( painter );
125 : 0 : if ( painter && painter->device() )
126 : : {
127 : 0 : context.setScaleFactor( painter->device()->logicalDpiX() / 25.4 );
128 : 0 : }
129 : : else
130 : : {
131 : 0 : context.setScaleFactor( 3.465 ); //assume 88 dpi as standard value
132 : : }
133 : :
134 : 0 : if ( painter && painter->renderHints() & QPainter::Antialiasing )
135 : 0 : context.setFlag( QgsRenderContext::Antialiasing, true );
136 : :
137 : : #if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
138 : 0 : if ( painter && painter->renderHints() & QPainter::LosslessImageRendering )
139 : 0 : context.setFlag( QgsRenderContext::LosslessImageRendering, true );
140 : : #endif
141 : :
142 : 0 : return context;
143 : 0 : }
144 : :
145 : 0 : void QgsRenderContext::setPainterFlagsUsingContext( QPainter *painter ) const
146 : : {
147 : 0 : if ( !painter )
148 : 0 : painter = mPainter;
149 : :
150 : 0 : if ( !painter )
151 : 0 : return;
152 : :
153 : 0 : painter->setRenderHint( QPainter::Antialiasing, mFlags & QgsRenderContext::Antialiasing );
154 : : #if QT_VERSION >= QT_VERSION_CHECK(5, 13, 0)
155 : 0 : painter->setRenderHint( QPainter::LosslessImageRendering, mFlags & QgsRenderContext::LosslessImageRendering );
156 : : #endif
157 : 0 : }
158 : :
159 : 0 : QgsCoordinateTransformContext QgsRenderContext::transformContext() const
160 : : {
161 : : #ifdef QGISDEBUG
162 : : if ( !mHasTransformContext )
163 : : QgsDebugMsgLevel( QStringLiteral( "No QgsCoordinateTransformContext context set for transform" ), 4 );
164 : : #endif
165 : 0 : return mTransformContext;
166 : : }
167 : :
168 : 0 : void QgsRenderContext::setTransformContext( const QgsCoordinateTransformContext &context )
169 : : {
170 : 0 : mTransformContext = context;
171 : : #ifdef QGISDEBUG
172 : : mHasTransformContext = true;
173 : : #endif
174 : 0 : }
175 : :
176 : 0 : void QgsRenderContext::setFlags( QgsRenderContext::Flags flags )
177 : : {
178 : 0 : mFlags = flags;
179 : 0 : }
180 : :
181 : 0 : void QgsRenderContext::setFlag( QgsRenderContext::Flag flag, bool on )
182 : : {
183 : 0 : if ( on )
184 : 0 : mFlags |= flag;
185 : : else
186 : 0 : mFlags &= ~flag;
187 : 0 : }
188 : :
189 : 0 : QgsRenderContext::Flags QgsRenderContext::flags() const
190 : : {
191 : 0 : return mFlags;
192 : : }
193 : :
194 : 0 : bool QgsRenderContext::testFlag( QgsRenderContext::Flag flag ) const
195 : : {
196 : 0 : return mFlags.testFlag( flag );
197 : : }
198 : :
199 : 0 : QgsRenderContext QgsRenderContext::fromMapSettings( const QgsMapSettings &mapSettings )
200 : : {
201 : 0 : QgsRenderContext ctx;
202 : 0 : QgsRectangle extent = mapSettings.visibleExtent();
203 : 0 : extent.grow( mapSettings.extentBuffer() );
204 : 0 : ctx.setMapToPixel( mapSettings.mapToPixel() );
205 : 0 : ctx.setExtent( extent );
206 : 0 : ctx.setMapExtent( mapSettings.visibleExtent() );
207 : 0 : ctx.setFlag( DrawEditingInfo, mapSettings.testFlag( QgsMapSettings::DrawEditingInfo ) );
208 : 0 : ctx.setFlag( ForceVectorOutput, mapSettings.testFlag( QgsMapSettings::ForceVectorOutput ) );
209 : 0 : ctx.setFlag( UseAdvancedEffects, mapSettings.testFlag( QgsMapSettings::UseAdvancedEffects ) );
210 : 0 : ctx.setFlag( UseRenderingOptimization, mapSettings.testFlag( QgsMapSettings::UseRenderingOptimization ) );
211 : 0 : ctx.setCoordinateTransform( QgsCoordinateTransform() );
212 : 0 : ctx.setSelectionColor( mapSettings.selectionColor() );
213 : 0 : ctx.setFlag( DrawSelection, mapSettings.testFlag( QgsMapSettings::DrawSelection ) );
214 : 0 : ctx.setFlag( DrawSymbolBounds, mapSettings.testFlag( QgsMapSettings::DrawSymbolBounds ) );
215 : 0 : ctx.setFlag( RenderMapTile, mapSettings.testFlag( QgsMapSettings::RenderMapTile ) );
216 : 0 : ctx.setFlag( Antialiasing, mapSettings.testFlag( QgsMapSettings::Antialiasing ) );
217 : 0 : ctx.setFlag( RenderPartialOutput, mapSettings.testFlag( QgsMapSettings::RenderPartialOutput ) );
218 : 0 : ctx.setFlag( RenderPreviewJob, mapSettings.testFlag( QgsMapSettings::RenderPreviewJob ) );
219 : 0 : ctx.setFlag( RenderBlocking, mapSettings.testFlag( QgsMapSettings::RenderBlocking ) );
220 : 0 : ctx.setFlag( LosslessImageRendering, mapSettings.testFlag( QgsMapSettings::LosslessImageRendering ) );
221 : 0 : ctx.setFlag( Render3DMap, mapSettings.testFlag( QgsMapSettings::Render3DMap ) );
222 : 0 : ctx.setScaleFactor( mapSettings.outputDpi() / 25.4 ); // = pixels per mm
223 : 0 : ctx.setRendererScale( mapSettings.scale() );
224 : 0 : ctx.setExpressionContext( mapSettings.expressionContext() );
225 : 0 : ctx.setSegmentationTolerance( mapSettings.segmentationTolerance() );
226 : 0 : ctx.setSegmentationToleranceType( mapSettings.segmentationToleranceType() );
227 : 0 : ctx.mDistanceArea.setSourceCrs( mapSettings.destinationCrs(), mapSettings.transformContext() );
228 : 0 : ctx.mDistanceArea.setEllipsoid( mapSettings.ellipsoid() );
229 : 0 : ctx.setTransformContext( mapSettings.transformContext() );
230 : 0 : ctx.setPathResolver( mapSettings.pathResolver() );
231 : 0 : ctx.setTextRenderFormat( mapSettings.textRenderFormat() );
232 : 0 : ctx.setVectorSimplifyMethod( mapSettings.simplifyMethod() );
233 : 0 : ctx.mRenderedFeatureHandlers = mapSettings.renderedFeatureHandlers();
234 : 0 : ctx.mHasRenderedFeatureHandlers = !mapSettings.renderedFeatureHandlers().isEmpty();
235 : : //this flag is only for stopping during the current rendering progress,
236 : : //so must be false at every new render operation
237 : 0 : ctx.setRenderingStopped( false );
238 : 0 : ctx.mCustomRenderingFlags = mapSettings.customRenderingFlags();
239 : 0 : ctx.setIsTemporal( mapSettings.isTemporal() );
240 : 0 : if ( ctx.isTemporal() )
241 : 0 : ctx.setTemporalRange( mapSettings.temporalRange() );
242 : :
243 : 0 : ctx.setZRange( mapSettings.zRange() );
244 : :
245 : 0 : ctx.mClippingRegions = mapSettings.clippingRegions();
246 : :
247 : 0 : return ctx;
248 : 0 : }
249 : :
250 : 0 : bool QgsRenderContext::forceVectorOutput() const
251 : : {
252 : 0 : return mFlags.testFlag( ForceVectorOutput );
253 : : }
254 : :
255 : 0 : bool QgsRenderContext::useAdvancedEffects() const
256 : : {
257 : 0 : return mFlags.testFlag( UseAdvancedEffects );
258 : : }
259 : :
260 : 0 : void QgsRenderContext::setUseAdvancedEffects( bool enabled )
261 : : {
262 : 0 : setFlag( UseAdvancedEffects, enabled );
263 : 0 : }
264 : :
265 : 0 : bool QgsRenderContext::drawEditingInformation() const
266 : : {
267 : 0 : return mFlags.testFlag( DrawEditingInfo );
268 : : }
269 : :
270 : 0 : bool QgsRenderContext::showSelection() const
271 : : {
272 : 0 : return mFlags.testFlag( DrawSelection );
273 : : }
274 : :
275 : 0 : void QgsRenderContext::setCoordinateTransform( const QgsCoordinateTransform &t )
276 : : {
277 : 0 : mCoordTransform = t;
278 : 0 : }
279 : :
280 : 0 : void QgsRenderContext::setDrawEditingInformation( bool b )
281 : : {
282 : 0 : setFlag( DrawEditingInfo, b );
283 : 0 : }
284 : :
285 : 0 : void QgsRenderContext::setForceVectorOutput( bool force )
286 : : {
287 : 0 : setFlag( ForceVectorOutput, force );
288 : 0 : }
289 : :
290 : 0 : void QgsRenderContext::setShowSelection( const bool showSelection )
291 : : {
292 : 0 : setFlag( DrawSelection, showSelection );
293 : 0 : }
294 : :
295 : 0 : bool QgsRenderContext::useRenderingOptimization() const
296 : : {
297 : 0 : return mFlags.testFlag( UseRenderingOptimization );
298 : : }
299 : :
300 : 0 : void QgsRenderContext::setUseRenderingOptimization( bool enabled )
301 : : {
302 : 0 : setFlag( UseRenderingOptimization, enabled );
303 : 0 : }
304 : :
305 : 0 : void QgsRenderContext::setFeatureFilterProvider( const QgsFeatureFilterProvider *ffp )
306 : : {
307 : 0 : if ( ffp )
308 : : {
309 : 0 : mFeatureFilterProvider.reset( ffp->clone() );
310 : 0 : }
311 : : else
312 : : {
313 : 0 : mFeatureFilterProvider.reset( nullptr );
314 : : }
315 : 0 : }
316 : :
317 : 0 : const QgsFeatureFilterProvider *QgsRenderContext::featureFilterProvider() const
318 : : {
319 : 0 : return mFeatureFilterProvider.get();
320 : : }
321 : :
322 : 0 : double QgsRenderContext::convertToPainterUnits( double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale ) const
323 : : {
324 : 0 : double conversionFactor = 1.0;
325 : 0 : switch ( unit )
326 : : {
327 : : case QgsUnitTypes::RenderMillimeters:
328 : 0 : conversionFactor = mScaleFactor;
329 : 0 : break;
330 : :
331 : : case QgsUnitTypes::RenderPoints:
332 : 0 : conversionFactor = mScaleFactor / POINTS_TO_MM;
333 : 0 : break;
334 : :
335 : : case QgsUnitTypes::RenderInches:
336 : 0 : conversionFactor = mScaleFactor * INCH_TO_MM;
337 : 0 : break;
338 : :
339 : : case QgsUnitTypes::RenderMetersInMapUnits:
340 : : {
341 : 0 : size = convertMetersToMapUnits( size );
342 : 0 : unit = QgsUnitTypes::RenderMapUnits;
343 : : // Fall through to RenderMapUnits with size in meters converted to size in MapUnits
344 : : FALLTHROUGH
345 : 0 : }
346 : : case QgsUnitTypes::RenderMapUnits:
347 : : {
348 : 0 : double mup = scale.computeMapUnitsPerPixel( *this );
349 : 0 : if ( mup > 0 )
350 : : {
351 : 0 : conversionFactor = 1.0 / mup;
352 : 0 : }
353 : : else
354 : : {
355 : 0 : conversionFactor = 1.0;
356 : : }
357 : 0 : break;
358 : : }
359 : : case QgsUnitTypes::RenderPixels:
360 : 0 : conversionFactor = 1.0;
361 : 0 : break;
362 : :
363 : : case QgsUnitTypes::RenderUnknownUnit:
364 : : case QgsUnitTypes::RenderPercentage:
365 : : //no sensible value
366 : 0 : conversionFactor = 1.0;
367 : 0 : break;
368 : : }
369 : :
370 : 0 : double convertedSize = size * conversionFactor;
371 : :
372 : 0 : if ( unit == QgsUnitTypes::RenderMapUnits )
373 : : {
374 : : //check max/min size
375 : 0 : if ( scale.minSizeMMEnabled )
376 : 0 : convertedSize = std::max( convertedSize, scale.minSizeMM * mScaleFactor );
377 : 0 : if ( scale.maxSizeMMEnabled )
378 : 0 : convertedSize = std::min( convertedSize, scale.maxSizeMM * mScaleFactor );
379 : 0 : }
380 : :
381 : 0 : return convertedSize;
382 : : }
383 : :
384 : 0 : double QgsRenderContext::convertToMapUnits( double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale ) const
385 : : {
386 : 0 : double mup = mMapToPixel.mapUnitsPerPixel();
387 : :
388 : 0 : switch ( unit )
389 : : {
390 : : case QgsUnitTypes::RenderMetersInMapUnits:
391 : : {
392 : 0 : size = convertMetersToMapUnits( size );
393 : : // Fall through to RenderMapUnits with values of meters converted to MapUnits
394 : : FALLTHROUGH
395 : 0 : }
396 : : case QgsUnitTypes::RenderMapUnits:
397 : : {
398 : : // check scale
399 : 0 : double minSizeMU = std::numeric_limits<double>::lowest();
400 : 0 : if ( scale.minSizeMMEnabled )
401 : : {
402 : 0 : minSizeMU = scale.minSizeMM * mScaleFactor * mup;
403 : 0 : }
404 : 0 : if ( !qgsDoubleNear( scale.minScale, 0.0 ) )
405 : : {
406 : 0 : minSizeMU = std::max( minSizeMU, size * ( mRendererScale / scale.minScale ) );
407 : 0 : }
408 : 0 : size = std::max( size, minSizeMU );
409 : :
410 : 0 : double maxSizeMU = std::numeric_limits<double>::max();
411 : 0 : if ( scale.maxSizeMMEnabled )
412 : : {
413 : 0 : maxSizeMU = scale.maxSizeMM * mScaleFactor * mup;
414 : 0 : }
415 : 0 : if ( !qgsDoubleNear( scale.maxScale, 0.0 ) )
416 : : {
417 : 0 : maxSizeMU = std::min( maxSizeMU, size * ( mRendererScale / scale.maxScale ) );
418 : 0 : }
419 : 0 : size = std::min( size, maxSizeMU );
420 : :
421 : 0 : return size;
422 : : }
423 : : case QgsUnitTypes::RenderMillimeters:
424 : : {
425 : 0 : return size * mScaleFactor * mup;
426 : : }
427 : : case QgsUnitTypes::RenderPoints:
428 : : {
429 : 0 : return size * mScaleFactor * mup / POINTS_TO_MM;
430 : : }
431 : : case QgsUnitTypes::RenderInches:
432 : : {
433 : 0 : return size * mScaleFactor * mup * INCH_TO_MM;
434 : : }
435 : : case QgsUnitTypes::RenderPixels:
436 : : {
437 : 0 : return size * mup;
438 : : }
439 : :
440 : : case QgsUnitTypes::RenderUnknownUnit:
441 : : case QgsUnitTypes::RenderPercentage:
442 : : //no sensible value
443 : 0 : return 0.0;
444 : : }
445 : 0 : return 0.0;
446 : 0 : }
447 : :
448 : 0 : double QgsRenderContext::convertFromMapUnits( double sizeInMapUnits, QgsUnitTypes::RenderUnit outputUnit ) const
449 : : {
450 : 0 : double mup = mMapToPixel.mapUnitsPerPixel();
451 : :
452 : 0 : switch ( outputUnit )
453 : : {
454 : : case QgsUnitTypes::RenderMetersInMapUnits:
455 : : {
456 : 0 : return sizeInMapUnits / convertMetersToMapUnits( 1.0 );
457 : : }
458 : : case QgsUnitTypes::RenderMapUnits:
459 : : {
460 : 0 : return sizeInMapUnits;
461 : : }
462 : : case QgsUnitTypes::RenderMillimeters:
463 : : {
464 : 0 : return sizeInMapUnits / ( mScaleFactor * mup );
465 : : }
466 : : case QgsUnitTypes::RenderPoints:
467 : : {
468 : 0 : return sizeInMapUnits / ( mScaleFactor * mup / POINTS_TO_MM );
469 : : }
470 : : case QgsUnitTypes::RenderInches:
471 : : {
472 : 0 : return sizeInMapUnits / ( mScaleFactor * mup * INCH_TO_MM );
473 : : }
474 : : case QgsUnitTypes::RenderPixels:
475 : : {
476 : 0 : return sizeInMapUnits / mup;
477 : : }
478 : :
479 : : case QgsUnitTypes::RenderUnknownUnit:
480 : : case QgsUnitTypes::RenderPercentage:
481 : : //no sensible value
482 : 0 : return 0.0;
483 : : }
484 : 0 : return 0.0;
485 : 0 : }
486 : :
487 : 0 : double QgsRenderContext::convertMetersToMapUnits( double meters ) const
488 : : {
489 : 0 : switch ( mDistanceArea.sourceCrs().mapUnits() )
490 : : {
491 : : case QgsUnitTypes::DistanceMeters:
492 : 0 : return meters;
493 : : case QgsUnitTypes::DistanceDegrees:
494 : : {
495 : 0 : if ( mExtent.isNull() )
496 : : {
497 : : // we don't have an extent to calculate exactly -- so just use a very rough approximation
498 : 0 : return meters * QgsUnitTypes::fromUnitToUnitFactor( QgsUnitTypes::DistanceMeters, QgsUnitTypes::DistanceDegrees );
499 : : }
500 : :
501 : 0 : QgsPointXY pointCenter = mExtent.center();
502 : : // The Extent is in the sourceCrs(), when different from destinationCrs()
503 : : // - the point must be transformed, since DistanceArea uses the destinationCrs()
504 : : // Note: the default QgsCoordinateTransform() : authid() will return an empty String
505 : 0 : if ( !mCoordTransform.isShortCircuited() )
506 : : {
507 : 0 : pointCenter = mCoordTransform.transform( pointCenter );
508 : 0 : }
509 : 0 : return mDistanceArea.measureLineProjected( pointCenter, meters );
510 : : }
511 : : case QgsUnitTypes::DistanceKilometers:
512 : : case QgsUnitTypes::DistanceFeet:
513 : : case QgsUnitTypes::DistanceNauticalMiles:
514 : : case QgsUnitTypes::DistanceYards:
515 : : case QgsUnitTypes::DistanceMiles:
516 : : case QgsUnitTypes::DistanceCentimeters:
517 : : case QgsUnitTypes::DistanceMillimeters:
518 : : case QgsUnitTypes::DistanceUnknownUnit:
519 : 0 : return ( meters * QgsUnitTypes::fromUnitToUnitFactor( QgsUnitTypes::DistanceMeters, mDistanceArea.sourceCrs().mapUnits() ) );
520 : : }
521 : 0 : return meters;
522 : 0 : }
523 : :
524 : 0 : QList<QgsRenderedFeatureHandlerInterface *> QgsRenderContext::renderedFeatureHandlers() const
525 : : {
526 : 0 : return mRenderedFeatureHandlers;
527 : : }
528 : :
529 : 0 : QList<QgsMapClippingRegion> QgsRenderContext::clippingRegions() const
530 : : {
531 : 0 : return mClippingRegions;
532 : : }
533 : :
534 : 0 : QgsGeometry QgsRenderContext::featureClipGeometry() const
535 : : {
536 : 0 : return mFeatureClipGeometry;
537 : : }
538 : :
539 : 0 : void QgsRenderContext::setFeatureClipGeometry( const QgsGeometry &geometry )
540 : : {
541 : 0 : mFeatureClipGeometry = geometry;
542 : 0 : }
543 : :
544 : 0 : QPointF QgsRenderContext::textureOrigin() const
545 : : {
546 : 0 : return mTextureOrigin;
547 : : }
548 : :
549 : 0 : void QgsRenderContext::setTextureOrigin( const QPointF &origin )
550 : : {
551 : 0 : mTextureOrigin = origin;
552 : 0 : }
553 : :
554 : 0 : QgsDoubleRange QgsRenderContext::zRange() const
555 : : {
556 : 0 : return mZRange;
557 : : }
558 : :
559 : 0 : void QgsRenderContext::setZRange( const QgsDoubleRange &range )
560 : : {
561 : 0 : mZRange = range;
562 : 0 : }
563 : :
564 : :
|
