QGIS API Documentation  3.20.0-Odense (decaadbb31)
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 
26 #include "feature.h"
27 #include "labelposition.h"
28 
30  : QgsAbstractLabelProvider( layer )
31  , mSettings( *layer->diagramLayerSettings() )
32  , mDiagRenderer( layer->diagramRenderer()->clone() )
33  , mFields( layer->fields() )
34  , mLayerCrs( layer->crs() )
35  , mSource( ownFeatureLoop ? new QgsVectorLayerFeatureSource( layer ) : nullptr )
36  , mOwnsSource( ownFeatureLoop )
37 {
38  init();
39 }
40 
41 
43 {
44  mName = mLayerId;
45  mPriority = 1 - mSettings.priority() / 10.0; // convert 0..10 --> 1..0
47 }
48 
49 
51 {
52  if ( mOwnsSource )
53  delete mSource;
54 
55  qDeleteAll( mFeatures );
56 
57  // renderer is owned by mSettings
58 }
59 
60 
62 {
63  if ( !mSource )
64  {
65  // we have created the provider with "own feature loop" == false
66  // so it is assumed that prepare() has been already called followed by registerFeature() calls
67  return mFeatures;
68  }
69 
70  QSet<QString> attributeNames;
71  if ( !prepare( context, attributeNames ) )
72  return QList<QgsLabelFeature *>();
73 
74  QgsRectangle layerExtent = context.extent();
77 
78  QgsFeatureRequest request;
79  request.setFilterRect( layerExtent );
80  request.setSubsetOfAttributes( attributeNames, mFields );
81  const QgsFeatureFilterProvider *featureFilterProvider = context.featureFilterProvider();
82  if ( featureFilterProvider )
83  {
84  featureFilterProvider->filterFeatures( qobject_cast<QgsVectorLayer *>( mLayer ), request );
85  }
86  QgsFeatureIterator fit = mSource->getFeatures( request );
87 
88  QgsFeature fet;
89  while ( fit.nextFeature( fet ) )
90  {
91  context.expressionContext().setFeature( fet );
92  registerFeature( fet, context );
93  }
94 
95  return mFeatures;
96 }
97 
98 
100 {
101 #if 1 // XXX strk
102  // features are pre-rotated but not scaled/translated,
103  // so we only disable rotation here. Ideally, they'd be
104  // also pre-scaled/translated, as suggested here:
105  // https://github.com/qgis/QGIS/issues/20071
106  QgsMapToPixel xform = context.mapToPixel();
107  xform.setMapRotation( 0, 0, 0 );
108 #else
109  const QgsMapToPixel &xform = context.mapToPixel();
110 #endif
111 
112  QgsDiagramLabelFeature *dlf = dynamic_cast<QgsDiagramLabelFeature *>( label->getFeaturePart()->feature() );
113 
114  QgsFeature feature;
115  feature.setFields( mFields );
116  feature.setValid( true );
117  feature.setId( label->getFeaturePart()->featureId() );
118  feature.setAttributes( dlf->attributes() );
119 
120  context.expressionContext().setFeature( feature );
121 
122  //calculate top-left point for diagram
123  //first, calculate the centroid of the label (accounts for PAL creating
124  //rotated labels when we do not want to draw the diagrams rotated)
125  double centerX = 0;
126  double centerY = 0;
127  for ( int i = 0; i < 4; ++i )
128  {
129  centerX += label->getX( i );
130  centerY += label->getY( i );
131  }
132  QgsPointXY outPt( centerX / 4.0, centerY / 4.0 );
133  //then, calculate the top left point for the diagram with this center position
134  QgsPointXY centerPt = xform.transform( outPt.x() - label->getWidth() / 2,
135  outPt.y() - label->getHeight() / 2 );
136 
137  mSettings.renderer()->renderDiagram( feature, context, centerPt.toQPointF(), mSettings.dataDefinedProperties() );
138 
139  //insert into label search tree to manipulate position interactively
140  mEngine->results()->mLabelSearchTree->insertLabel( label, label->getFeaturePart()->featureId(), mLayerId, QString(), QFont(), true, false );
141 
142 }
143 
144 
145 bool QgsVectorLayerDiagramProvider::prepare( const QgsRenderContext &context, QSet<QString> &attributeNames )
146 {
148  const QgsMapSettings &mapSettings = mEngine->mapSettings();
149 
150  if ( context.coordinateTransform().isValid() )
151  // this is context for layer rendering
153  else
154  {
155  // otherwise fall back to creating our own CT
157  }
158 
160 
161  bool result = s2.prepare( context.expressionContext() );
162 
163  //add attributes needed by the diagram renderer
164  attributeNames.unite( s2.referencedFields( context.expressionContext() ) );
165 
166  return result;
167 }
168 
169 
171 {
172  QgsLabelFeature *label = registerDiagram( feature, context, obstacleGeometry );
173  if ( label )
174  mFeatures << label;
175 }
176 
178 {
179  mLabelClipFeatureGeom = geometry;
180 }
181 
183 {
184  const QgsMapSettings &mapSettings = mEngine->mapSettings();
185 
186  const QgsDiagramRenderer *dr = mSettings.renderer();
187  if ( dr )
188  {
189  QList<QgsDiagramSettings> settingList = dr->diagramSettings();
190  if ( !settingList.isEmpty() && settingList.at( 0 ).scaleBasedVisibility )
191  {
192  double maxScale = settingList.at( 0 ).maximumScale;
193  if ( maxScale > 0 && context.rendererScale() < maxScale )
194  {
195  return nullptr;
196  }
197 
198  double minScale = settingList.at( 0 ).minimumScale;
199  if ( minScale > 0 && context.rendererScale() > minScale )
200  {
201  return nullptr;
202  }
203  }
204  }
205 
206  // data defined show diagram? check this before doing any other processing
208  return nullptr;
209 
210  // data defined obstacle?
212 
213  //convert geom to geos
214  QgsGeometry geom = feat.geometry();
215  QgsGeometry extentGeom = QgsGeometry::fromRect( mapSettings.visibleExtent() );
216  if ( !qgsDoubleNear( mapSettings.rotation(), 0.0 ) )
217  {
218  //PAL features are prerotated, so extent also needs to be unrotated
219  extentGeom.rotate( -mapSettings.rotation(), mapSettings.visibleExtent().center() );
220  }
221 
222  if ( QgsPalLabeling::geometryRequiresPreparation( geom, context, mSettings.coordinateTransform(), extentGeom ) )
223  {
224  geom = QgsPalLabeling::prepareGeometry( geom, context, mSettings.coordinateTransform(), extentGeom );
225  }
226  if ( geom.isEmpty() )
227  return nullptr;
228 
230  if ( !clipGeometry.isEmpty() )
231  {
232  const QgsWkbTypes::GeometryType expectedType = geom.type();
233  geom = geom.intersection( clipGeometry );
234  geom.convertGeometryCollectionToSubclass( expectedType );
235  }
236  if ( geom.isEmpty() )
237  return nullptr;
238 
239  QgsGeometry preparedObstacleGeom;
240  if ( isObstacle && !obstacleGeometry.isNull() && QgsPalLabeling::geometryRequiresPreparation( obstacleGeometry, context, mSettings.coordinateTransform(), extentGeom ) )
241  {
242  preparedObstacleGeom = QgsPalLabeling::prepareGeometry( obstacleGeometry, context, mSettings.coordinateTransform(), extentGeom );
243  }
244  else if ( mSettings.isObstacle() && !obstacleGeometry.isNull() )
245  {
246  preparedObstacleGeom = obstacleGeometry;
247  }
248 
249  double diagramWidth = 0;
250  double diagramHeight = 0;
251  if ( dr )
252  {
253  QSizeF diagSize = dr->sizeMapUnits( feat, context );
254  if ( diagSize.isValid() )
255  {
256  diagramWidth = diagSize.width();
257  diagramHeight = diagSize.height();
258  }
259  }
260 
261  // feature to the layer
262  bool alwaysShow = mSettings.showAllDiagrams();
263  context.expressionContext().setOriginalValueVariable( alwaysShow );
265 
266  // new style data defined position
267  bool ddPos = false;
268  double ddPosX = 0.0;
269  double ddPosY = 0.0;
274  {
275  ddPosX = mSettings.dataDefinedProperties().valueAsDouble( QgsDiagramLayerSettings::PositionX, context.expressionContext(), std::numeric_limits<double>::quiet_NaN() );
276  ddPosY = mSettings.dataDefinedProperties().valueAsDouble( QgsDiagramLayerSettings::PositionY, context.expressionContext(), std::numeric_limits<double>::quiet_NaN() );
277 
278  ddPos = !std::isnan( ddPosX ) && !std::isnan( ddPosY );
279 
280  if ( ddPos )
281  {
283  if ( ct.isValid() && !ct.isShortCircuited() )
284  {
285  double z = 0;
286  ct.transformInPlace( ddPosX, ddPosY, z );
287  }
288  //data defined diagram position is always centered
289  ddPosX -= diagramWidth / 2.0;
290  ddPosY -= diagramHeight / 2.0;
291  }
292  }
293 
294  QgsDiagramLabelFeature *lf = new QgsDiagramLabelFeature( feat.id(), QgsGeos::asGeos( geom ), QSizeF( diagramWidth, diagramHeight ) );
295  lf->setHasFixedPosition( ddPos );
296  lf->setFixedPosition( QgsPointXY( ddPosX, ddPosY ) );
297  lf->setHasFixedAngle( true );
298  lf->setFixedAngle( 0 );
299  lf->setAlwaysShow( alwaysShow );
301  os.setIsObstacle( isObstacle );
302  os.setObstacleGeometry( preparedObstacleGeom );
303  lf->setObstacleSettings( os );
304 
305  if ( dr )
306  {
307  //append the diagram attributes to lbl
308  lf->setAttributes( feat.attributes() );
309  }
310 
311  // data defined priority?
314  {
317  priorityD = std::clamp( priorityD, 0.0, 10.0 );
318  priorityD = 1 - priorityD / 10.0; // convert 0..10 --> 1..0
319  lf->setPriority( priorityD );
320  }
321 
322  // z-Index
323  double zIndex = mSettings.zIndex();
326  {
327  context.expressionContext().setOriginalValueVariable( zIndex );
329  }
330  lf->setZIndex( zIndex );
331 
332  // label distance
333  QgsPointXY ptZero = mapSettings.mapToPixel().toMapCoordinates( 0, 0 );
334  QgsPointXY ptOne = mapSettings.mapToPixel().toMapCoordinates( 1, 0 );
335  double dist = mSettings.distance();
336 
339  {
342  }
343 
344  dist *= ptOne.distance( ptZero );
345 
346  lf->setDistLabel( dist );
347  return lf;
348 }
349 
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.
QgsWeakMapLayerPointer mLayer
Weak pointer to source layer.
QgsPalLayerSettings::Placement mPlacement
Placement strategy.
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.
bool isShortCircuited() const
Returns true if the transform short circuits because the source and destination are equivalent.
@ ReverseTransform
Transform from destination to source CRS.
QgsRectangle transformBoundingBox(const QgsRectangle &rectangle, TransformDirection direction=ForwardTransform, bool handle180Crossover=false) const SIP_THROW(QgsCsException)
Transforms a rectangle from the source CRS to the destination CRS.
void transformInPlace(double &x, double &y, double &z, TransformDirection direction=ForwardTransform) const SIP_THROW(QgsCsException)
Transforms an array of x, y and z double coordinates in place, from the source CRS to the destination...
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.
const QgsAttributes & attributes()
Gets feature's attributes - used for rendering of diagrams.
void setAttributes(const QgsAttributes &attrs)
Store feature's attributes - used for rendering 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...
QgsDiagramRenderer * renderer()
Returns the diagram renderer associated with the layer.
@ Distance
Distance to diagram from feature.
@ IsObstacle
Whether diagram features act as obstacles for other diagrams/labels.
@ PositionX
X-coordinate data defined diagram position.
@ Priority
Diagram priority (between 0 and 10)
@ AlwaysShow
Whether the diagram should always be shown, even if it overlaps other diagrams/labels.
@ Show
Whether to show the diagram.
@ ZIndex
Z-index for diagram ordering.
@ PositionY
Y-coordinate data defined diagram position.
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.
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.
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.
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the diagram's property collection, used for data defined overrides.
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.
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.
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)
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:56
QgsAttributes attributes
Definition: qgsfeature.h:65
void setAttributes(const QgsAttributes &attrs)
Sets the feature's attributes.
Definition: qgsfeature.cpp:135
void setFields(const QgsFields &fields, bool initAttributes=false)
Assigns a field map with the feature to allow attribute access by attribute name.
Definition: qgsfeature.cpp:170
void setId(QgsFeatureId id)
Sets the feature id for this feature.
Definition: qgsfeature.cpp:115
QgsGeometry geometry
Definition: qgsfeature.h:67
void setValid(bool validity)
Sets the validity of the feature.
Definition: qgsfeature.cpp:196
Q_GADGET QgsFeatureId id
Definition: qgsfeature.h:64
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:124
OperationResult rotate(double rotation, const QgsPointXY &center)
Rotate this geometry around the Z axis.
Q_GADGET bool isNull
Definition: qgsgeometry.h:126
static QgsGeometry fromRect(const QgsRectangle &rect) SIP_HOLDGIL
Creates a new geometry from a QgsRectangle.
QgsGeometry intersection(const QgsGeometry &geometry) const
Returns a geometry representing the points shared by this geometry and other.
QgsWkbTypes::GeometryType type
Definition: qgsgeometry.h:127
bool isEmpty() const
Returns true if the geometry is empty (eg a linestring with no vertices, or a collection with no geom...
bool convertGeometryCollectionToSubclass(QgsWkbTypes::GeometryType geomType)
Converts geometry collection to a the desired geometry type subclass (multi-point,...
static geos::unique_ptr asGeos(const QgsGeometry &geometry, double precision=0)
Returns a geos geometry - caller takes ownership of the object (should be deleted with GEOSGeom_destr...
Definition: qgsgeos.cpp:181
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.
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 angle in degrees 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 takes output image size into accou...
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.
Definition: qgsmaptopixel.h:39
void setMapRotation(double degrees, double cx, double cy)
Set map rotation in degrees (clockwise)
QgsPointXY toMapCoordinates(int x, int y) const
Transform device coordinates to map (world) coordinates.
QgsPointXY transform(const QgsPointXY &p) const
Transform the point p from map (world) coordinates to device coordinates.
Definition: qgsmaptopixel.h:82
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.
Placement
Placement modes which determine how label candidates are generated for a feature.
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
QPointF toQPointF() const
Converts a point to a QPointF.
Definition: qgspointxy.h:169
bool hasProperty(int key) const override
Returns true if the collection contains a property with the specified key.
QgsProperty property(int key) const override
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.
Definition: qgsrectangle.h:42
QgsPointXY center() const SIP_HOLDGIL
Returns the center point of the rectangle.
Definition: qgsrectangle.h:251
Contains information about the context of a rendering operation.
double rendererScale() const
Returns the renderer map scale.
QgsExpressionContext & expressionContext()
Gets the expression context.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
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 QgsFeatureFilterProvider * featureFilterProvider() const
Gets the filter feature provider used for additional filtering of rendered features.
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context.
const QgsRectangle & extent() const
When rendering a map layer, calling this method returns the "clipping" extent for the layer (in the l...
QgsDiagramLayerSettings mSettings
Diagram layer settings.
QgsLabelFeature * registerDiagram(QgsFeature &feat, QgsRenderContext &context, const QgsGeometry &obstacleGeometry=QgsGeometry())
helper method to register one diagram feature
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.
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.
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.
GeometryType
The geometry types are used to group QgsWkbTypes::Type in a coarse way.
Definition: qgswkbtypes.h:141
QgsFeatureId featureId() const
Returns the unique ID of the feature.
Definition: feature.cpp:161
QgsLabelFeature * feature()
Returns the parent feature.
Definition: feature.h:94
LabelPosition is a candidate feature label position.
Definition: labelposition.h:56
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:598
const QgsCoordinateReferenceSystem & crs