QGIS API Documentation 3.41.0-Master (d5b93354e9c)
Loading...
Searching...
No Matches
qgsmapsettings.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsmapsettings.cpp
3 --------------------------------------
4 Date : December 2013
5 Copyright : (C) 2013 by Martin Dobias
6 Email : wonder dot sk at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
16#include "qgsmapsettings.h"
17
18#include "qgsscalecalculator.h"
19#include "qgsmaptopixel.h"
20#include "qgslogger.h"
21
22#include "qgsmessagelog.h"
23#include "qgsmaplayer.h"
25#include "qgsxmlutils.h"
26#include "qgsexception.h"
27#include "qgsgeometry.h"
28#include "qgsgrouplayer.h"
30#include "qgsellipsoidutils.h"
31#include "qgsunittypes.h"
32#include "qgspainting.h"
33
35 : mDpi( QgsPainting::qtDefaultDpiX() ) // DPI that will be used by default for QImage instances
36 , mSize( QSize( 0, 0 ) )
37 , mBackgroundColor( Qt::white )
38 , mSelectionColor( Qt::yellow )
39 , mFlags( Qgis::MapSettingsFlag::Antialiasing | Qgis::MapSettingsFlag::UseAdvancedEffects | Qgis::MapSettingsFlag::DrawLabeling | Qgis::MapSettingsFlag::DrawSelection )
40 , mSegmentationTolerance( M_PI_2 / 90 )
41{
44
46}
47
48void QgsMapSettings::setMagnificationFactor( double factor, const QgsPointXY *center )
49{
50 const double ratio = mMagnificationFactor / factor;
51
52 mMagnificationFactor = factor;
53
54 const double rot = rotation();
55 setRotation( 0.0 );
56
58 ext.scale( ratio, center );
59
60 mRotation = rot;
61 mExtent = ext;
62 mDpi = mDpi / ratio;
63
64 QgsDebugMsgLevel( QStringLiteral( "Magnification factor: %1 dpi: %2 ratio: %3" ).arg( factor ).arg( mDpi ).arg( ratio ), 3 );
65
67}
68
73
75{
76 return mExtent;
77}
78
79void QgsMapSettings::setExtent( const QgsRectangle &extent, bool magnified )
80{
81 QgsRectangle magnifiedExtent = extent;
82
83 if ( !magnified )
84 magnifiedExtent.scale( 1 / mMagnificationFactor );
85
86 mExtent = magnifiedExtent;
87
89}
90
92{
93 return mExtentBuffer;
94}
95
96void QgsMapSettings::setExtentBuffer( const double buffer )
97{
98 mExtentBuffer = buffer;
99}
100
102{
103 return mRotation;
104}
105
106void QgsMapSettings::setRotation( double degrees )
107{
108 if ( qgsDoubleNear( mRotation, degrees ) )
109 return;
110
111 mRotation = degrees;
112
113 // TODO: update extent while keeping scale ?
115}
116
117
119{
121
122 if ( extent.isEmpty() || !extent.isFinite() )
123 {
124 mValid = false;
125 return;
126 }
127
128 // Don't allow zooms where the current extent is so small that it
129 // can't be accurately represented using a double (which is what
130 // currentExtent uses). Excluding 0 avoids a divide by zero and an
131 // infinite loop when rendering to a new canvas. Excluding extents
132 // greater than 1 avoids doing unnecessary calculations.
133
134 // The scheme is to compare the width against the mean x coordinate
135 // (and height against mean y coordinate) and only allow zooms where
136 // the ratio indicates that there is more than about 12 significant
137 // figures (there are about 16 significant figures in a double).
138
139 if ( extent.width() > 0 &&
140 extent.height() > 0 &&
141 extent.width() < 1 &&
142 extent.height() < 1 )
143 {
144 // Use abs() on the extent to avoid the case where the extent is
145 // symmetrical about 0.
146 const double xMean = ( std::fabs( extent.xMinimum() ) + std::fabs( extent.xMaximum() ) ) * 0.5;
147 const double yMean = ( std::fabs( extent.yMinimum() ) + std::fabs( extent.yMaximum() ) ) * 0.5;
148
149 const double xRange = extent.width() / xMean;
150 const double yRange = extent.height() / yMean;
151
152 static const double MIN_PROPORTION = 1e-12;
153 if ( xRange < MIN_PROPORTION || yRange < MIN_PROPORTION )
154 {
155 mValid = false;
156 return;
157 }
158 }
159
160 const double myHeight = mSize.height();
161 const double myWidth = mSize.width();
162
163 if ( !myWidth || !myHeight )
164 {
165 mValid = false;
166 return;
167 }
168
169 // calculate the translation and scaling parameters
170 const double mapUnitsPerPixelY = mExtent.height() / myHeight;
171 const double mapUnitsPerPixelX = mExtent.width() / myWidth;
172 mMapUnitsPerPixel = mapUnitsPerPixelY > mapUnitsPerPixelX ? mapUnitsPerPixelY : mapUnitsPerPixelX;
173
174 // calculate the actual extent of the mapCanvas
175 double dxmin = mExtent.xMinimum(), dxmax = mExtent.xMaximum(),
176 dymin = mExtent.yMinimum(), dymax = mExtent.yMaximum(), whitespace;
177
178 if ( mapUnitsPerPixelY > mapUnitsPerPixelX )
179 {
180 whitespace = ( ( myWidth * mMapUnitsPerPixel ) - mExtent.width() ) * 0.5;
181 dxmin -= whitespace;
182 dxmax += whitespace;
183 }
184 else
185 {
186 whitespace = ( ( myHeight * mMapUnitsPerPixel ) - mExtent.height() ) * 0.5;
187 dymin -= whitespace;
188 dymax += whitespace;
189 }
190
191 mVisibleExtent.set( dxmin, dymin, dxmax, dymax );
192
193 // update the scale
196
197 bool ok = true;
200 visibleExtent().center().x(),
201 visibleExtent().center().y(),
202 outputSize().width(),
203 outputSize().height(),
204 mRotation, &ok );
205
206 mValid = ok;
207
208#if 1 // set visible extent taking rotation in consideration
209 if ( mRotation )
210 {
211 const QgsPointXY p1 = mMapToPixel.toMapCoordinates( QPoint( 0, 0 ) );
212 const QgsPointXY p2 = mMapToPixel.toMapCoordinates( QPoint( 0, myHeight ) );
213 const QgsPointXY p3 = mMapToPixel.toMapCoordinates( QPoint( myWidth, 0 ) );
214 const QgsPointXY p4 = mMapToPixel.toMapCoordinates( QPoint( myWidth, myHeight ) );
215 dxmin = std::min( p1.x(), std::min( p2.x(), std::min( p3.x(), p4.x() ) ) );
216 dymin = std::min( p1.y(), std::min( p2.y(), std::min( p3.y(), p4.y() ) ) );
217 dxmax = std::max( p1.x(), std::max( p2.x(), std::max( p3.x(), p4.x() ) ) );
218 dymax = std::max( p1.y(), std::max( p2.y(), std::max( p3.y(), p4.y() ) ) );
219 mVisibleExtent.set( dxmin, dymin, dxmax, dymax );
220 }
221#endif
222
223 QgsDebugMsgLevel( QStringLiteral( "Map units per pixel (x,y) : %1, %2" ).arg( qgsDoubleToString( mapUnitsPerPixelX ), qgsDoubleToString( mapUnitsPerPixelY ) ), 5 );
224 QgsDebugMsgLevel( QStringLiteral( "Pixmap dimensions (x,y) : %1, %2" ).arg( qgsDoubleToString( mSize.width() ), qgsDoubleToString( mSize.height() ) ), 5 );
225 QgsDebugMsgLevel( QStringLiteral( "Extent dimensions (x,y) : %1, %2" ).arg( qgsDoubleToString( mExtent.width() ), qgsDoubleToString( mExtent.height() ) ), 5 );
227 QgsDebugMsgLevel( QStringLiteral( "Adjusted map units per pixel (x,y) : %1, %2" ).arg( qgsDoubleToString( mVisibleExtent.width() / myWidth ), qgsDoubleToString( mVisibleExtent.height() / myHeight ) ), 5 );
228 QgsDebugMsgLevel( QStringLiteral( "Recalced pixmap dimensions (x,y) : %1, %2" ).arg( qgsDoubleToString( mVisibleExtent.width() / mMapUnitsPerPixel ), qgsDoubleToString( mVisibleExtent.height() / mMapUnitsPerPixel ) ), 5 );
229 QgsDebugMsgLevel( QStringLiteral( "Scale (assuming meters as map units) = 1:%1" ).arg( qgsDoubleToString( mScale ) ), 5 );
230 QgsDebugMsgLevel( QStringLiteral( "Rotation: %1 degrees" ).arg( mRotation ), 5 );
231 QgsDebugMsgLevel( QStringLiteral( "Extent: %1" ).arg( mExtent.asWktCoordinates() ), 5 );
232 QgsDebugMsgLevel( QStringLiteral( "Visible Extent: %1" ).arg( mVisibleExtent.asWktCoordinates() ), 5 );
233 QgsDebugMsgLevel( QStringLiteral( "Magnification factor: %1" ).arg( mMagnificationFactor ), 5 );
234
235}
236
237
239{
240 return mSize;
241}
242
244{
245 mSize = size;
246
248}
249
251{
252 return mDevicePixelRatio;
253}
254
256{
257 mDevicePixelRatio = dpr;
259}
260
262{
263 return outputSize() * mDevicePixelRatio;
264}
265
267{
268 return mDpi;
269}
270
272{
273 mDpi = dpi;
274
276}
277
279{
280 return mDpiTarget;
281}
282
284{
285 mDpiTarget = dpi;
286}
287
288QStringList QgsMapSettings::layerIds( bool expandGroupLayers ) const
289{
290 const QList<QgsMapLayer * > mapLayers = layers( expandGroupLayers );
291 QStringList res;
292 res.reserve( mapLayers.size() );
293 for ( const QgsMapLayer *layer : mapLayers )
294 res << layer->id();
295 return res;
296}
297
298QList<QgsMapLayer *> QgsMapSettings::layers( bool expandGroupLayers ) const
299{
300 const QList<QgsMapLayer *> actualLayers = _qgis_listQPointerToRaw( mLayers );
301 if ( !expandGroupLayers )
302 return actualLayers;
303
304 QList< QgsMapLayer * > result;
305
306 std::function< void( const QList< QgsMapLayer * >& layers ) > expandLayers;
307 expandLayers = [&result, &expandLayers]( const QList< QgsMapLayer * > &layers )
308 {
309 for ( QgsMapLayer *layer : layers )
310 {
311 if ( QgsGroupLayer *groupLayer = qobject_cast< QgsGroupLayer * >( layer ) )
312 {
313 expandLayers( groupLayer->childLayers() );
314 }
315 else
316 {
317 result << layer;
318 }
319 }
320 };
321
322 expandLayers( actualLayers );
323 return result;
324}
325
326template<typename T>
327QVector<T> QgsMapSettings::layers() const
328{
329 const QList<QgsMapLayer *> actualLayers = _qgis_listQPointerToRaw( mLayers );
330
331 QVector<T> layers;
332 for ( QgsMapLayer *layer : actualLayers )
333 {
334 T tLayer = qobject_cast<T>( layer );
335 if ( tLayer )
336 {
337 layers << tLayer;
338 }
339 }
340 return layers;
341}
342
343void QgsMapSettings::setLayers( const QList<QgsMapLayer *> &layers )
344{
345 // filter list, removing null layers and non-spatial layers
346 auto filteredList = layers;
347 filteredList.erase( std::remove_if( filteredList.begin(), filteredList.end(),
348 []( QgsMapLayer * layer )
349 {
350 return !layer || !layer->isSpatial();
351 } ), filteredList.end() );
352
353 mLayers = _qgis_listRawToQPointer( filteredList );
354}
355
356QMap<QString, QString> QgsMapSettings::layerStyleOverrides() const
357{
359}
360
361void QgsMapSettings::setLayerStyleOverrides( const QMap<QString, QString> &overrides )
362{
363 mLayerStyleOverrides = overrides;
364}
365
367{
368 mDestCRS = crs;
370 // Since the map units have changed, force a recalculation of the scale.
372}
373
378
379bool QgsMapSettings::setEllipsoid( const QString &ellipsoid )
380{
382 if ( !params.valid )
383 {
384 return false;
385 }
386 else
387 {
389 return true;
390 }
391}
392
397
399{
400 if ( on )
401 mFlags |= flag;
402 else
403 mFlags &= ~( static_cast< int >( flag ) );
404}
405
410
412{
413 return mFlags.testFlag( flag );
414}
415
420
421
423{
424 return mValid;
425}
426
431
433{
434 QPolygonF poly;
435
436 const QSize &sz = outputSize();
437 const QgsMapToPixel &m2p = mapToPixel();
438
439 poly << m2p.toMapCoordinates( 0.0, 0.0 ).toQPointF();
440 poly << m2p.toMapCoordinates( static_cast<double>( sz.width() ), 0.0 ).toQPointF();
441 poly << m2p.toMapCoordinates( static_cast<double>( sz.width() ), static_cast<double>( sz.height() ) ).toQPointF();
442 poly << m2p.toMapCoordinates( 0.0, static_cast<double>( sz.height() ) ).toQPointF();
443
444 return poly;
445}
446
448{
449 QPolygonF poly;
450
451 const QSize &sz = outputSize();
452 const QgsMapToPixel &m2p = mapToPixel();
453
454 // Transform tilebuffer in pixel.
455 // Original tilebuffer is in pixel and transformed only according
456 // extent width (see QgsWmsRenderContext::mapTileBuffer)
457
458 const double mapUnitsPerPixel = mExtent.width() / sz.width();
459 const double buffer = mExtentBuffer / mapUnitsPerPixel;
460
461 poly << m2p.toMapCoordinates( -buffer, -buffer ).toQPointF();
462 poly << m2p.toMapCoordinates( static_cast<double>( sz.width() + buffer ), -buffer ).toQPointF();
463 poly << m2p.toMapCoordinates( static_cast<double>( sz.width() + buffer ), static_cast<double>( sz.height() + buffer ) ).toQPointF();
464 poly << m2p.toMapCoordinates( -buffer, static_cast<double>( sz.height() + buffer ) ).toQPointF();
465
466 return poly;
467}
468
470{
471 return mMapUnitsPerPixel;
472}
473
475{
476 return mScale;
477}
478
480{
481#ifdef QGISDEBUG
482 if ( !mHasTransformContext )
483 QgsDebugMsgLevel( QStringLiteral( "No QgsCoordinateTransformContext context set for transform" ), 4 );
484#endif
485
486 return mTransformContext;
487}
488
490{
491 mTransformContext = context;
492#ifdef QGISDEBUG
493 mHasTransformContext = true;
494#endif
495}
496
498{
499 if ( !layer )
500 return QgsCoordinateTransform();
501
503}
504
506{
507 // Output width in inches
508 const double outputWidthInInches = outputSize().width() / outputDpi();
509
510 // Desired visible width (honouring scale)
511 const double scaledWidthInInches = outputWidthInInches * scale;
512
514 {
515 // Start with some fraction of the current extent around the center
516 const double delta = mExtent.width() / 100.;
517 QgsRectangle ext( center.x() - delta, center.y() - delta, center.x() + delta, center.y() + delta );
518 // Get scale at extent, and then scale extent to the desired scale
519 const double testScale = mScaleCalculator.calculate( ext, outputSize().width() );
520 ext.scale( scale / testScale );
521 return ext;
522 }
523 else
524 {
525 // Conversion from inches to mapUnits - this is safe to use, because we know here that the map units AREN'T in degrees
526 const double conversionFactor = QgsUnitTypes::fromUnitToUnitFactor( Qgis::DistanceUnit::Feet, mapUnits() ) / 12;
527
528 const double delta = 0.5 * scaledWidthInInches * conversionFactor;
529 return QgsRectangle( center.x() - delta, center.y() - delta, center.x() + delta, center.y() + delta );
530 }
531}
532
534{
535 return mScaleCalculator.calculate( extent, outputSize().width() );
536}
537
538double QgsMapSettings::layerToMapUnits( const QgsMapLayer *layer, const QgsRectangle &referenceExtent ) const
539{
540 return layerTransform( layer ).scaleFactor( referenceExtent );
541}
542
543
545{
546 try
547 {
549 if ( ct.isValid() )
550 {
551 QgsDebugMsgLevel( QStringLiteral( "sourceCrs = %1" ).arg( ct.sourceCrs().authid() ), 3 );
552 QgsDebugMsgLevel( QStringLiteral( "destCRS = %1" ).arg( ct.destinationCrs().authid() ), 3 );
553 QgsDebugMsgLevel( QStringLiteral( "extent %1" ).arg( extent.toString() ), 3 );
556 }
557 }
558 catch ( QgsCsException &cse )
559 {
560 QgsMessageLog::logMessage( QObject::tr( "Transform error caught: %1" ).arg( cse.what() ), QObject::tr( "CRS" ) );
561 }
562
563 QgsDebugMsgLevel( QStringLiteral( "proj extent = %1 " ).arg( extent.toString() ), 3 );
564
565 return extent;
566}
567
568
570{
571 try
572 {
575 if ( ct.isValid() )
576 {
577 QgsDebugMsgLevel( QStringLiteral( "sourceCrs = %1" ).arg( ct.sourceCrs().authid() ), 3 );
578 QgsDebugMsgLevel( QStringLiteral( "destCRS = %1" ).arg( ct.destinationCrs().authid() ), 3 );
579 QgsDebugMsgLevel( QStringLiteral( "extent = %1" ).arg( extent.toString() ), 3 );
581 }
582 }
583 catch ( QgsCsException &cse )
584 {
585 QgsMessageLog::logMessage( QObject::tr( "Transform error caught: %1" ).arg( cse.what() ), QObject::tr( "CRS" ) );
586 }
587
588 QgsDebugMsgLevel( QStringLiteral( "proj extent = %1" ).arg( extent.toString() ), 3 );
589
590 return extent;
591}
592
593
595{
596 try
597 {
598 const QgsCoordinateTransform ct = layerTransform( layer );
599 if ( ct.isValid() )
600 point = ct.transform( point, Qgis::TransformDirection::Forward );
601 }
602 catch ( QgsCsException &cse )
603 {
604 QgsMessageLog::logMessage( QObject::tr( "Transform error caught: %1" ).arg( cse.what() ), QObject::tr( "CRS" ) );
605 }
606
607 return point;
608}
609
611{
612 double x = point.x();
613 double y = point.y();
614 double z = point.z();
615 const double m = point.m();
616
617 try
618 {
619 const QgsCoordinateTransform ct = layerTransform( layer );
620 if ( ct.isValid() )
622 }
623 catch ( QgsCsException &cse )
624 {
625 QgsMessageLog::logMessage( QObject::tr( "Transform error caught: %1" ).arg( cse.what() ), QObject::tr( "CRS" ) );
626 }
627
628 return QgsPoint( x, y, z, m );
629}
630
631
633{
634 try
635 {
636 const QgsCoordinateTransform ct = layerTransform( layer );
637 if ( ct.isValid() )
639 }
640 catch ( QgsCsException &cse )
641 {
642 QgsMessageLog::logMessage( QObject::tr( "Transform error caught: %1" ).arg( cse.what() ), QObject::tr( "CRS" ) );
643 }
644
645 return rect;
646}
647
648
650{
651 try
652 {
653 const QgsCoordinateTransform ct = layerTransform( layer );
654 if ( ct.isValid() )
655 point = ct.transform( point, Qgis::TransformDirection::Reverse );
656 }
657 catch ( QgsCsException &cse )
658 {
659 QgsMessageLog::logMessage( QObject::tr( "Transform error caught: %1" ).arg( cse.what() ), QObject::tr( "CRS" ) );
660 }
661
662 return point;
663}
664
666{
667 double x = point.x();
668 double y = point.y();
669 double z = point.z();
670 const double m = point.m();
671
672 try
673 {
674 const QgsCoordinateTransform ct = layerTransform( layer );
675 if ( ct.isValid() )
677 }
678 catch ( QgsCsException &cse )
679 {
680 QgsMessageLog::logMessage( QObject::tr( "Transform error caught: %1" ).arg( cse.what() ), QObject::tr( "CRS" ) );
681 }
682
683 return QgsPoint( x, y, z, m );
684}
685
686
688{
689 try
690 {
691 const QgsCoordinateTransform ct = layerTransform( layer );
692 if ( ct.isValid() )
694 }
695 catch ( QgsCsException &cse )
696 {
697 QgsMessageLog::logMessage( QObject::tr( "Transform error caught: %1" ).arg( cse.what() ), QObject::tr( "CRS" ) );
698 }
699
700 return rect;
701}
702
703
704
706{
707 // reset the map canvas extent since the extent may now be smaller
708 // We can't use a constructor since QgsRectangle normalizes the rectangle upon construction
711
712 // iterate through the map layers and test each layers extent
713 // against the current min and max values
714 QgsDebugMsgLevel( QStringLiteral( "Layer count: %1" ).arg( mLayers.count() ), 5 );
715 const auto constMLayers = mLayers;
716 for ( const QgsWeakMapLayerPointer &layerPtr : constMLayers )
717 {
718 if ( QgsMapLayer *lyr = layerPtr.data() )
719 {
720 QgsDebugMsgLevel( "Updating extent using " + lyr->name(), 5 );
721 QgsDebugMsgLevel( "Input extent: " + lyr->extent().toString(), 5 );
722
723 if ( lyr->extent().isNull() )
724 continue;
725
726 // Layer extents are stored in the coordinate system (CS) of the
727 // layer. The extent must be projected to the canvas CS
728 const QgsRectangle extent = layerExtentToOutputExtent( lyr, lyr->extent() );
729
730 QgsDebugMsgLevel( "Output extent: " + extent.toString(), 5 );
732 }
733 }
734
735 if ( fullExtent.width() == 0.0 || fullExtent.height() == 0.0 )
736 {
737 // If all of the features are at the one point, buffer the
738 // rectangle a bit. If they are all at zero, do something a bit
739 // more crude.
740
741 if ( fullExtent.xMinimum() == 0.0 && fullExtent.xMaximum() == 0.0 &&
742 fullExtent.yMinimum() == 0.0 && fullExtent.yMaximum() == 0.0 )
743 {
744 fullExtent.set( -1.0, -1.0, 1.0, 1.0 );
745 }
746 else
747 {
748 const double padFactor = 1e-8;
749 const double widthPad = fullExtent.xMinimum() * padFactor;
750 const double heightPad = fullExtent.yMinimum() * padFactor;
751 const double xmin = fullExtent.xMinimum() - widthPad;
752 const double xmax = fullExtent.xMaximum() + widthPad;
753 const double ymin = fullExtent.yMinimum() - heightPad;
754 const double ymax = fullExtent.yMaximum() + heightPad;
755 fullExtent.set( xmin, ymin, xmax, ymax );
756 }
757 }
758
759 QgsDebugMsgLevel( "Full extent: " + fullExtent.toString(), 5 );
760 return fullExtent;
761}
762
763
764void QgsMapSettings::readXml( QDomNode &node )
765{
766 // set destination CRS
768 const QDomNode srsNode = node.namedItem( QStringLiteral( "destinationsrs" ) );
769 if ( !srsNode.isNull() )
770 {
771 srs.readXml( srsNode );
772 }
773 setDestinationCrs( srs );
774
775 // set extent
776 const QDomNode extentNode = node.namedItem( QStringLiteral( "extent" ) );
777 const QgsRectangle aoi = QgsXmlUtils::readRectangle( extentNode.toElement() );
778 setExtent( aoi );
779
780 // set rotation
781 const QDomNode rotationNode = node.namedItem( QStringLiteral( "rotation" ) );
782 const QString rotationVal = rotationNode.toElement().text();
783 if ( ! rotationVal.isEmpty() )
784 {
785 const double rot = rotationVal.toDouble();
786 setRotation( rot );
787 }
788
789 //render map tile
790 const QDomElement renderMapTileElem = node.firstChildElement( QStringLiteral( "rendermaptile" ) );
791 if ( !renderMapTileElem.isNull() )
792 {
793 setFlag( Qgis::MapSettingsFlag::RenderMapTile, renderMapTileElem.text() == QLatin1String( "1" ) );
794 }
795}
796
797
798
799void QgsMapSettings::writeXml( QDomNode &node, QDomDocument &doc )
800{
801 // units
802 node.appendChild( QgsXmlUtils::writeMapUnits( mapUnits(), doc ) );
803
804 // Write current view extents
805 node.appendChild( QgsXmlUtils::writeRectangle( extent(), doc ) );
806
807 // Write current view rotation
808 QDomElement rotNode = doc.createElement( QStringLiteral( "rotation" ) );
809 rotNode.appendChild(
810 doc.createTextNode( qgsDoubleToString( rotation() ) )
811 );
812 node.appendChild( rotNode );
813
814 // destination CRS
815 if ( mDestCRS.isValid() )
816 {
817 QDomElement srsNode = doc.createElement( QStringLiteral( "destinationsrs" ) );
818 node.appendChild( srsNode );
819 mDestCRS.writeXml( srsNode, doc );
820 }
821
822 //render map tile
823 QDomElement renderMapTileElem = doc.createElement( QStringLiteral( "rendermaptile" ) );
824 const QDomText renderMapTileText = doc.createTextNode( testFlag( Qgis::MapSettingsFlag::RenderMapTile ) ? "1" : "0" );
825 renderMapTileElem.appendChild( renderMapTileText );
826 node.appendChild( renderMapTileElem );
827}
828
833
835{
836 mLabelBoundaryGeometry = boundary;
837}
838
840{
841 mClippingRegions.append( region );
842}
843
844void QgsMapSettings::setClippingRegions( const QList<QgsMapClippingRegion> &regions )
845{
846 mClippingRegions = regions;
847}
848
849QList<QgsMapClippingRegion> QgsMapSettings::clippingRegions() const
850{
851 return mClippingRegions;
852}
853
855{
856 mMaskRenderSettings = settings;
857}
858
860{
861 mRenderedFeatureHandlers.append( handler );
862}
863
864QList<QgsRenderedFeatureHandlerInterface *> QgsMapSettings::renderedFeatureHandlers() const
865{
866 return mRenderedFeatureHandlers;
867}
868
870{
871 return mZRange;
872}
873
875{
876 mZRange = zRange;
877}
878
883
888
890{
891 return mFrameRate;
892}
893
895{
896 mFrameRate = rate;
897}
898
900{
901 return mCurrentFrame;
902}
903
904void QgsMapSettings::setCurrentFrame( long long frame )
905{
906 mCurrentFrame = frame;
907}
908
913
918
The Qgis class provides global constants for use throughout the application.
Definition qgis.h:54
QFlags< MapSettingsFlag > MapSettingsFlags
Map settings flags.
Definition qgis.h:2601
@ NoSimplification
No simplification can be applied.
DistanceUnit
Units of distance.
Definition qgis.h:4722
@ Feet
Imperial feet.
@ Unknown
Unknown distance unit.
@ Degrees
Degrees, for planar geographic CRS distance measurements.
RendererUsage
Usage of the renderer.
Definition qgis.h:3241
@ Forward
Forward transform (from source to destination)
@ Reverse
Reverse/inverse transform (from destination to source)
MapSettingsFlag
Flags which adjust the way maps are rendered.
Definition qgis.h:2579
@ RenderMapTile
Draw map such that there are no problems between adjacent tiles.
This class represents a coordinate reference system (CRS).
bool isValid() const
Returns whether this CRS is correctly initialized and usable.
bool readXml(const QDomNode &node)
Restores state from the given DOM node.
bool writeXml(QDomNode &node, QDomDocument &doc) const
Stores state to the given Dom node in the given document.
Contains information about the context in which a coordinate transform is executed.
Class for doing transforms between two map coordinate systems.
QgsCoordinateReferenceSystem sourceCrs() const
Returns the source coordinate reference system, which the transform will transform coordinates from.
void setBallparkTransformsAreAppropriate(bool appropriate)
Sets whether approximate "ballpark" results are appropriate for this coordinate transform.
double scaleFactor(const QgsRectangle &referenceExtent) const
Computes an estimated conversion factor between source and destination units:
QgsPointXY transform(const QgsPointXY &point, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward) const
Transform the point from the source CRS to the destination CRS.
void transformInPlace(double &x, double &y, double &z, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward) const
Transforms an array of x, y and z double coordinates in place, from the source CRS to the destination...
QgsRectangle transformBoundingBox(const QgsRectangle &rectangle, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward, bool handle180Crossover=false) const
Transforms a rectangle from the source CRS to the destination CRS.
bool isValid() const
Returns true if the coordinate transform is valid, ie both the source and destination CRS have been s...
QgsCoordinateReferenceSystem destinationCrs() const
Returns the destination coordinate reference system, which the transform will transform coordinates t...
Custom exception class for Coordinate Reference System related exceptions.
QgsRange which stores a range of double values.
Definition qgsrange.h:231
This class can render elevation shading on an image with different methods (eye dome lighting,...
static EllipsoidParameters ellipsoidParameters(const QString &ellipsoid)
Returns the parameters for the specified ellipsoid.
QString what() const
A geometry is the spatial representation of a feature.
A map layer which consists of a set of child layers, where all component layers are rendered as a sin...
A map clipping region (in map coordinates and CRS).
Base class for all map layer types.
Definition qgsmaplayer.h:76
QgsCoordinateReferenceSystem crs
Definition qgsmaplayer.h:83
void setElevationShadingRenderer(const QgsElevationShadingRenderer &renderer)
Sets the shading renderer used to render shading on the entire map.
QSize deviceOutputSize() const
Returns the device output size of the map render.
Qgis::DistanceUnit mapUnits() const
Returns the units of the map's geographical coordinates - used for scale calculation.
Qgis::RendererUsage rendererUsage() const
Returns the rendering usage.
QgsVectorSimplifyMethod mSimplifyMethod
void addClippingRegion(const QgsMapClippingRegion &region)
Adds a new clipping region to the map settings.
void writeXml(QDomNode &node, QDomDocument &doc)
Writes the map settings to an XML node.
QgsPointXY layerToMapCoordinates(const QgsMapLayer *layer, QgsPointXY point) const
transform point coordinates from layer's CRS to output CRS
QgsMaskRenderSettings mMaskRenderSettings
Qgis::RendererUsage mRendererUsage
QgsRectangle mVisibleExtent
Extent with some additional white space that matches the output aspect ratio.
QPolygonF visiblePolygon() const
Returns the visible area as a polygon (may be rotated)
void addRenderedFeatureHandler(QgsRenderedFeatureHandlerInterface *handler)
Adds a rendered feature handler to use while rendering the map settings.
void setLayers(const QList< QgsMapLayer * > &layers)
Sets the list of layers to render in the map.
double scale() const
Returns the calculated map scale.
void setFrameRate(double rate)
Sets the frame rate of the map (in frames per second), for maps which are part of an animation.
void setFlags(Qgis::MapSettingsFlags flags)
Sets combination of flags that will be used for rendering.
Qgis::MapSettingsFlags mFlags
QgsCoordinateTransform layerTransform(const QgsMapLayer *layer) const
Returns the coordinate transform from layer's CRS to destination CRS.
QgsRectangle layerExtentToOutputExtent(const QgsMapLayer *layer, QgsRectangle extent) const
transform bounding box from layer's CRS to output CRS
QgsDoubleRange zRange() const
Returns the range of z-values which will be visible in the map.
bool setEllipsoid(const QString &ellipsoid)
Sets the ellipsoid by its acronym.
void setDpiTarget(double dpi)
Sets the target dpi (dots per inch) to be taken into consideration when rendering.
double magnificationFactor() const
Returns the magnification factor.
QgsGeometry labelBoundaryGeometry() const
Returns the label boundary geometry, which restricts where in the rendered map labels are permitted t...
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.
void setDevicePixelRatio(float dpr)
Sets the device pixel ratio.
QString mEllipsoid
ellipsoid acronym (from table tbl_ellipsoids)
void setZRange(const QgsDoubleRange &range)
Sets the range of z-values which will be visible 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.
bool mValid
Whether the actual settings are valid (set in updateDerived())
void setOutputDpi(double dpi)
Sets the dpi (dots per inch) used for conversion between real world units (e.g.
const QgsMapToPixel & mapToPixel() const
double mapUnitsPerPixel() const
Returns the distance in geographical coordinates that equals to one pixel in the map.
void setRendererUsage(Qgis::RendererUsage rendererUsage)
Sets the rendering usage.
float devicePixelRatio() const
Returns the device pixel ratio.
QgsRectangle mExtent
QSize outputSize() const
Returns the size of the resulting map image, in pixels.
QgsRectangle extent() const
Returns geographical coordinates of the rectangle that should be rendered.
void setMaskSettings(const QgsMaskRenderSettings &settings)
Sets the mask render settings, which control how masks are drawn and behave during the map render.
QMap< QString, QString > mLayerStyleOverrides
QgsGeometry mLabelBoundaryGeometry
void setLayerStyleOverrides(const QMap< QString, QString > &overrides)
Sets the map of map layer style overrides (key: layer ID, value: style name) where a different style ...
QgsElevationShadingRenderer mShadingRenderer
QgsCoordinateTransformContext mTransformContext
void setExtent(const QgsRectangle &rect, bool magnified=true)
Sets the coordinates of the rectangle which should be rendered.
void setClippingRegions(const QList< QgsMapClippingRegion > &regions)
Sets the list of clipping regions to apply to the map.
double layerToMapUnits(const QgsMapLayer *layer, const QgsRectangle &referenceExtent=QgsRectangle()) const
Computes an estimated conversion factor between layer and map units, where layerUnits × layerToMapUni...
double extentBuffer() const
Returns the buffer in map units to use around the visible extent for rendering symbols whose correspo...
QVector< T > layers() const
Returns a list of registered map layers with a specified layer type.
QgsScaleCalculator mScaleCalculator
Qgis::MapSettingsFlags flags() const
Returns combination of flags used for rendering.
double frameRate() const
Returns the frame rate of the map (in frames per second), for maps which are part of an animation.
void setExtentBuffer(double buffer)
Sets the buffer in map units to use around the visible extent for rendering symbols whose correspondi...
QgsRectangle visibleExtent() const
Returns the actual extent derived from requested extent that takes output image size into account.
QgsRectangle outputExtentToLayerExtent(const QgsMapLayer *layer, QgsRectangle extent) const
transform bounding box from output CRS to layer's CRS
QgsRectangle fullExtent() const
returns current extent of layer set
void setTransformContext(const QgsCoordinateTransformContext &context)
Sets the coordinate transform context, which stores various information regarding which datum transfo...
void setRotation(double rotation)
Sets the rotation of the resulting map image, in degrees clockwise.
double computeScaleForExtent(const QgsRectangle &extent) const
Compute the scale that corresponds to the specified extent.
QString ellipsoid() const
Returns ellipsoid's acronym.
double mMagnificationFactor
void setCurrentFrame(long long frame)
Sets the current frame of the map, for maps which are part of an animation.
const QgsElevationShadingRenderer & elevationShadingRenderer() const
Returns the shading renderer used to render shading on the entire map.
QgsCoordinateReferenceSystem mDestCRS
double outputDpi() const
Returns the DPI (dots per inch) used for conversion between real world units (e.g.
void setLabelBoundaryGeometry(const QgsGeometry &boundary)
Sets the label boundary geometry, which restricts where in the rendered map labels are permitted to b...
QgsMapToPixel mMapToPixel
bool testFlag(Qgis::MapSettingsFlag flag) const
Check whether a particular flag is enabled.
QMap< QString, QString > layerStyleOverrides() const
Returns the map of map layer style overrides (key: layer ID, value: style name) where a different sty...
double rotation() const
Returns the rotation of the resulting map image, in degrees clockwise.
QList< QgsMapClippingRegion > clippingRegions() const
Returns the list of clipping regions to apply to the map.
bool hasValidSettings() const
Check whether the map settings are valid and can be used for rendering.
QgsWeakMapLayerPointerList mLayers
list of layers to be rendered (stored as weak pointers)
void setOutputSize(QSize size)
Sets the size of the resulting map image, in pixels.
QgsPointXY mapToLayerCoordinates(const QgsMapLayer *layer, QgsPointXY point) const
transform point coordinates from output CRS to layer's CRS
long long mCurrentFrame
QgsCoordinateReferenceSystem destinationCrs() const
Returns the destination coordinate reference system for the map render.
QPolygonF visiblePolygonWithBuffer() const
Returns the visible area as a polygon (may be rotated) with extent buffer included.
void setFlag(Qgis::MapSettingsFlag flag, bool on=true)
Enable or disable a particular flag (other flags are not affected)
void setDestinationCrs(const QgsCoordinateReferenceSystem &crs)
Sets the destination crs (coordinate reference system) for the map render.
void readXml(QDomNode &node)
Restore the map settings from a XML node.
QgsRectangle computeExtentForScale(const QgsPointXY &center, double scale) const
Compute the extent such that its center is at the specified position (mapped to the destinatonCrs) an...
void setMagnificationFactor(double factor, const QgsPointXY *center=nullptr)
Set the magnification factor.
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context, which stores various information regarding which datum tran...
Perform transforms between map coordinates and device coordinates.
QgsPointXY toMapCoordinates(int x, int y) const
Transforms device coordinates to map (world) coordinates.
void setParameters(double mapUnitsPerPixel, double centerX, double centerY, int widthPixels, int heightPixels, double rotation)
Sets parameters for use in transforming coordinates.
Contains settings regarding how masks are calculated and handled during a map render.
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::MessageLevel::Warning, bool notifyUser=true)
Adds a message to the log instance (and creates it if necessary).
Contains miscellaneous painting utility functions.
Definition qgspainting.h:32
A class to represent a 2D point.
Definition qgspointxy.h:60
double y
Definition qgspointxy.h:64
double x
Definition qgspointxy.h:63
QPointF toQPointF() const
Converts a point to a QPointF.
Definition qgspointxy.h:165
Point geometry type, with support for z-dimension and m-values.
Definition qgspoint.h:49
double z
Definition qgspoint.h:54
double x
Definition qgspoint.h:52
double m
Definition qgspoint.h:55
double y
Definition qgspoint.h:53
A rectangle specified with double values.
Q_INVOKABLE QString toString(int precision=16) const
Returns a string representation of form xmin,ymin : xmax,ymax Coordinates will be truncated to the sp...
void scale(double scaleFactor, const QgsPointXY *c=nullptr)
Scale the rectangle around its center point.
double xMinimum
double yMinimum
double xMaximum
Q_INVOKABLE QString asWktCoordinates() const
Returns a string representation of the rectangle in WKT format.
void set(const QgsPointXY &p1, const QgsPointXY &p2, bool normalize=true)
Sets the rectangle from two QgsPoints.
double yMaximum
void combineExtentWith(const QgsRectangle &rect)
Expands the rectangle so that it covers both the original rectangle and the given rectangle.
QgsPointXY center
void setNull()
Mark a rectangle as being null (holding no spatial information).
bool isFinite() const
Returns true if the rectangle has finite boundaries.
An interface for classes which provider custom handlers for features rendered as part of a map render...
double calculate(const QgsRectangle &mapExtent, double canvasWidth) const
Calculate the scale denominator.
void setDpi(double dpi)
Sets the dpi (dots per inch) for the output resolution, to be used in scale calculations.
void setMapUnits(Qgis::DistanceUnit mapUnits)
Set the map units.
Qgis::DistanceUnit mapUnits() const
Returns current map units.
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.
static QDomElement writeRectangle(const QgsRectangle &rect, QDomDocument &doc, const QString &elementName=QStringLiteral("extent"))
Encodes a rectangle to a DOM element.
static QgsRectangle readRectangle(const QDomElement &element)
static QDomElement writeMapUnits(Qgis::DistanceUnit units, QDomDocument &doc)
Encodes a distance unit to a DOM element.
QString qgsDoubleToString(double a, int precision=17)
Returns a string representation of a double.
Definition qgis.h:5941
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition qgis.h:6024
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:39
QPointer< QgsMapLayer > QgsWeakMapLayerPointer
Weak pointer for QgsMapLayer.
const QgsCoordinateReferenceSystem & crs
Contains parameters for an ellipsoid.
bool valid
Whether ellipsoid parameters are valid.