QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgsvectorlayerdiagramprovider.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsvectorlayerdiagramprovider.cpp
3 --------------------------------------
4 Date : September 2015
5 Copyright : (C) 2015 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
17
18#include "qgsgeometry.h"
19#include "qgslabelsearchtree.h"
20#include "qgsvectorlayer.h"
22#include "diagram/qgsdiagram.h"
23#include "qgsgeos.h"
24#include "qgslabelingresults.h"
25#include "qgsrendercontext.h"
27#include "qgsscaleutils.h"
28
29#include "feature.h"
30#include "labelposition.h"
31
34 , mSettings( *layer->diagramLayerSettings() )
35 , mDiagRenderer( layer->diagramRenderer()->clone() )
36 , mFields( layer->fields() )
37 , mLayerCrs( layer->crs() )
38 , mSource( ownFeatureLoop ? new QgsVectorLayerFeatureSource( layer ) : nullptr )
39 , mOwnsSource( ownFeatureLoop )
40{
41 init();
42
43 // we have to create an expression context scope for the layer in advance, while we still have access to the layer itself
44 mLayerScope.reset( layer->createExpressionContextScope() );
45}
46
47
49{
51 mPriority = 1 - mSettings.priority() / 10.0; // convert 0..10 --> 1..0
53}
54
55
57{
58 if ( mOwnsSource )
59 delete mSource;
60
61 qDeleteAll( mFeatures );
62
63 // renderer is owned by mSettings
64}
65
66
68{
69 if ( !mSource )
70 {
71 // we have created the provider with "own feature loop" == false
72 // so it is assumed that prepare() has been already called followed by registerFeature() calls
73 return mFeatures;
74 }
75
76 QSet<QString> attributeNames;
77 if ( !prepare( context, attributeNames ) )
78 return QList<QgsLabelFeature *>();
79
80 QgsRectangle layerExtent = context.extent();
82 {
84 extentTransform.setBallparkTransformsAreAppropriate( true );
85 layerExtent = extentTransform.transformBoundingBox( context.extent(), Qgis::TransformDirection::Reverse );
86 }
87
88 QgsFeatureRequest request;
89 request.setFilterRect( layerExtent );
90 request.setSubsetOfAttributes( attributeNames, mFields );
91 const QgsFeatureFilterProvider *featureFilterProvider = context.featureFilterProvider();
92 if ( featureFilterProvider )
93 {
94 featureFilterProvider->filterFeatures( qobject_cast<QgsVectorLayer *>( mLayer ), request );
95 }
96 QgsFeatureIterator fit = mSource->getFeatures( request );
97
98 QgsFeature fet;
99 while ( fit.nextFeature( fet ) )
100 {
101 context.expressionContext().setFeature( fet );
102 registerFeature( fet, context );
103 }
104
105 return mFeatures;
106}
107
108
110{
111#if 1 // XXX strk
112 // features are pre-rotated but not scaled/translated,
113 // so we only disable rotation here. Ideally, they'd be
114 // also pre-scaled/translated, as suggested here:
115 // https://github.com/qgis/QGIS/issues/20071
116 QgsMapToPixel xform = context.mapToPixel();
117 xform.setMapRotation( 0, 0, 0 );
118#else
119 const QgsMapToPixel &xform = context.mapToPixel();
120#endif
121
122 QgsDiagramLabelFeature *dlf = dynamic_cast<QgsDiagramLabelFeature *>( label->getFeaturePart()->feature() );
123 const QgsFeature feature = dlf->feature();
124
125 // at time of drawing labels the expression context won't contain a layer scope -- so we manually add it here so that
126 // associated variables work correctly
128 context.expressionContext().setFeature( feature );
129
130 //calculate top-left point for diagram
131 //first, calculate the centroid of the label (accounts for PAL creating
132 //rotated labels when we do not want to draw the diagrams rotated)
133 double centerX = 0;
134 double centerY = 0;
135 for ( int i = 0; i < 4; ++i )
136 {
137 centerX += label->getX( i );
138 centerY += label->getY( i );
139 }
140 QgsPointXY outPt( centerX / 4.0, centerY / 4.0 );
141 //then, calculate the top left point for the diagram with this center position
142 QgsPointXY centerPt = xform.transform( outPt.x() - label->getWidth() / 2,
143 outPt.y() - label->getHeight() / 2 );
144
145 mSettings.renderer()->renderDiagram( feature, context, centerPt.toQPointF(), mSettings.dataDefinedProperties() );
146
147 //insert into label search tree to manipulate position interactively
148 mEngine->results()->mLabelSearchTree->insertLabel( label, label->getFeaturePart()->featureId(), mLayerId, QString(), QFont(), true, false );
149}
150
151bool QgsVectorLayerDiagramProvider::prepare( const QgsRenderContext &context, QSet<QString> &attributeNames )
152{
154 const QgsMapSettings &mapSettings = mEngine->mapSettings();
155
156 if ( context.coordinateTransform().isValid() )
157 // this is context for layer rendering
159 else
160 {
161 // otherwise fall back to creating our own CT
163 }
164
166
167 bool result = s2.prepare( context.expressionContext() );
168
169 //add attributes needed by the diagram renderer
170 attributeNames.unite( s2.referencedFields( context.expressionContext() ) );
171
172 return result;
173}
174
175
177{
178 QgsLabelFeature *label = registerDiagram( feature, context, obstacleGeometry );
179 if ( label )
180 mFeatures << label;
181}
182
187
189{
190 const QgsMapSettings &mapSettings = mEngine->mapSettings();
191
193 if ( dr )
194 {
195 QList<QgsDiagramSettings> settingList = dr->diagramSettings();
196 if ( !settingList.isEmpty() && settingList.at( 0 ).scaleBasedVisibility )
197 {
198 // Note: scale might be a non-round number, so compare with qgsDoubleNear
199 const double rendererScale = context.rendererScale();
200
201 // maxScale is inclusive ( < --> no diagram )
202 double maxScale = settingList.at( 0 ).maximumScale;
203 if ( maxScale > 0 && QgsScaleUtils::lessThanMaximumScale( rendererScale, maxScale ) )
204 {
205 return nullptr;
206 }
207
208 // minScale is exclusive ( >= --> no diagram)
209 double minScale = settingList.at( 0 ).minimumScale;
210 if ( minScale > 0 && QgsScaleUtils::equalToOrGreaterThanMinimumScale( rendererScale, minScale ) )
211 {
212 return nullptr;
213 }
214 }
215 }
216
217 // data defined show diagram? check this before doing any other processing
219 return nullptr;
220
221 // data defined obstacle?
223
224 //convert geom to geos
225 QgsGeometry geom = feat.geometry();
226 QgsGeometry extentGeom = QgsGeometry::fromRect( mapSettings.visibleExtent() );
227 if ( !qgsDoubleNear( mapSettings.rotation(), 0.0 ) )
228 {
229 //PAL features are prerotated, so extent also needs to be unrotated
230 extentGeom.rotate( -mapSettings.rotation(), mapSettings.visibleExtent().center() );
231 }
232
234 {
235 geom = QgsPalLabeling::prepareGeometry( geom, context, mSettings.coordinateTransform(), extentGeom );
236 }
237 if ( geom.isEmpty() )
238 return nullptr;
239
241 if ( !clipGeometry.isEmpty() )
242 {
243 const Qgis::GeometryType expectedType = geom.type();
244 geom = geom.intersection( clipGeometry );
245 geom.convertGeometryCollectionToSubclass( expectedType );
246 }
247 if ( geom.isEmpty() )
248 return nullptr;
249
250 QgsGeometry preparedObstacleGeom;
251 if ( isObstacle && !obstacleGeometry.isNull() && QgsPalLabeling::geometryRequiresPreparation( obstacleGeometry, context, mSettings.coordinateTransform(), extentGeom ) )
252 {
253 preparedObstacleGeom = QgsPalLabeling::prepareGeometry( obstacleGeometry, context, mSettings.coordinateTransform(), extentGeom );
254 }
255 else if ( mSettings.isObstacle() && !obstacleGeometry.isNull() )
256 {
257 preparedObstacleGeom = obstacleGeometry;
258 }
259
260 double diagramWidth = 0;
261 double diagramHeight = 0;
262 if ( dr )
263 {
264 QSizeF diagSize = dr->sizeMapUnits( feat, context );
265 if ( diagSize.isValid() )
266 {
267 diagramWidth = diagSize.width();
268 diagramHeight = diagSize.height();
269 }
270 }
271
272 // feature to the layer
273 bool alwaysShow = mSettings.showAllDiagrams();
274 context.expressionContext().setOriginalValueVariable( alwaysShow );
276
277 // new style data defined position
278 bool ddPos = false;
279 double ddPosX = 0.0;
280 double ddPosY = 0.0;
285 {
286 ddPosX = mSettings.dataDefinedProperties().valueAsDouble( QgsDiagramLayerSettings::Property::PositionX, context.expressionContext(), std::numeric_limits<double>::quiet_NaN() );
287 ddPosY = mSettings.dataDefinedProperties().valueAsDouble( QgsDiagramLayerSettings::Property::PositionY, context.expressionContext(), std::numeric_limits<double>::quiet_NaN() );
288
289 ddPos = !std::isnan( ddPosX ) && !std::isnan( ddPosY );
290
291 if ( ddPos )
292 {
294 if ( ct.isValid() && !ct.isShortCircuited() )
295 {
296 double z = 0;
297 ct.transformInPlace( ddPosX, ddPosY, z );
298 }
299 //data defined diagram position is always centered
300 ddPosX -= diagramWidth / 2.0;
301 ddPosY -= diagramHeight / 2.0;
302 }
303 }
304
305 QgsDiagramLabelFeature *lf = new QgsDiagramLabelFeature( feat, QgsGeos::asGeos( geom ), QSizeF( diagramWidth, diagramHeight ) );
306 lf->setHasFixedPosition( ddPos );
307 lf->setFixedPosition( QgsPointXY( ddPosX, ddPosY ) );
308 lf->setHasFixedAngle( true );
309 lf->setFixedAngle( 0 );
310 lf->setAlwaysShow( alwaysShow );
312 os.setIsObstacle( isObstacle );
313 os.setObstacleGeometry( preparedObstacleGeom );
314 lf->setObstacleSettings( os );
315
316 // data defined priority?
319 {
322 priorityD = std::clamp( priorityD, 0.0, 10.0 );
323 priorityD = 1 - priorityD / 10.0; // convert 0..10 --> 1..0
324 lf->setPriority( priorityD );
325 }
326
327 // z-Index
328 double zIndex = mSettings.zIndex();
331 {
334 }
335 lf->setZIndex( zIndex );
336
337 // label distance
338 QgsPointXY ptZero = mapSettings.mapToPixel().toMapCoordinates( 0, 0 );
339 QgsPointXY ptOne = mapSettings.mapToPixel().toMapCoordinates( 1, 0 );
340 double dist = mSettings.distance();
341
344 {
347 }
348
349 dist *= ptOne.distance( ptZero );
350
351 lf->setDistLabel( dist );
352 return lf;
353}
354
LabelPlacement
Placement modes which determine how label candidates are generated for a feature.
Definition qgis.h:1125
GeometryType
The geometry types are used to group Qgis::WkbType in a coarse way.
Definition qgis.h:337
@ Reverse
Reverse/inverse transform (from destination to source)
virtual QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest())=0
Gets an iterator for features matching the specified request.
The QgsAbstractLabelProvider class is an interface class.
QString mName
Name of the layer.
QString mLayerId
Associated layer's ID, if applicable.
double mPriority
Default priority of labels.
const QgsLabelingEngine * mEngine
Associated labeling engine.
QgsMapLayer * layer() const
Returns the associated layer, or nullptr if no layer is associated with the provider.
Qgis::LabelPlacement mPlacement
Placement strategy.
QgsWeakMapLayerPointer mLayer
Weak pointer to source layer.
bool valueAsBool(int key, const QgsExpressionContext &context, bool defaultValue=false, bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as an boolean.
double valueAsDouble(int key, const QgsExpressionContext &context, double defaultValue=0.0, bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as a double.
Class for doing transforms between two map coordinate systems.
void setBallparkTransformsAreAppropriate(bool appropriate)
Sets whether approximate "ballpark" results are appropriate for this coordinate transform.
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...
bool isShortCircuited() const
Returns true if the transform short circuits because the source and destination are equivalent.
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...
Class that adds extra information to QgsLabelFeature for labeling of diagrams.
Stores the settings for rendering of all diagrams for a layer.
Placement placement() const
Returns the diagram placement.
QgsCoordinateTransform coordinateTransform() const
Returns the coordinate transform associated with the layer, or an invalid transform if no transformat...
void setRenderer(QgsDiagramRenderer *diagramRenderer)
Sets the diagram renderer associated with the layer.
bool showAllDiagrams() const
Returns whether the layer should show all diagrams, including overlapping diagrams.
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the diagram's property collection, used for data defined overrides.
@ PositionX
X-coordinate data defined diagram position.
@ Distance
Distance to diagram from feature.
@ PositionY
Y-coordinate data defined diagram position.
@ Show
Whether to show the diagram.
@ Priority
Diagram priority (between 0 and 10)
@ ZIndex
Z-index for diagram ordering.
@ IsObstacle
Whether diagram features act as obstacles for other diagrams/labels.
@ AlwaysShow
Whether the diagram should always be shown, even if it overlaps other diagrams/labels.
int priority() const
Returns the diagram priority.
QSet< QString > referencedFields(const QgsExpressionContext &context=QgsExpressionContext()) const
Returns the set of any fields referenced by the layer's diagrams.
QgsDiagramRenderer * renderer()
Returns the diagram renderer associated with the layer.
bool isObstacle() const
Returns whether the feature associated with a diagram acts as an obstacle for other labels or diagram...
bool prepare(const QgsExpressionContext &context=QgsExpressionContext()) const
Prepares the diagrams for a specified expression context.
void setCoordinateTransform(const QgsCoordinateTransform &transform)
Sets the coordinate transform associated with the layer.
double zIndex() const
Returns the diagram z-index.
double distance() const
Returns the distance between the diagram and the feature (in mm).
Evaluates and returns the diagram settings relating to a diagram for a specific feature.
virtual void renderDiagram(const QgsFeature &feature, QgsRenderContext &c, QPointF pos, const QgsPropertyCollection &properties=QgsPropertyCollection()) const
Renders the diagram for a specified feature at a specific position in the passed render context.
virtual QSizeF sizeMapUnits(const QgsFeature &feature, const QgsRenderContext &c) const
Returns size of the diagram for a feature in map units. Returns an invalid QSizeF in case of error.
virtual QList< QgsDiagramSettings > diagramSettings() const =0
Returns list with all diagram settings in the renderer.
RAII class to pop scope from an expression context on destruction.
Single scope for storing variables and functions for use within a QgsExpressionContext.
void setOriginalValueVariable(const QVariant &value)
Sets the original value variable value for the context.
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
Abstract interface for use by classes that filter the features or attributes of a layer.
virtual void filterFeatures(const QgsVectorLayer *layer, QgsFeatureRequest &featureRequest) const =0
Add additional filters to the feature request to further restrict the features returned by the reques...
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
This class wraps a request for features to a vector layer (or directly its vector data provider).
QgsFeatureRequest & setSubsetOfAttributes(const QgsAttributeList &attrs)
Set a subset of attributes that will be fetched.
QgsFeatureRequest & setFilterRect(const QgsRectangle &rectangle)
Sets the rectangle from which features will be taken.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:58
QgsGeometry geometry
Definition qgsfeature.h:69
A geometry is the spatial representation of a feature.
static QgsGeometry fromRect(const QgsRectangle &rect)
Creates a new geometry from a QgsRectangle.
Qgis::GeometryType type
QgsGeometry intersection(const QgsGeometry &geometry, const QgsGeometryParameters &parameters=QgsGeometryParameters()) const
Returns a geometry representing the points shared by this geometry and other.
bool isEmpty() const
Returns true if the geometry is empty (eg a linestring with no vertices, or a collection with no geom...
bool convertGeometryCollectionToSubclass(Qgis::GeometryType geomType)
Converts geometry collection to a the desired geometry type subclass (multi-point,...
Qgis::GeometryOperationResult rotate(double rotation, const QgsPointXY &center)
Rotate this geometry around the Z axis.
static geos::unique_ptr asGeos(const QgsGeometry &geometry, double precision=0, Qgis::GeosCreationFlags flags=Qgis::GeosCreationFlags())
Returns a geos geometry - caller takes ownership of the object (should be deleted with GEOSGeom_destr...
Definition qgsgeos.cpp:257
The QgsLabelFeature class describes a feature that should be used within the labeling engine.
void setDistLabel(double dist)
Applies to "around point" placement strategy or linestring features.
void setAlwaysShow(bool enabled)
Sets whether label should be always shown (sets very high label priority)
void setZIndex(double zIndex)
Sets the label's z-index.
void setHasFixedAngle(bool enabled)
Sets whether the label should use a fixed angle instead of using angle from automatic placement.
void setObstacleSettings(const QgsLabelObstacleSettings &settings)
Sets the label's obstacle settings.
QgsFeature feature() const
Returns the original feature associated with this label.
void setPriority(double priority)
Sets the priority for labeling the feature.
void setHasFixedPosition(bool enabled)
Sets whether the label should use a fixed position instead of being automatically placed.
void setFixedPosition(const QgsPointXY &point)
Sets coordinates of the fixed position (relevant only if hasFixedPosition() returns true)
void setFixedAngle(double angle)
Sets the angle in radians of the fixed angle (relevant only if hasFixedAngle() returns true).
Contains settings related to how the label engine treats features as obstacles.
void setIsObstacle(bool isObstacle)
Sets whether features are obstacles to labels of other layers.
void setObstacleGeometry(const QgsGeometry &obstacleGeom)
Sets the label's obstacle geometry, if different to the feature geometry.
const QgsMapSettings & mapSettings() const
Gets associated map settings.
QgsLabelingResults * results() const
For internal use by the providers.
The QgsMapSettings class contains configuration for rendering of the map.
const QgsMapToPixel & mapToPixel() const
QgsRectangle visibleExtent() const
Returns the actual extent derived from requested extent that takes output image size into account.
double rotation() const
Returns the rotation of the resulting map image, in degrees clockwise.
QgsCoordinateReferenceSystem destinationCrs() const
Returns the destination coordinate reference system for the map render.
Perform transforms between map coordinates and device coordinates.
void setMapRotation(double degrees, double cx, double cy)
Sets map rotation in degrees (clockwise).
QgsPointXY toMapCoordinates(int x, int y) const
Transforms device coordinates to map (world) coordinates.
QgsPointXY transform(const QgsPointXY &p) const
Transforms a point p from map (world) coordinates to device coordinates.
static QgsGeometry prepareGeometry(const QgsGeometry &geometry, QgsRenderContext &context, const QgsCoordinateTransform &ct, const QgsGeometry &clipGeometry=QgsGeometry(), bool mergeLines=false)
Prepares a geometry for registration with PAL.
static bool geometryRequiresPreparation(const QgsGeometry &geometry, QgsRenderContext &context, const QgsCoordinateTransform &ct, const QgsGeometry &clipGeometry=QgsGeometry(), bool mergeLines=false)
Checks whether a geometry requires preparation before registration with PAL.
A class to represent a 2D point.
Definition qgspointxy.h:60
double distance(double x, double y) const
Returns the distance between this point and a specified x, y coordinate.
Definition qgspointxy.h:206
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
bool hasProperty(int key) const final
Returns true if the collection contains a property with the specified key.
QgsProperty property(int key) const final
Returns a matching property from the collection, if one exists.
bool isActive() const
Returns whether the property is currently active.
A rectangle specified with double values.
QgsPointXY center() const
Returns the center point of the rectangle.
Contains information about the context of a rendering operation.
double rendererScale() const
Returns the renderer map scale.
QgsExpressionContext & expressionContext()
Gets the expression context.
QgsCoordinateTransformContext transformContext() const
Returns the context's coordinate transform context, which stores various information regarding which ...
QgsGeometry featureClipGeometry() const
Returns the geometry to use to clip features at render time.
const QgsRectangle & extent() const
When rendering a map layer, calling this method returns the "clipping" extent for the layer (in the l...
const QgsFeatureFilterProvider * featureFilterProvider() const
Gets the filter feature provider used for additional filtering of rendered features.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context.
static bool equalToOrGreaterThanMinimumScale(const double scale, const double minScale)
Returns whether the scale is equal to or greater than the minScale, taking non-round numbers into acc...
static bool lessThanMaximumScale(const double scale, const double maxScale)
Returns whether the scale is less than the maxScale, taking non-round numbers into account.
QgsDiagramLayerSettings mSettings
Diagram layer settings.
QgsAbstractFeatureSource * mSource
Layer's feature source.
QList< QgsLabelFeature * > labelFeatures(QgsRenderContext &context) override
Returns list of label features (they are owned by the provider and thus deleted on its destruction)
void init()
initialization method - called from constructors
bool mOwnsSource
Whether layer's feature source is owned.
QgsCoordinateReferenceSystem mLayerCrs
Layer's CRS.
virtual bool prepare(const QgsRenderContext &context, QSet< QString > &attributeNames)
Prepare for registration of features.
QgsLabelFeature * registerDiagram(const QgsFeature &feat, QgsRenderContext &context, const QgsGeometry &obstacleGeometry=QgsGeometry())
helper method to register one diagram feature
virtual void registerFeature(QgsFeature &feature, QgsRenderContext &context, const QgsGeometry &obstacleGeometry=QgsGeometry())
Register a feature for labeling as one or more QgsLabelFeature objects stored into mFeatures.
QgsDiagramRenderer * mDiagRenderer
Diagram renderer instance (owned by mSettings)
QList< QgsLabelFeature * > mFeatures
List of generated label features (owned by the provider)
QgsVectorLayerDiagramProvider(QgsVectorLayer *layer, bool ownFeatureLoop=true)
Convenience constructor to initialize the provider from given vector layer.
void drawLabel(QgsRenderContext &context, pal::LabelPosition *label) const override
Draw this label at the position determined by the labeling engine.
void setClipFeatureGeometry(const QgsGeometry &geometry)
Sets a geometry to use to clip features to when registering them as diagrams.
std::unique_ptr< QgsExpressionContextScope > mLayerScope
Partial snapshot of vector layer's state (only the members necessary for access to features)
Represents a vector layer which manages a vector based data sets.
QgsFeatureId featureId() const
Returns the unique ID of the feature.
Definition feature.cpp:166
QgsLabelFeature * feature()
Returns the parent feature.
Definition feature.h:94
LabelPosition is a candidate feature label position.
double getHeight() const
double getWidth() const
FeaturePart * getFeaturePart() const
Returns the feature corresponding to this labelposition.
double getX(int i=0) const
Returns the down-left x coordinate.
double getY(int i=0) const
Returns the down-left y coordinate.
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
const QgsCoordinateReferenceSystem & crs