QGIS API Documentation 3.28.0-Firenze (ed3ad0430f)
qgssnaptogridcanvasitem.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgssnaptogridcanvasitem.cpp
3 ----------------------
4 begin : August 2018
5 copyright : (C) Matthias Kuhn
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
17#include "qgsmapcanvas.h"
18#include "qgsrendercontext.h"
19
21 : QgsMapCanvasItem( mapCanvas )
22{
23 updateMapCanvasCrs();
24 connect( mMapCanvas, &QgsMapCanvas::extentsChanged, this, &QgsSnapToGridCanvasItem::updateZoomFactor );
25 connect( mMapCanvas, &QgsMapCanvas::destinationCrsChanged, this, &QgsSnapToGridCanvasItem::updateMapCanvasCrs );
26}
27
28void QgsSnapToGridCanvasItem::paint( QPainter *painter )
29{
30 if ( !mEnabled || !mAvailableByZoomFactor )
31 return;
32
33 const QgsScopedQPainterState painterState( painter );
34 const QgsRectangle mapRect = mMapCanvas->extent();
35
36 painter->setRenderHints( QPainter::Antialiasing );
37 painter->setCompositionMode( QPainter::CompositionMode_Difference );
38
39 const double scaleFactor = painter->fontMetrics().xHeight() * .2;
40
41 mGridPen.setWidth( scaleFactor );
42 mCurrentPointPen.setWidth( scaleFactor * 3 );
43 const int gridMarkerLength = scaleFactor * 3;
44
45 try
46 {
47 QgsCoordinateTransform extentTransform = mTransform;
48 extentTransform.setBallparkTransformsAreAppropriate( true );
49 const QgsRectangle layerExtent = extentTransform.transformBoundingBox( mapRect, Qgis::TransformDirection::Reverse );
50 const QgsPointXY layerPt = mTransform.transform( mPoint, Qgis::TransformDirection::Reverse );
51
52 const double gridXMin = std::ceil( layerExtent.xMinimum() / mPrecision ) * mPrecision;
53 const double gridXMax = std::ceil( layerExtent.xMaximum() / mPrecision ) * mPrecision;
54 const double gridYMin = std::ceil( layerExtent.yMinimum() / mPrecision ) * mPrecision;
55 const double gridYMax = std::ceil( layerExtent.yMaximum() / mPrecision ) * mPrecision;
56
57 for ( double x = gridXMin ; x < gridXMax; x += mPrecision )
58 {
59 for ( double y = gridYMin ; y < gridYMax; y += mPrecision )
60 {
61 const QgsPointXY pt = mTransform.transform( x, y );
62 const QPointF canvasPt = toCanvasCoordinates( pt );
63
64 if ( qgsDoubleNear( layerPt.x(), x, mPrecision / 2 ) && qgsDoubleNear( layerPt.y(), y, mPrecision / 2 ) )
65 {
66 painter->setPen( mCurrentPointPen );
67 }
68 else
69 {
70 painter->setPen( mGridPen );
71 }
72 painter->drawLine( canvasPt.x() - gridMarkerLength, canvasPt.y(), canvasPt.x() + gridMarkerLength, canvasPt.y() );
73 painter->drawLine( canvasPt.x(), canvasPt.y() - gridMarkerLength, canvasPt.x(), canvasPt.y() + gridMarkerLength );
74
75 }
76 }
77 }
78 catch ( QgsCsException &e )
79 {
80 Q_UNUSED( e )
81 mAvailableByZoomFactor = false;
82 }
83}
84
86{
87 return mPoint;
88}
89
91{
92 mPoint = point;
93 update();
94}
95
97{
98 return mPrecision;
99}
100
102{
103 mPrecision = precision;
104 updateZoomFactor();
105}
106
108{
109 return mTransform.sourceCrs();
110}
111
113{
114 mTransform.setSourceCrs( crs );
115 updateZoomFactor();
116}
117
119{
120 return mEnabled;
121}
122
124{
125 mEnabled = enabled;
126 update();
127}
128
129void QgsSnapToGridCanvasItem::updateMapCanvasCrs()
130{
133 update();
134}
135
136
137
138void QgsSnapToGridCanvasItem::updateZoomFactor()
139{
140 if ( !isVisible() )
141 return;
142
143 try
144 {
145 const int threshold = 5;
146
147 const QgsRectangle extent = mMapCanvas->extent();
148 if ( extent != rect() )
149 setRect( extent );
150
151 const QgsPointXY centerPoint = mMapCanvas->extent().center();
152 const QPointF canvasCenter = toCanvasCoordinates( centerPoint );
153
154 const QgsPointXY pt1 = mMapCanvas->mapSettings().mapToPixel().toMapCoordinates( static_cast<int>( canvasCenter.x() - threshold ),
155 static_cast<int>( canvasCenter.y() - threshold ) );
156 const QgsPointXY pt2 = mMapCanvas->mapSettings().mapToPixel().toMapCoordinates( static_cast<int>( canvasCenter.x() + threshold ),
157 static_cast<int>( canvasCenter.y() + threshold ) );
158
159 const QgsPointXY layerPt1 = mTransform.transform( pt1, Qgis::TransformDirection::Reverse );
160 const QgsPointXY layerPt2 = mTransform.transform( pt2, Qgis::TransformDirection::Reverse );
161
162 const double dist = layerPt1.distance( layerPt2 );
163
164 if ( dist < mPrecision )
165 mAvailableByZoomFactor = true;
166 else
167 mAvailableByZoomFactor = false;
168 }
169 catch ( QgsCsException & )
170 {
171 // transform errors?
172 // you've probably got worse problems than the grid with your digitizing operations in the current projection.
173 mAvailableByZoomFactor = false;
174 }
175}
This class represents a coordinate reference system (CRS).
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 setContext(const QgsCoordinateTransformContext &context)
Sets the context in which the coordinate transform should be calculated.
void setSourceCrs(const QgsCoordinateReferenceSystem &crs)
Sets the source coordinate reference system.
void setBallparkTransformsAreAppropriate(bool appropriate)
Sets whether approximate "ballpark" results are appropriate for this coordinate transform.
void setDestinationCrs(const QgsCoordinateReferenceSystem &crs)
Sets the destination coordinate reference system.
QgsRectangle transformBoundingBox(const QgsRectangle &rectangle, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward, bool handle180Crossover=false) const SIP_THROW(QgsCsException)
Transforms a rectangle from the source CRS to the destination CRS.
QgsPointXY transform(const QgsPointXY &point, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward) const SIP_THROW(QgsCsException)
Transform the point from the source CRS to the destination CRS.
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:66
An abstract class for items that can be placed on the map canvas.
QgsRectangle rect() const
returns canvas item rectangle in map units
QPointF toCanvasCoordinates(const QgsPointXY &point) const
transformation from map coordinates to screen coordinates
QgsMapCanvas * mMapCanvas
pointer to map canvas
void setRect(const QgsRectangle &r, bool resetRotation=true)
sets canvas item rectangle in map units
Map canvas is a class for displaying all GIS data types on a canvas.
Definition: qgsmapcanvas.h:90
void extentsChanged()
Emitted when the extents of the map change.
void destinationCrsChanged()
Emitted when map CRS has changed.
const QgsMapSettings & mapSettings() const
Gets access to properties used for map rendering.
QgsRectangle extent() const
Returns the current zoom extent of the map canvas.
const QgsMapToPixel & mapToPixel() const
QgsCoordinateReferenceSystem destinationCrs() const
Returns the destination coordinate reference system for the map render.
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context, which stores various information regarding which datum tran...
QgsPointXY toMapCoordinates(int x, int y) const
Transforms device coordinates to map (world) coordinates.
A class to represent a 2D point.
Definition: qgspointxy.h:59
double y
Definition: qgspointxy.h:63
Q_GADGET double x
Definition: qgspointxy.h:62
double distance(double x, double y) const SIP_HOLDGIL
Returns the distance between this point and a specified x, y coordinate.
Definition: qgspointxy.h:211
A rectangle specified with double values.
Definition: qgsrectangle.h:42
double yMaximum() const SIP_HOLDGIL
Returns the y maximum value (top side of rectangle).
Definition: qgsrectangle.h:193
double xMaximum() const SIP_HOLDGIL
Returns the x maximum value (right side of rectangle).
Definition: qgsrectangle.h:183
double xMinimum() const SIP_HOLDGIL
Returns the x minimum value (left side of rectangle).
Definition: qgsrectangle.h:188
double yMinimum() const SIP_HOLDGIL
Returns the y minimum value (bottom side of rectangle).
Definition: qgsrectangle.h:198
QgsPointXY center() const SIP_HOLDGIL
Returns the center point of the rectangle.
Definition: qgsrectangle.h:251
Scoped object for saving and restoring a QPainter object's state.
bool enabled() const
Enable this item.
double precision() const
The resolution of the grid in map units.
void setCrs(const QgsCoordinateReferenceSystem &crs)
The CRS in which the grid should be calculated.
void setPoint(const QgsPointXY &point)
A point that will be highlighted on the map canvas.
void setEnabled(bool enabled)
Enable this item.
QgsSnapToGridCanvasItem(QgsMapCanvas *mapCanvas)
Will automatically be added to the mapCanvas.
void paint(QPainter *painter) override
function to be implemented by derived classes
QgsCoordinateReferenceSystem crs() const
The CRS in which the grid should be calculated.
void setPrecision(double precision)
The resolution of the grid in map units.
QgsPointXY point() const
A point that will be highlighted on the map canvas.
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition: qgis.h:2527
const QgsCoordinateReferenceSystem & crs
int precision