QGIS API Documentation 3.41.0-Master (d5b93354e9c)
Loading...
Searching...
No Matches
qgssymbollayer.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgssymbollayer.cpp
3 ---------------------
4 begin : November 2009
5 copyright : (C) 2009 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 "qgssymbollayer.h"
17#include "qgsrendercontext.h"
18#include "qgsdxfexport.h"
20#include "qgspainteffect.h"
22#include "qgsproperty.h"
24#include "qgssymbollayerutils.h"
25#include "qgslegendpatchshape.h"
26#include "qgsstyle.h"
28#include "qgssymbol.h"
30#include "qgsgeos.h"
31
32#include <QSize>
33#include <QPainter>
34#include <QPointF>
35#include <QPolygonF>
36#include <QUuid>
37
38QgsPropertiesDefinition QgsSymbolLayer::sPropertyDefinitions;
39
40void QgsSymbolLayer::initPropertyDefinitions()
41{
42 if ( !sPropertyDefinitions.isEmpty() )
43 return;
44
45 QString origin = QStringLiteral( "symbol" );
46
47 sPropertyDefinitions = QgsPropertiesDefinition
48 {
49 { static_cast< int >( QgsSymbolLayer::Property::Size ), QgsPropertyDefinition( "size", QObject::tr( "Symbol size" ), QgsPropertyDefinition::Size, origin ) },
50 { static_cast< int >( QgsSymbolLayer::Property::Angle ), QgsPropertyDefinition( "angle", QObject::tr( "Rotation angle" ), QgsPropertyDefinition::Rotation, origin ) },
51 { static_cast< int >( QgsSymbolLayer::Property::Name ), QgsPropertyDefinition( "name", QObject::tr( "Symbol name" ), QgsPropertyDefinition::String, origin ) },
52 { static_cast< int >( QgsSymbolLayer::Property::FillColor ), QgsPropertyDefinition( "fillColor", QObject::tr( "Symbol fill color" ), QgsPropertyDefinition::ColorWithAlpha, origin ) },
53 { static_cast< int >( QgsSymbolLayer::Property::StrokeColor ), QgsPropertyDefinition( "outlineColor", QObject::tr( "Symbol stroke color" ), QgsPropertyDefinition::ColorWithAlpha, origin ) },
54 { static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ), QgsPropertyDefinition( "outlineWidth", QObject::tr( "Symbol stroke width" ), QgsPropertyDefinition::StrokeWidth, origin ) },
55 { static_cast< int >( QgsSymbolLayer::Property::StrokeStyle ), QgsPropertyDefinition( "outlineStyle", QObject::tr( "Symbol stroke style" ), QgsPropertyDefinition::LineStyle, origin )},
56 { static_cast< int >( QgsSymbolLayer::Property::Offset ), QgsPropertyDefinition( "offset", QObject::tr( "Symbol offset" ), QgsPropertyDefinition::Offset, origin )},
57 { static_cast< int >( QgsSymbolLayer::Property::Character ), QgsPropertyDefinition( "char", QObject::tr( "Marker character(s)" ), QgsPropertyDefinition::String, origin )},
58 { static_cast< int >( QgsSymbolLayer::Property::FontFamily ), QgsPropertyDefinition( "fontFamily", QObject::tr( "Font family" ), QgsPropertyDefinition::String, origin )},
59 { static_cast< int >( QgsSymbolLayer::Property::FontStyle ), QgsPropertyDefinition( "fontStyle", QObject::tr( "Font style" ), QgsPropertyDefinition::String, origin )},
60 { static_cast< int >( QgsSymbolLayer::Property::Width ), QgsPropertyDefinition( "width", QObject::tr( "Symbol width" ), QgsPropertyDefinition::DoublePositive, origin )},
61 { static_cast< int >( QgsSymbolLayer::Property::Height ), QgsPropertyDefinition( "height", QObject::tr( "Symbol height" ), QgsPropertyDefinition::DoublePositive, origin )},
62 { static_cast< int >( QgsSymbolLayer::Property::PreserveAspectRatio ), QgsPropertyDefinition( "preserveAspectRatio", QObject::tr( "Preserve aspect ratio between width and height" ), QgsPropertyDefinition::Boolean, origin )},
63 { static_cast< int >( QgsSymbolLayer::Property::FillStyle ), QgsPropertyDefinition( "fillStyle", QObject::tr( "Symbol fill style" ), QgsPropertyDefinition::FillStyle, origin )},
64 { static_cast< int >( QgsSymbolLayer::Property::JoinStyle ), QgsPropertyDefinition( "joinStyle", QObject::tr( "Outline join style" ), QgsPropertyDefinition::PenJoinStyle, origin )},
65 { static_cast< int >( QgsSymbolLayer::Property::SecondaryColor ), QgsPropertyDefinition( "color2", QObject::tr( "Secondary fill color" ), QgsPropertyDefinition::ColorWithAlpha, origin )},
66 { static_cast< int >( QgsSymbolLayer::Property::LineAngle ), QgsPropertyDefinition( "lineAngle", QObject::tr( "Angle for line fills" ), QgsPropertyDefinition::Rotation, origin )},
67 { static_cast< int >( QgsSymbolLayer::Property::GradientType ), QgsPropertyDefinition( "gradientType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Gradient type" ), QObject::tr( "string " ) + QLatin1String( "[<b>linear</b>|<b>radial</b>|<b>conical</b>]" ), origin )},
68 { static_cast< int >( QgsSymbolLayer::Property::CoordinateMode ), QgsPropertyDefinition( "gradientMode", QgsPropertyDefinition::DataTypeString, QObject::tr( "Gradient mode" ), QObject::tr( "string " ) + QLatin1String( "[<b>feature</b>|<b>viewport</b>]" ), origin )},
69 { static_cast< int >( QgsSymbolLayer::Property::GradientSpread ), QgsPropertyDefinition( "gradientSpread", QgsPropertyDefinition::DataTypeString, QObject::tr( "Gradient spread" ), QObject::tr( "string " ) + QLatin1String( "[<b>pad</b>|<b>repeat</b>|<b>reflect</b>]" ), origin )},
70 { static_cast< int >( QgsSymbolLayer::Property::GradientReference1X ), QgsPropertyDefinition( "gradientRef1X", QObject::tr( "Reference point 1 (X)" ), QgsPropertyDefinition::Double0To1, origin )},
71 { static_cast< int >( QgsSymbolLayer::Property::GradientReference1Y ), QgsPropertyDefinition( "gradientRef1Y", QObject::tr( "Reference point 1 (Y)" ), QgsPropertyDefinition::Double0To1, origin )},
72 { static_cast< int >( QgsSymbolLayer::Property::GradientReference2X ), QgsPropertyDefinition( "gradientRef2X", QObject::tr( "Reference point 2 (X)" ), QgsPropertyDefinition::Double0To1, origin )},
73 { static_cast< int >( QgsSymbolLayer::Property::GradientReference2Y ), QgsPropertyDefinition( "gradientRef2Y", QObject::tr( "Reference point 2 (Y)" ), QgsPropertyDefinition::Double0To1, origin )},
74 { static_cast< int >( QgsSymbolLayer::Property::GradientReference1IsCentroid ), QgsPropertyDefinition( "gradientRef1Centroid", QObject::tr( "Reference point 1 follows feature centroid" ), QgsPropertyDefinition::Boolean, origin )},
75 { static_cast< int >( QgsSymbolLayer::Property::GradientReference2IsCentroid ), QgsPropertyDefinition( "gradientRef2Centroid", QObject::tr( "Reference point 2 follows feature centroid" ), QgsPropertyDefinition::Boolean, origin )},
76 { static_cast< int >( QgsSymbolLayer::Property::BlurRadius ), QgsPropertyDefinition( "blurRadius", QgsPropertyDefinition::DataTypeNumeric, QObject::tr( "Blur radius" ), QObject::tr( "Integer between 0 and 18" ), origin )},
77 { static_cast< int >( QgsSymbolLayer::Property::LineDistance ), QgsPropertyDefinition( "lineDistance", QObject::tr( "Distance between lines" ), QgsPropertyDefinition::DoublePositive, origin )},
78 { static_cast< int >( QgsSymbolLayer::Property::ShapeburstUseWholeShape ), QgsPropertyDefinition( "shapeburstWholeShape", QObject::tr( "Shade whole shape" ), QgsPropertyDefinition::Boolean, origin )},
79 { static_cast< int >( QgsSymbolLayer::Property::ShapeburstMaxDistance ), QgsPropertyDefinition( "shapeburstMaxDist", QObject::tr( "Maximum distance for shapeburst fill" ), QgsPropertyDefinition::DoublePositive, origin )},
80 { static_cast< int >( QgsSymbolLayer::Property::ShapeburstIgnoreRings ), QgsPropertyDefinition( "shapeburstIgnoreRings", QObject::tr( "Ignore rings in feature" ), QgsPropertyDefinition::Boolean, origin )},
81 { static_cast< int >( QgsSymbolLayer::Property::File ), QgsPropertyDefinition( "file", QObject::tr( "Symbol file path" ), QgsPropertyDefinition::String, origin )},
82 { static_cast< int >( QgsSymbolLayer::Property::DistanceX ), QgsPropertyDefinition( "distanceX", QObject::tr( "Horizontal distance between markers" ), QgsPropertyDefinition::DoublePositive, origin )},
83 { static_cast< int >( QgsSymbolLayer::Property::DistanceY ), QgsPropertyDefinition( "distanceY", QObject::tr( "Vertical distance between markers" ), QgsPropertyDefinition::DoublePositive, origin )},
84 { static_cast< int >( QgsSymbolLayer::Property::DisplacementX ), QgsPropertyDefinition( "displacementX", QObject::tr( "Horizontal displacement between rows" ), QgsPropertyDefinition::DoublePositive, origin )},
85 { static_cast< int >( QgsSymbolLayer::Property::DisplacementY ), QgsPropertyDefinition( "displacementY", QObject::tr( "Vertical displacement between columns" ), QgsPropertyDefinition::DoublePositive, origin )},
86 { static_cast< int >( QgsSymbolLayer::Property::OffsetX ), QgsPropertyDefinition( "offsetX", QObject::tr( "Horizontal offset" ), QgsPropertyDefinition::Double, origin )},
87 { static_cast< int >( QgsSymbolLayer::Property::OffsetY ), QgsPropertyDefinition( "offsetY", QObject::tr( "Vertical offset" ), QgsPropertyDefinition::Double, origin )},
88 { static_cast< int >( QgsSymbolLayer::Property::Opacity ), QgsPropertyDefinition( "alpha", QObject::tr( "Opacity" ), QgsPropertyDefinition::Opacity, origin )},
89 { static_cast< int >( QgsSymbolLayer::Property::CustomDash ), QgsPropertyDefinition( "customDash", QgsPropertyDefinition::DataTypeString, QObject::tr( "Custom dash pattern" ), QObject::tr( "[<b><dash>;<space></b>] e.g. '8;2;1;2'" ), origin )},
90 { static_cast< int >( QgsSymbolLayer::Property::CapStyle ), QgsPropertyDefinition( "capStyle", QObject::tr( "Line cap style" ), QgsPropertyDefinition::CapStyle, origin )},
91 { static_cast< int >( QgsSymbolLayer::Property::Placement ), QgsPropertyDefinition( "placement", QgsPropertyDefinition::DataTypeString, QObject::tr( "Marker placement" ), QObject::tr( "string " ) + "[<b>interval</b>|<b>innervertices</b>|<b>vertex</b>|<b>lastvertex</b>|<b>firstvertex</b>|<b>centerpoint</b>|<b>curvepoint</b>|<b>segmentcenter</b>]", origin )},
92 { static_cast< int >( QgsSymbolLayer::Property::Interval ), QgsPropertyDefinition( "interval", QObject::tr( "Marker interval" ), QgsPropertyDefinition::DoublePositive, origin )},
93 { static_cast< int >( QgsSymbolLayer::Property::OffsetAlongLine ), QgsPropertyDefinition( "offsetAlongLine", QObject::tr( "Offset along line" ), QgsPropertyDefinition::Double, origin )},
94 { static_cast< int >( QgsSymbolLayer::Property::AverageAngleLength ), QgsPropertyDefinition( "averageAngleLength", QObject::tr( "Average line angles over" ), QgsPropertyDefinition::DoublePositive, origin )},
95 { static_cast< int >( QgsSymbolLayer::Property::HorizontalAnchor ), QgsPropertyDefinition( "hAnchor", QObject::tr( "Horizontal anchor point" ), QgsPropertyDefinition::HorizontalAnchor, origin )},
96 { static_cast< int >( QgsSymbolLayer::Property::VerticalAnchor ), QgsPropertyDefinition( "vAnchor", QObject::tr( "Vertical anchor point" ), QgsPropertyDefinition::VerticalAnchor, origin )},
97 { static_cast< int >( QgsSymbolLayer::Property::LayerEnabled ), QgsPropertyDefinition( "enabled", QObject::tr( "Layer enabled" ), QgsPropertyDefinition::Boolean, origin )},
98 { static_cast< int >( QgsSymbolLayer::Property::ArrowWidth ), QgsPropertyDefinition( "arrowWidth", QObject::tr( "Arrow line width" ), QgsPropertyDefinition::StrokeWidth, origin )},
99 { static_cast< int >( QgsSymbolLayer::Property::ArrowStartWidth ), QgsPropertyDefinition( "arrowStartWidth", QObject::tr( "Arrow line start width" ), QgsPropertyDefinition::StrokeWidth, origin )},
100 { static_cast< int >( QgsSymbolLayer::Property::ArrowHeadLength ), QgsPropertyDefinition( "arrowHeadLength", QObject::tr( "Arrow head length" ), QgsPropertyDefinition::DoublePositive, origin )},
101 { static_cast< int >( QgsSymbolLayer::Property::ArrowHeadThickness ), QgsPropertyDefinition( "arrowHeadThickness", QObject::tr( "Arrow head thickness" ), QgsPropertyDefinition::DoublePositive, origin )},
102 { static_cast< int >( QgsSymbolLayer::Property::ArrowHeadType ), QgsPropertyDefinition( "arrowHeadType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Arrow head type" ), QObject::tr( "string " ) + QLatin1String( "[<b>single</b>|<b>reversed</b>|<b>double</b>]" ), origin )},
103 { static_cast< int >( QgsSymbolLayer::Property::ArrowType ), QgsPropertyDefinition( "arrowType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Arrow type" ), QObject::tr( "string " ) + QLatin1String( "[<b>plain</b>|<b>lefthalf</b>|<b>righthalf</b>]" ), origin )},
104 { static_cast< int >( QgsSymbolLayer::Property::PointCount ), QgsPropertyDefinition( "pointCount", QObject::tr( "Point count" ), QgsPropertyDefinition::IntegerPositive, origin )},
105 { static_cast< int >( QgsSymbolLayer::Property::RandomSeed ), QgsPropertyDefinition( "randomSeed", QgsPropertyDefinition::DataTypeNumeric, QObject::tr( "Random number seed" ), QObject::tr( "integer > 0, or 0 for completely random sequence" ), origin )},
106 { static_cast< int >( QgsSymbolLayer::Property::ClipPoints ), QgsPropertyDefinition( "clipPoints", QObject::tr( "Clip markers" ), QgsPropertyDefinition::Boolean, origin )},
107 { static_cast< int >( QgsSymbolLayer::Property::DensityArea ), QgsPropertyDefinition( "densityArea", QObject::tr( "Density area" ), QgsPropertyDefinition::DoublePositive, origin )},
108 { static_cast< int >( QgsSymbolLayer::Property::DashPatternOffset ), QgsPropertyDefinition( "dashPatternOffset", QObject::tr( "Dash pattern offset" ), QgsPropertyDefinition::DoublePositive, origin )},
109 { static_cast< int >( QgsSymbolLayer::Property::TrimStart ), QgsPropertyDefinition( "trimStart", QObject::tr( "Start trim distance" ), QgsPropertyDefinition::DoublePositive, origin )},
110 { static_cast< int >( QgsSymbolLayer::Property::TrimEnd ), QgsPropertyDefinition( "trimEnd", QObject::tr( "End trim distance" ), QgsPropertyDefinition::DoublePositive, origin )},
111 { static_cast< int >( QgsSymbolLayer::Property::LineStartWidthValue ), QgsPropertyDefinition( "lineStartWidthValue", QObject::tr( "Line start width value" ), QgsPropertyDefinition::Double, origin )},
112 { static_cast< int >( QgsSymbolLayer::Property::LineEndWidthValue ), QgsPropertyDefinition( "lineEndWidthValue", QObject::tr( "Line end width value" ), QgsPropertyDefinition::Double, origin )},
113 { static_cast< int >( QgsSymbolLayer::Property::LineStartColorValue ), QgsPropertyDefinition( "lineStartColorValue", QObject::tr( "Line start color value" ), QgsPropertyDefinition::Double, origin )},
114 { static_cast< int >( QgsSymbolLayer::Property::LineEndColorValue ), QgsPropertyDefinition( "lineEndColorValue", QObject::tr( "Line end color value" ), QgsPropertyDefinition::Double, origin )},
115 { static_cast< int >( QgsSymbolLayer::Property::MarkerClipping ), QgsPropertyDefinition( "markerClipping", QgsPropertyDefinition::DataTypeString, QObject::tr( "Marker clipping mode" ), QObject::tr( "string " ) + QLatin1String( "[<b>no</b>|<b>shape</b>|<b>centroid_within</b>|<b>completely_within</b>]" ), origin )},
116 { static_cast< int >( QgsSymbolLayer::Property::RandomOffsetX ), QgsPropertyDefinition( "randomOffsetX", QObject::tr( "Horizontal random offset" ), QgsPropertyDefinition::Double, origin )},
117 { static_cast< int >( QgsSymbolLayer::Property::RandomOffsetY ), QgsPropertyDefinition( "randomOffsetY", QObject::tr( "Vertical random offset" ), QgsPropertyDefinition::Double, origin )},
118 { static_cast< int >( QgsSymbolLayer::Property::LineClipping ), QgsPropertyDefinition( "lineClipping", QgsPropertyDefinition::DataTypeString, QObject::tr( "Line clipping mode" ), QObject::tr( "string " ) + QLatin1String( "[<b>no</b>|<b>during_render</b>|<b>before_render</b>]" ), origin )},
119 { static_cast< int >( QgsSymbolLayer::Property::SkipMultiples ), QgsPropertyDefinition( "skipMultiples", QObject::tr( "Skip multiples of" ), QgsPropertyDefinition::DoublePositive, origin )},
120 { static_cast< int >( QgsSymbolLayer::Property::ShowMarker ), QgsPropertyDefinition( "showMarker", QObject::tr( "Show marker" ), QgsPropertyDefinition::Boolean, origin )},
121 };
122}
123
128
130{
131 installMasks( context, false );
132
133 if ( QgsSymbol *lSubSymbol = subSymbol() )
134 lSubSymbol->startFeatureRender( feature, context );
135}
136
138{
139 if ( QgsSymbol *lSubSymbol = subSymbol() )
140 lSubSymbol->stopFeatureRender( feature, context );
141
142 removeMasks( context, false );
143}
144
146{
147 return nullptr;
148}
149
151{
152 delete symbol;
153 return false;
154}
155
156bool QgsSymbolLayer::writeDxf( QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift ) const
157{
158 Q_UNUSED( e )
159 Q_UNUSED( mmMapUnitScaleFactor )
160 Q_UNUSED( layerName )
161 Q_UNUSED( context )
162 Q_UNUSED( shift )
163 return false;
164}
165
167{
168 Q_UNUSED( e )
169 Q_UNUSED( context )
170 return 1.0;
171}
172
174{
175 Q_UNUSED( e )
176 Q_UNUSED( context )
177 return 1.0;
178}
179
181{
182 Q_UNUSED( e )
183 Q_UNUSED( context )
184 return 0.0;
185}
186
188{
189 Q_UNUSED( context )
190 return color();
191}
192
194{
195 Q_UNUSED( context )
196 return 0.0;
197}
198
200{
201 Q_UNUSED( unit )
202 return QVector<qreal>();
203}
204
205Qt::PenStyle QgsSymbolLayer::dxfPenStyle() const
206{
207 return Qt::SolidLine;
208}
209
211{
212 Q_UNUSED( context )
213 return color();
214}
215
216Qt::BrushStyle QgsSymbolLayer::dxfBrushStyle() const
217{
218 return Qt::NoBrush;
219}
220
222{
223 return mPaintEffect.get();
224}
225
227{
228 if ( effect == mPaintEffect.get() )
229 return;
230
231 mPaintEffect.reset( effect );
232}
233
235 : mType( other.mType )
236 , mEnabled( other.mEnabled )
237 , mUserFlags( other.mUserFlags )
238 , mLocked( other.mLocked )
239 , mColor( other.mColor )
240 , mRenderingPass( other.mRenderingPass )
241 , mId( other.mId )
242 , mDataDefinedProperties( other.mDataDefinedProperties )
243 , mPaintEffect( other.mPaintEffect ? other.mPaintEffect->clone() : nullptr )
244 , mFields( other.mFields )
245 , mClipPath( other.mClipPath )
246{
247}
248
250 : mType( type )
251 , mLocked( locked )
252 , mId( QUuid::createUuid().toString() )
253{
254}
255
260
265
270
272{
273 return mColor;
274}
275
276void QgsSymbolLayer::setColor( const QColor &color )
277{
278 mColor = color;
279}
280
281void QgsSymbolLayer::setStrokeColor( const QColor & )
282{
283
284}
285
287{
288 return QColor();
289}
290
291void QgsSymbolLayer::setFillColor( const QColor & )
292{
293}
294
296{
297 return QColor();
298}
299
301{
303
304 if ( !context.fields().isEmpty() )
305 {
306 //QgsFields is implicitly shared, so it's cheap to make a copy
307 mFields = context.fields();
308 }
309}
310
315
317{
318 QgsSymbolLayer::initPropertyDefinitions();
319 return sPropertyDefinitions;
320}
321
323
325{
327 return true;
328
329 return symbol->type() == mType;
330}
331
333{
334 return false;
335}
336
338{
339 return false;
340}
341
342void QgsSymbolLayer::setRenderingPass( int renderingPass )
343{
345}
346
348{
349 return mRenderingPass;
350}
351
352QSet<QString> QgsSymbolLayer::usedAttributes( const QgsRenderContext &context ) const
353{
354 // calling referencedFields() with ignoreContext=true because in our expression context
355 // we do not have valid QgsFields yet - because of that the field names from expressions
356 // wouldn't get reported
357 QSet<QString> columns = mDataDefinedProperties.referencedFields( context.expressionContext(), true );
358 return columns;
359}
360
361QgsProperty propertyFromMap( const QVariantMap &map, const QString &baseName )
362{
363 QString prefix;
364 if ( !baseName.isEmpty() )
365 {
366 prefix.append( QStringLiteral( "%1_dd_" ).arg( baseName ) );
367 }
368
369 if ( !map.contains( QStringLiteral( "%1expression" ).arg( prefix ) ) )
370 {
371 //requires at least the expression value
372 return QgsProperty();
373 }
374
375 bool active = ( map.value( QStringLiteral( "%1active" ).arg( prefix ), QStringLiteral( "1" ) ) != QLatin1String( "0" ) );
376 QString expression = map.value( QStringLiteral( "%1expression" ).arg( prefix ) ).toString();
377 bool useExpression = ( map.value( QStringLiteral( "%1useexpr" ).arg( prefix ), QStringLiteral( "1" ) ) != QLatin1String( "0" ) );
378 QString field = map.value( QStringLiteral( "%1field" ).arg( prefix ), QString() ).toString();
379
380 if ( useExpression )
381 return QgsProperty::fromExpression( expression, active );
382 else
383 return QgsProperty::fromField( field, active );
384}
385
386void QgsSymbolLayer::restoreOldDataDefinedProperties( const QVariantMap &stringMap )
387{
388 // property string to type upgrade map
389 static const QMap < QString, int > OLD_PROPS
390 {
391 { "color", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },
392 { "arrow_width", static_cast< int >( QgsSymbolLayer::Property::ArrowWidth ) },
393 { "arrow_start_width", static_cast< int >( QgsSymbolLayer::Property::ArrowStartWidth ) },
394 { "head_length", static_cast< int >( QgsSymbolLayer::Property::ArrowHeadLength ) },
395 { "head_thickness", static_cast< int >( QgsSymbolLayer::Property::ArrowHeadThickness ) },
396 { "offset", static_cast< int >( QgsSymbolLayer::Property::Offset ) },
397 { "head_type", static_cast< int >( QgsSymbolLayer::Property::ArrowHeadType ) },
398 { "arrow_type", static_cast< int >( QgsSymbolLayer::Property::ArrowType ) },
399 { "width_field", static_cast< int >( QgsSymbolLayer::Property::Width ) },
400 { "height_field", static_cast< int >( QgsSymbolLayer::Property::Height ) },
401 { "rotation_field", static_cast< int >( QgsSymbolLayer::Property::Angle ) },
402 { "outline_width_field", static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ) },
403 { "fill_color_field", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },
404 { "outline_color_field", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },
405 { "symbol_name_field", static_cast< int >( QgsSymbolLayer::Property::Name ) },
406 { "outline_width", static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ) },
407 { "outline_style", static_cast< int >( QgsSymbolLayer::Property::StrokeStyle ) },
408 { "join_style", static_cast< int >( QgsSymbolLayer::Property::JoinStyle ) },
409 { "fill_color", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },
410 { "outline_color", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },
411 { "width", static_cast< int >( QgsSymbolLayer::Property::Width ) },
412 { "height", static_cast< int >( QgsSymbolLayer::Property::Height ) },
413 { "symbol_name", static_cast< int >( QgsSymbolLayer::Property::Name ) },
414 { "angle", static_cast< int >( QgsSymbolLayer::Property::Angle ) },
415 { "fill_style", static_cast< int >( QgsSymbolLayer::Property::FillStyle ) },
416 { "color_border", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },
417 { "width_border", static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ) },
418 { "border_color", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },
419 { "border_style", static_cast< int >( QgsSymbolLayer::Property::StrokeStyle ) },
420 { "color2", static_cast< int >( QgsSymbolLayer::Property::SecondaryColor ) },
421 { "gradient_type", static_cast< int >( QgsSymbolLayer::Property::GradientType ) },
422 { "coordinate_mode", static_cast< int >( QgsSymbolLayer::Property::CoordinateMode )},
423 { "spread", static_cast< int >( QgsSymbolLayer::Property::GradientSpread ) },
424 { "reference1_x", static_cast< int >( QgsSymbolLayer::Property::GradientReference1X ) },
425 { "reference1_y", static_cast< int >( QgsSymbolLayer::Property::GradientReference1Y ) },
426 { "reference2_x", static_cast< int >( QgsSymbolLayer::Property::GradientReference2X ) },
427 { "reference2_y", static_cast< int >( QgsSymbolLayer::Property::GradientReference2Y )},
428 { "reference1_iscentroid", static_cast< int >( QgsSymbolLayer::Property::GradientReference1IsCentroid )},
429 { "reference2_iscentroid", static_cast< int >( QgsSymbolLayer::Property::GradientReference2IsCentroid )},
430 { "blur_radius", static_cast< int >( QgsSymbolLayer::Property::BlurRadius ) },
431 { "use_whole_shape", static_cast< int >( QgsSymbolLayer::Property::ShapeburstUseWholeShape ) },
432 { "max_distance", static_cast< int >( QgsSymbolLayer::Property::ShapeburstMaxDistance ) },
433 { "ignore_rings", static_cast< int >( QgsSymbolLayer::Property::ShapeburstIgnoreRings ) },
434 { "svgFillColor", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },
435 { "svgOutlineColor", static_cast< int >( QgsSymbolLayer::Property::StrokeColor ) },
436 { "svgOutlineWidth", static_cast< int >( QgsSymbolLayer::Property::StrokeWidth ) },
437 { "svgFile", static_cast< int >( QgsSymbolLayer::Property::File ) },
438 { "lineangle", static_cast< int >( QgsSymbolLayer::Property::LineAngle ) },
439 { "distance", static_cast< int >( QgsSymbolLayer::Property::LineDistance )},
440 { "distance_x", static_cast< int >( QgsSymbolLayer::Property::DistanceX )},
441 { "distance_y", static_cast< int >( QgsSymbolLayer::Property::DistanceY ) },
442 { "displacement_x", static_cast< int >( QgsSymbolLayer::Property::DisplacementX )},
443 { "displacement_y", static_cast< int >( QgsSymbolLayer::Property::DisplacementY ) },
444 { "file", static_cast< int >( QgsSymbolLayer::Property::File ) },
445 { "alpha", static_cast< int >( QgsSymbolLayer::Property::Opacity )},
446 { "customdash", static_cast< int >( QgsSymbolLayer::Property::CustomDash ) },
447 { "line_style", static_cast< int >( QgsSymbolLayer::Property::StrokeStyle ) },
448 { "joinstyle", static_cast< int >( QgsSymbolLayer::Property::JoinStyle ) },
449 { "capstyle", static_cast< int >( QgsSymbolLayer::Property::CapStyle ) },
450 { "placement", static_cast< int >( QgsSymbolLayer::Property::Placement ) },
451 { "interval", static_cast< int >( QgsSymbolLayer::Property::Interval ) },
452 { "offset_along_line", static_cast< int >( QgsSymbolLayer::Property::OffsetAlongLine ) },
453 { "name", static_cast< int >( QgsSymbolLayer::Property::Name ) },
454 { "size", static_cast< int >( QgsSymbolLayer::Property::Size ) },
455 { "fill", static_cast< int >( QgsSymbolLayer::Property::FillColor ) },
456 { "outline", static_cast< int >( QgsSymbolLayer::Property::StrokeColor )},
457 { "char", static_cast< int >( QgsSymbolLayer::Property::Character )},
458 { "enabled", static_cast< int >( QgsSymbolLayer::Property::LayerEnabled ) },
459 { "rotation", static_cast< int >( QgsSymbolLayer::Property::Angle )},
460 { "horizontal_anchor_point", static_cast< int >( QgsSymbolLayer::Property::HorizontalAnchor ) },
461 { "vertical_anchor_point", static_cast< int >( QgsSymbolLayer::Property::VerticalAnchor ) },
462 };
463
464 QVariantMap::const_iterator propIt = stringMap.constBegin();
465 for ( ; propIt != stringMap.constEnd(); ++propIt )
466 {
467 std::unique_ptr<QgsProperty> prop;
468 QString propertyName;
469
470 if ( propIt.key().endsWith( QLatin1String( "_dd_expression" ) ) )
471 {
472 //found a data defined property
473
474 //get data defined property name by stripping "_dd_expression" from property key
475 propertyName = propIt.key().left( propIt.key().length() - 14 );
476
477 prop = std::make_unique<QgsProperty>( propertyFromMap( stringMap, propertyName ) );
478 }
479 else if ( propIt.key().endsWith( QLatin1String( "_expression" ) ) )
480 {
481 //old style data defined property, upgrade
482
483 //get data defined property name by stripping "_expression" from property key
484 propertyName = propIt.key().left( propIt.key().length() - 11 );
485
486 prop = std::make_unique<QgsProperty>( QgsProperty::fromExpression( propIt.value().toString() ) );
487 }
488
489 if ( !prop || !OLD_PROPS.contains( propertyName ) )
490 continue;
491
492 int key = OLD_PROPS.value( propertyName );
493
494 if ( type() == Qgis::SymbolType::Line )
495 {
496 //these keys had different meaning for line symbol layers
497 if ( propertyName == QLatin1String( "width" ) )
498 key = static_cast< int >( QgsSymbolLayer::Property::StrokeWidth );
499 else if ( propertyName == QLatin1String( "color" ) )
500 key = static_cast< int >( QgsSymbolLayer::Property::StrokeColor );
501 }
502
503 setDataDefinedProperty( static_cast< QgsSymbolLayer::Property >( key ), QgsProperty( *prop.get() ) );
504 }
505}
506
508{
509 if ( !destLayer )
510 return;
511
513}
514
516{
517 if ( !destLayer || !mPaintEffect )
518 return;
519
521 destLayer->setPaintEffect( mPaintEffect->clone() );
522 else
523 destLayer->setPaintEffect( nullptr );
524}
525
527 : QgsSymbolLayer( Qgis::SymbolType::Marker, locked )
528{
529
530}
531
533 : QgsSymbolLayer( Qgis::SymbolType::Line, locked )
534{
535}
536
541
543{
544 mRingFilter = filter;
545}
546
548 : QgsSymbolLayer( Qgis::SymbolType::Fill, locked )
549{
550}
551
553 : QgsSymbolLayer( other )
554 , mAngle( other.mAngle )
555 , mLineAngle( other.mLineAngle )
556 , mSize( other.mSize )
557 , mSizeUnit( other.mSizeUnit )
558 , mSizeMapUnitScale( other.mSizeMapUnitScale )
559 , mOffset( other.mOffset )
560 , mOffsetUnit( other.mOffsetUnit )
561 , mOffsetMapUnitScale( other.mOffsetMapUnitScale )
562 , mScaleMethod( other.mScaleMethod )
563 , mHorizontalAnchorPoint( other.mHorizontalAnchorPoint )
564 , mVerticalAnchorPoint( other.mVerticalAnchorPoint )
565{
566
567}
568
570{
571 Q_UNUSED( context )
572}
573
575{
576 Q_UNUSED( context )
577}
578
580{
581 startRender( context );
582 QgsPaintEffect *effect = paintEffect();
583
584 QPolygonF points = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Marker, size ).value( 0 ).value( 0 )
586
587 std::unique_ptr< QgsEffectPainter > effectPainter;
588 if ( effect && effect->enabled() )
589 effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );
590
591 for ( QPointF point : std::as_const( points ) )
592 renderPoint( point, context );
593
594 effectPainter.reset();
595
596 stopRender( context );
597}
598
599void QgsMarkerSymbolLayer::markerOffset( QgsSymbolRenderContext &context, double &offsetX, double &offsetY ) const
600{
602}
603
604void QgsMarkerSymbolLayer::markerOffset( QgsSymbolRenderContext &context, double width, double height, double &offsetX, double &offsetY ) const
605{
606 markerOffset( context, width, height, mSizeUnit, mSizeUnit, offsetX, offsetY, mSizeMapUnitScale, mSizeMapUnitScale );
607}
608
609void QgsMarkerSymbolLayer::markerOffset( QgsSymbolRenderContext &context, double width, double height,
610 Qgis::RenderUnit widthUnit, Qgis::RenderUnit heightUnit,
611 double &offsetX, double &offsetY, const QgsMapUnitScale &widthMapUnitScale, const QgsMapUnitScale &heightMapUnitScale ) const
612{
613 offsetX = mOffset.x();
614 offsetY = mOffset.y();
615
617 {
620 bool ok = false;
621 const QPointF offset = QgsSymbolLayerUtils::toPoint( exprVal, &ok );
622 if ( ok )
623 {
624 offsetX = offset.x();
625 offsetY = offset.y();
626 }
627 }
628
631
635 {
637 if ( !QgsVariantUtils::isNull( exprVal ) )
638 {
639 horizontalAnchorPoint = decodeHorizontalAnchorPoint( exprVal.toString() );
640 }
641 }
643 {
645 if ( !QgsVariantUtils::isNull( exprVal ) )
646 {
647 verticalAnchorPoint = decodeVerticalAnchorPoint( exprVal.toString() );
648 }
649 }
650
651 //correct horizontal position according to anchor point
653 {
654 return;
655 }
656
657 double anchorPointCorrectionX = context.renderContext().convertToPainterUnits( width, widthUnit, widthMapUnitScale ) / 2.0;
659 {
660 // rendering for symbol previews -- an size in meters in map units can't be calculated, so treat the size as millimeters
661 // and clamp it to a reasonable range. It's the best we can do in this situation!
662 anchorPointCorrectionX = std::min( std::max( context.renderContext().convertToPainterUnits( width, Qgis::RenderUnit::Millimeters ), 3.0 ), 100.0 ) / 2.0;
663 }
664
665 double anchorPointCorrectionY = context.renderContext().convertToPainterUnits( height, heightUnit, heightMapUnitScale ) / 2.0;
667 {
668 // rendering for symbol previews -- an size in meters in map units can't be calculated, so treat the size as millimeters
669 // and clamp it to a reasonable range. It's the best we can do in this situation!
670 anchorPointCorrectionY = std::min( std::max( context.renderContext().convertToPainterUnits( height, Qgis::RenderUnit::Millimeters ), 3.0 ), 100.0 ) / 2.0;
671 }
672
674 {
675 offsetX += anchorPointCorrectionX;
676 }
677 else if ( horizontalAnchorPoint == Right )
678 {
679 offsetX -= anchorPointCorrectionX;
680 }
681
682//correct vertical position according to anchor point
683 if ( verticalAnchorPoint == Top )
684 {
685 offsetY += anchorPointCorrectionY;
686 }
687 else if ( verticalAnchorPoint == Bottom )
688 {
689 offsetY -= anchorPointCorrectionY;
690 }
691}
692
693QPointF QgsMarkerSymbolLayer::_rotatedOffset( QPointF offset, double angle )
694{
695 angle = DEG2RAD( angle );
696 double c = std::cos( angle ), s = std::sin( angle );
697 return QPointF( offset.x() * c - offset.y() * s, offset.x() * s + offset.y() * c );
698}
699
700QgsMarkerSymbolLayer::HorizontalAnchorPoint QgsMarkerSymbolLayer::decodeHorizontalAnchorPoint( const QString &str )
701{
702 if ( str.compare( QLatin1String( "left" ), Qt::CaseInsensitive ) == 0 )
703 {
705 }
706 else if ( str.compare( QLatin1String( "right" ), Qt::CaseInsensitive ) == 0 )
707 {
709 }
710 else
711 {
713 }
714}
715
716QgsMarkerSymbolLayer::VerticalAnchorPoint QgsMarkerSymbolLayer::decodeVerticalAnchorPoint( const QString &str )
717{
718 if ( str.compare( QLatin1String( "top" ), Qt::CaseInsensitive ) == 0 )
719 {
721 }
722 else if ( str.compare( QLatin1String( "bottom" ), Qt::CaseInsensitive ) == 0 )
723 {
725 }
726 else
727 {
729 }
730}
731
733{
734 mSizeUnit = unit;
735 mOffsetUnit = unit;
736}
737
739{
740 if ( mOffsetUnit != mSizeUnit )
741 {
743 }
744 return mOffsetUnit;
745}
746
752
761
763{
764 mWidthUnit = unit;
765 mOffsetUnit = unit;
766}
767
772
777
782
783
785{
786 const QList< QList< QPolygonF > > points = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Line, size )
788 startRender( context );
789 QgsPaintEffect *effect = paintEffect();
790
791 std::unique_ptr< QgsEffectPainter > effectPainter;
792 if ( effect && effect->enabled() )
793 effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );
794
795 for ( const QList< QPolygonF > &line : points )
796 renderPolyline( line.value( 0 ), context );
797
798 effectPainter.reset();
799
800 stopRender( context );
801}
802
803void QgsLineSymbolLayer::renderPolygonStroke( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context )
804{
805 QgsExpressionContextScope *scope = nullptr;
806 std::unique_ptr< QgsExpressionContextScopePopper > scopePopper;
808 {
809 scope = new QgsExpressionContextScope();
810 scopePopper = std::make_unique< QgsExpressionContextScopePopper >( context.renderContext().expressionContext(), scope );
811 }
812
813 switch ( mRingFilter )
814 {
815 case AllRings:
816 case ExteriorRingOnly:
817 {
818 if ( scope )
820 renderPolyline( points, context );
821 break;
822 }
824 break;
825 }
826
827 if ( rings )
828 {
829 switch ( mRingFilter )
830 {
831 case AllRings:
833 {
834 int ringIndex = 1;
835 for ( const QPolygonF &ring : std::as_const( *rings ) )
836 {
837 if ( scope )
839
840 renderPolyline( ring, context );
841 ringIndex++;
842 }
843 }
844 break;
845 case ExteriorRingOnly:
846 break;
847 }
848 }
849}
850
851double QgsLineSymbolLayer::width( const QgsRenderContext &context ) const
852{
854}
855
857{
858 Q_UNUSED( context )
860}
861
862
864{
865 const QList< QList< QPolygonF > > polys = context.patchShape() ? context.patchShape()->toQPolygonF( Qgis::SymbolType::Fill, size )
867
868 startRender( context );
869 QgsPaintEffect *effect = paintEffect();
870
871 std::unique_ptr< QgsEffectPainter > effectPainter;
872 if ( effect && effect->enabled() )
873 effectPainter = std::make_unique< QgsEffectPainter >( context.renderContext(), effect );
874
875 for ( const QList< QPolygonF > &poly : polys )
876 {
877 QVector< QPolygonF > rings;
878 for ( int i = 1; i < poly.size(); ++i )
879 rings << poly.at( i );
880 renderPolygon( poly.value( 0 ), &rings, context );
881 }
882
883 effectPainter.reset();
884
885 stopRender( context );
886}
887
889{
890 return QImage();
891}
892
893void QgsFillSymbolLayer::_renderPolygon( QPainter *p, const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context )
894{
895 if ( !p )
896 {
897 return;
898 }
899
900 // Disable 'Antialiasing' if the geometry was generalized in the current RenderContext (We known that it must have least #5 points).
901 if ( points.size() <= 5 &&
904 ( p->renderHints() & QPainter::Antialiasing ) )
905 {
906 p->setRenderHint( QPainter::Antialiasing, false );
907 p->drawRect( points.boundingRect() );
908 p->setRenderHint( QPainter::Antialiasing, true );
909 return;
910 }
911
912 // polygons outlines are sometimes rendered wrongly with drawPolygon, when
913 // clipped (see #13343), so use drawPath instead.
914 if ( !rings && p->pen().style() == Qt::NoPen )
915 {
916 // simple polygon without holes
917 p->drawPolygon( points );
918 }
919 else
920 {
921 // polygon with holes must be drawn using painter path
922 QPainterPath path;
923 path.addPolygon( points );
924
925 if ( rings )
926 {
927 for ( auto it = rings->constBegin(); it != rings->constEnd(); ++it )
928 {
929 QPolygonF ring = *it;
930 path.addPolygon( ring );
931 }
932 }
933
934 p->drawPath( path );
935 }
936}
937
938void QgsMarkerSymbolLayer::toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const
939{
940 QDomElement symbolizerElem = doc.createElement( QStringLiteral( "se:PointSymbolizer" ) );
941 if ( !props.value( QStringLiteral( "uom" ), QString() ).toString().isEmpty() )
942 symbolizerElem.setAttribute( QStringLiteral( "uom" ), props.value( QStringLiteral( "uom" ), QString() ).toString() );
943 element.appendChild( symbolizerElem );
944
945 // <Geometry>
946 QgsSymbolLayerUtils::createGeometryElement( doc, symbolizerElem, props.value( QStringLiteral( "geom" ), QString() ).toString() );
947
948 writeSldMarker( doc, symbolizerElem, props );
949}
950
951QList<QgsSymbolLayerReference> QgsSymbolLayer::masks() const
952{
953 return {};
954}
955
957{
958 double size = mSize;
960 {
961 bool ok = false;
963
964 if ( ok )
965 {
966 switch ( mScaleMethod )
967 {
969 size = std::sqrt( size );
970 break;
972 break;
973 }
974 }
975 }
977}
978
989
990QPainterPath generateClipPath( const QgsRenderContext &renderContext, const QString &id, const QRectF *rect, bool &foundGeometries )
991{
992 foundGeometries = false;
993 const QVector<QgsGeometry> clipGeometries = rect
995 : renderContext.symbolLayerClipGeometries( id );
996 if ( !clipGeometries.empty() )
997 {
998 foundGeometries = true;
999 QgsGeometry mergedGeom = QgsGeometry::unaryUnion( clipGeometries );
1000 if ( renderContext.maskSettings().simplifyTolerance() > 0 )
1001 {
1002 QgsGeos geos( mergedGeom.constGet() );
1003 mergedGeom = QgsGeometry( geos.simplify( renderContext.maskSettings().simplifyTolerance() ) );
1004 }
1005#if GEOS_VERSION_MAJOR==3 && GEOS_VERSION_MINOR<10
1006 // structure would be better, but too old GEOS
1007 mergedGeom = mergedGeom.makeValid( Qgis::MakeValidMethod::Linework );
1008#else
1009 mergedGeom = mergedGeom.makeValid( Qgis::MakeValidMethod::Structure );
1010#endif
1011 if ( !mergedGeom.isEmpty() )
1012 {
1013 QgsGeometry exterior;
1014 const QgsRectangle contextBounds( 0, 0,
1015 renderContext.outputSize().width(),
1016 renderContext.outputSize().height() );
1017 if ( rect )
1018 {
1019 exterior = QgsGeometry::fromRect( QgsRectangle( *rect ).intersect( contextBounds ) );
1020 }
1021 else
1022 {
1023 exterior = QgsGeometry::fromRect( contextBounds );
1024 }
1025 const QgsGeometry maskGeom = exterior.difference( mergedGeom );
1026 if ( !maskGeom.isNull() )
1027 {
1028 return maskGeom.constGet()->asQPainterPath();
1029 }
1030 }
1031 }
1032 return QPainterPath();
1033}
1034
1036{
1037 const QgsRenderContext &renderContext = context.renderContext();
1038
1039 bool foundGeometries = false;
1040 mClipPath = generateClipPath( renderContext, id(), nullptr, foundGeometries );
1041}
1042
1043bool QgsSymbolLayer::installMasks( QgsRenderContext &context, bool recursive, const QRectF &rect )
1044{
1045 bool res = false;
1046 if ( !mClipPath.isEmpty() )
1047 {
1048 context.painter()->save();
1049 context.painter()->setClipPath( mClipPath, Qt::IntersectClip );
1050 res = true;
1051 }
1052 else if ( rect.isValid() )
1053 {
1054 // find just the clip geometries within the area the symbol layer will be drawn over
1055 bool foundGeometries = false;
1056 const QPainterPath clipPath = generateClipPath( context, id(), &rect, foundGeometries );
1057 if ( !clipPath.isEmpty() )
1058 {
1059 context.painter()->setClipPath( clipPath, context.painter()->clipPath().isEmpty() ? Qt::ReplaceClip : Qt::IntersectClip );
1060 res = true;
1061 }
1062 }
1063
1064 if ( QgsSymbol *lSubSymbol = recursive ? subSymbol() : nullptr )
1065 {
1066 const QList<QgsSymbolLayer *> layers = lSubSymbol->symbolLayers();
1067 for ( QgsSymbolLayer *sl : layers )
1068 res = sl->installMasks( context, true ) || res;
1069 }
1070
1071 return res;
1072}
1073
1074void QgsSymbolLayer::removeMasks( QgsRenderContext &context, bool recursive )
1075{
1076 if ( !mClipPath.isEmpty() )
1077 {
1078 context.painter()->restore();
1079 }
1080
1081 if ( QgsSymbol *lSubSymbol = recursive ? subSymbol() : nullptr )
1082 {
1083 const QList<QgsSymbolLayer *> layers = lSubSymbol->symbolLayers();
1084 for ( QgsSymbolLayer *sl : layers )
1085 sl->removeMasks( context, true );
1086 }
1087}
1088
1093
1094void QgsSymbolLayer::setId( const QString &id )
1095{
1096 mId = id;
1097}
1098
1099QString QgsSymbolLayer::id() const
1100{
1101 return mId;
1102}
The Qgis class provides global constants for use throughout the application.
Definition qgis.h:54
@ AntialiasingSimplification
The geometries can be rendered with 'AntiAliasing' disabled because of it is '1-pixel size'.
@ ScaleDiameter
Calculate scale by the diameter.
@ ScaleArea
Calculate scale by the area.
QFlags< SymbolLayerFlag > SymbolLayerFlags
Symbol layer flags.
Definition qgis.h:821
QFlags< SymbolLayerUserFlag > SymbolLayerUserFlags
Symbol layer user flags.
Definition qgis.h:844
RenderUnit
Rendering size units.
Definition qgis.h:4892
@ Millimeters
Millimeters.
@ Unknown
Mixed or unknown units.
@ MetersInMapUnits
Meters value as Map units.
@ RenderSymbolPreview
The render is for a symbol preview only and map based properties may not be available,...
@ Linework
Combines all rings into a set of noded lines and then extracts valid polygons from that linework.
@ Structure
Structured method, first makes all rings valid and then merges shells and subtracts holes from shells...
@ DisableSelectionRecoloring
If present, indicates that the symbol layer should not be recolored when rendering selected features.
SymbolType
Symbol types.
Definition qgis.h:574
@ Marker
Marker symbol.
@ Line
Line symbol.
@ Fill
Fill symbol.
static bool isGeneralizableByDeviceBoundingBox(const QgsRectangle &envelope, float mapToPixelTol=1.0f)
Returns whether the device-envelope can be replaced by its BBOX when is applied the specified toleran...
virtual QPainterPath asQPainterPath() const =0
Returns the geometry represented as a QPainterPath.
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.
Exports QGIS layers to the DXF format.
static double mapUnitScaleFactor(double scale, Qgis::RenderUnit symbolUnits, Qgis::DistanceUnit mapUnits, double mapUnitsPerPixel=1.0)
Returns scale factor for conversion to map units.
Qgis::DistanceUnit mapUnits() const
Retrieve map units.
double symbologyScale() const
Returns the reference scale for output.
Single scope for storing variables and functions for use within a QgsExpressionContext.
void addVariable(const QgsExpressionContextScope::StaticVariable &variable)
Adds a variable into the context scope.
static const QString EXPR_GEOMETRY_RING_NUM
Inbuilt variable name for geometry ring number variable.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:58
bool isEmpty
Definition qgsfields.h:49
virtual void renderPolygon(const QPolygonF &points, const QVector< QPolygonF > *rings, QgsSymbolRenderContext &context)=0
Renders the fill symbol layer for the polygon whose outer ring is defined by points,...
void _renderPolygon(QPainter *p, const QPolygonF &points, const QVector< QPolygonF > *rings, QgsSymbolRenderContext &context)
Default method to render polygon.
virtual QImage toTiledPatternImage() const
Renders the symbol layer as an image that can be used as a seamless pattern fill for polygons,...
void drawPreviewIcon(QgsSymbolRenderContext &context, QSize size) override
QgsFillSymbolLayer(const QgsFillSymbolLayer &other)=delete
A geometry is the spatial representation of a feature.
static QgsGeometry fromRect(const QgsRectangle &rect)
Creates a new geometry from a QgsRectangle.
QgsGeometry difference(const QgsGeometry &geometry, const QgsGeometryParameters &parameters=QgsGeometryParameters()) const
Returns a geometry representing the points making up this geometry that do not make up other.
QgsGeometry makeValid(Qgis::MakeValidMethod method=Qgis::MakeValidMethod::Linework, bool keepCollapsed=false) const
Attempts to make an invalid geometry valid without losing vertices.
const QgsAbstractGeometry * constGet() const
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
bool isEmpty() const
Returns true if the geometry is empty (eg a linestring with no vertices, or a collection with no geom...
static QgsGeometry unaryUnion(const QVector< QgsGeometry > &geometries, const QgsGeometryParameters &parameters=QgsGeometryParameters())
Compute the unary union on a list of geometries.
Does vector analysis using the GEOS library and handles import, export, and exception handling.
Definition qgsgeos.h:139
QList< QList< QPolygonF > > toQPolygonF(Qgis::SymbolType type, QSizeF size) const
Converts the patch shape to a set of QPolygonF objects representing how the patch should be drawn for...
Qgis::RenderUnit mOffsetUnit
RenderRingFilter
Options for filtering rings when the line symbol layer is being used to render a polygon's rings.
@ ExteriorRingOnly
Render the exterior ring only.
@ InteriorRingsOnly
Render the interior rings only.
@ AllRings
Render both exterior and interior rings.
QgsMapUnitScale mWidthMapUnitScale
RenderRingFilter ringFilter() const
Returns the line symbol layer's ring filter, which controls which rings are rendered when the line sy...
void drawPreviewIcon(QgsSymbolRenderContext &context, QSize size) override
QgsLineSymbolLayer(const QgsLineSymbolLayer &other)=delete
void setOutputUnit(Qgis::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
Qgis::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
virtual void renderPolygonStroke(const QPolygonF &points, const QVector< QPolygonF > *rings, QgsSymbolRenderContext &context)
Renders the line symbol layer along the outline of polygon, using the given render context.
Qgis::RenderUnit mWidthUnit
virtual void renderPolyline(const QPolygonF &points, QgsSymbolRenderContext &context)=0
Renders the line symbol layer along the line joining points, using the given render context.
RenderRingFilter mRingFilter
virtual double width() const
Returns the estimated width for the line symbol layer.
double dxfWidth(const QgsDxfExport &e, QgsSymbolRenderContext &context) const override
Gets line width.
QgsMapUnitScale mapUnitScale() const override
void setRingFilter(QgsLineSymbolLayer::RenderRingFilter filter)
Sets the line symbol layer's ring filter, which controls which rings are rendered when the line symbo...
void setMapUnitScale(const QgsMapUnitScale &scale) override
Qgis::RenderUnit widthUnit() const
Returns the units for the line's width.
double mapUnitsPerPixel() const
Returns the current map units per pixel.
Struct for storing maximum and minimum scales for measurements in map units.
Abstract base class for marker symbol layers.
double mSize
Marker size.
QgsMarkerSymbolLayer(const QgsMarkerSymbolLayer &other)
void drawPreviewIcon(QgsSymbolRenderContext &context, QSize size) override
Qgis::RenderUnit mOffsetUnit
Offset units.
QPointF offset() const
Returns the marker's offset, which is the horizontal and vertical displacement which the rendered mar...
HorizontalAnchorPoint
Symbol horizontal anchor points.
@ Right
Align to right side of symbol.
@ HCenter
Align to horizontal center of symbol.
@ Left
Align to left side of symbol.
Qgis::RenderUnit outputUnit() const override
Returns the units to use for sizes and widths within the symbol layer.
virtual void renderPoint(QPointF point, QgsSymbolRenderContext &context)=0
Renders a marker at the specified point.
QPointF mOffset
Marker offset.
QgsMapUnitScale mapUnitScale() const override
double size() const
Returns the symbol size.
QgsMapUnitScale mOffsetMapUnitScale
Offset map unit scale.
HorizontalAnchorPoint mHorizontalAnchorPoint
Horizontal anchor point.
static QPointF _rotatedOffset(QPointF offset, double angle)
Adjusts a marker offset to account for rotation.
virtual double dxfAngle(QgsSymbolRenderContext &context) const override
Gets angle.
Qgis::ScaleMethod mScaleMethod
Marker size scaling method.
virtual double dxfSize(const QgsDxfExport &e, QgsSymbolRenderContext &context) const override
Gets marker size.
void stopRender(QgsSymbolRenderContext &context) override
Called after a set of rendering operations has finished on the supplied render context.
VerticalAnchorPoint verticalAnchorPoint() const
Returns the vertical anchor point for positioning the symbol.
QgsMapUnitScale mSizeMapUnitScale
Marker size map unit scale.
Qgis::RenderUnit mSizeUnit
Marker size unit.
void setOutputUnit(Qgis::RenderUnit unit) override
Sets the units to use for sizes and widths within the symbol layer.
HorizontalAnchorPoint horizontalAnchorPoint() const
Returns the horizontal anchor point for positioning the symbol.
VerticalAnchorPoint
Symbol vertical anchor points.
@ VCenter
Align to vertical center of symbol.
@ Bottom
Align to bottom of symbol.
@ Top
Align to top of symbol.
void markerOffset(QgsSymbolRenderContext &context, double &offsetX, double &offsetY) const
Calculates the required marker offset, including both the symbol offset and any displacement required...
VerticalAnchorPoint mVerticalAnchorPoint
Vertical anchor point.
void toSld(QDomDocument &doc, QDomElement &element, const QVariantMap &props) const override
Saves the symbol layer as SLD.
virtual void writeSldMarker(QDomDocument &doc, QDomElement &element, const QVariantMap &props) const
Writes the symbol layer definition as a SLD XML element.
double mAngle
Marker rotation angle, in degrees clockwise from north.
void startRender(QgsSymbolRenderContext &context) override
Called before a set of rendering operations commences on the supplied render context.
double angle() const
Returns the rotation angle for the marker, in degrees clockwise from north.
void setMapUnitScale(const QgsMapUnitScale &scale) override
double simplifyTolerance() const
Returns the simplification tolerance (in painter units) to use for on-the-fly simplification of mask ...
static bool isDefaultStack(QgsPaintEffect *effect)
Tests whether a paint effect matches the default effects stack.
Base class for visual effects which can be applied to QPicture drawings.
bool enabled() const
Returns whether the effect is enabled.
QVariant value(int key, const QgsExpressionContext &context, const QVariant &defaultValue=QVariant()) const final
Returns the calculated value of the property with the specified key from within the collection.
void setProperty(int key, const QgsProperty &property)
Adds a property to the collection and takes ownership of it.
bool isActive(int key) const final
Returns true if the collection contains an active property with the specified key.
bool prepare(const QgsExpressionContext &context=QgsExpressionContext()) const final
Prepares the collection against a specified expression context.
bool hasActiveProperties() const final
Returns true if the collection has any active properties, or false if all properties within the colle...
QSet< QString > referencedFields(const QgsExpressionContext &context=QgsExpressionContext(), bool ignoreContext=false) const final
Returns the set of any fields referenced by the active properties from the collection.
Definition for a property.
Definition qgsproperty.h:45
@ HorizontalAnchor
Horizontal anchor point.
Definition qgsproperty.h:73
@ Double
Double value (including negative values)
Definition qgsproperty.h:55
@ VerticalAnchor
Vertical anchor point.
Definition qgsproperty.h:74
@ Double0To1
Double value between 0-1 (inclusive)
Definition qgsproperty.h:57
@ FillStyle
Fill style (eg solid, lines)
Definition qgsproperty.h:71
@ StrokeWidth
Line stroke width.
Definition qgsproperty.h:70
@ LineStyle
Line style (eg solid/dashed)
Definition qgsproperty.h:69
@ String
Any string value.
Definition qgsproperty.h:59
@ Boolean
Boolean value.
Definition qgsproperty.h:51
@ PenJoinStyle
Pen join style.
Definition qgsproperty.h:64
@ IntegerPositive
Positive integer values (including 0)
Definition qgsproperty.h:53
@ Opacity
Opacity (0-100)
Definition qgsproperty.h:60
@ CapStyle
Line cap style (eg round)
Definition qgsproperty.h:72
@ Rotation
Rotation (value between 0-360 degrees)
Definition qgsproperty.h:58
@ Size
1D size (eg marker radius, or square marker height/width)
Definition qgsproperty.h:67
@ ColorWithAlpha
Color with alpha channel.
Definition qgsproperty.h:62
@ DoublePositive
Positive double value (including 0)
Definition qgsproperty.h:56
@ DataTypeString
Property requires a string value.
Definition qgsproperty.h:90
@ DataTypeNumeric
Property requires a numeric value.
Definition qgsproperty.h:97
A store for object properties.
static QgsProperty fromExpression(const QString &expression, bool isActive=true)
Returns a new ExpressionBasedProperty created from the specified expression.
static QgsProperty fromField(const QString &fieldName, bool isActive=true)
Returns a new FieldBasedProperty created from the specified field name.
A rectangle specified with double values.
QgsRectangle intersect(const QgsRectangle &rect) const
Returns the intersection with the given rectangle.
Contains information about the context of a rendering operation.
QgsVectorSimplifyMethod & vectorSimplifyMethod()
Returns the simplification settings to use when rendering vector layers.
double convertToPainterUnits(double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property=Qgis::RenderSubcomponentProperty::Generic) const
Converts a size from the specified units to painter units (pixels).
QPainter * painter()
Returns the destination QPainter for the render operation.
QgsExpressionContext & expressionContext()
Gets the expression context.
QSize outputSize() const
Returns the size of the resulting rendered image, in pixels.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
QVector< QgsGeometry > symbolLayerClipGeometries(const QString &symbolLayerId) const
Returns clipping geometries to be applied to the symbolLayer before rendering.
Qgis::RenderContextFlags flags() const
Returns combination of flags used for rendering.
const QgsMaskRenderSettings & maskSettings() const
Returns a reference to the mask render settings, which control how masks are drawn and behave during ...
static QgsStyle * defaultStyle(bool initialize=true)
Returns the default application-wide style.
Definition qgsstyle.cpp:146
QList< QList< QPolygonF > > defaultPatchAsQPolygonF(Qgis::SymbolType type, QSizeF size) const
Returns the default patch geometry for the given symbol type and size as a set of QPolygonF objects (...
static QPointF toPoint(const QVariant &value, bool *ok=nullptr)
Converts a value to a point.
static QVector< QgsGeometry > collectSymbolLayerClipGeometries(const QgsRenderContext &context, const QString &symbolLayerId, const QRectF &bounds)
Returns a list of the symbol layer clip geometries to be used for the symbol layer with the specified...
static void createGeometryElement(QDomDocument &doc, QDomElement &element, const QString &geomFunc)
static QString encodePoint(QPointF point)
Encodes a QPointF to a string.
virtual bool setSubSymbol(QgsSymbol *symbol)
Sets layer's subsymbol. takes ownership of the passed symbol.
bool shouldRenderUsingSelectionColor(const QgsSymbolRenderContext &context) const
Returns true if the symbol layer should be rendered using the selection color from the render context...
Qgis::SymbolType type() const
virtual void startFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called before the layer will be rendered for a particular feature.
virtual QColor fillColor() const
Returns the fill color for the symbol layer.
void setId(const QString &id)
Set symbol layer identifier This id has to be unique in the whole project.
virtual void setStrokeColor(const QColor &color)
Sets the stroke color for the symbol layer.
QPainterPath mClipPath
bool installMasks(QgsRenderContext &context, bool recursive, const QRectF &rect=QRectF())
When rendering, install masks on context painter.
virtual double dxfSize(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets marker size.
virtual double dxfOffset(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets offset.
virtual QColor dxfBrushColor(QgsSymbolRenderContext &context) const
Gets brush/fill color.
Qgis::SymbolType mType
void removeMasks(QgsRenderContext &context, bool recursive)
When rendering, remove previously installed masks from context painter if recursive is true masks are...
virtual QSet< QString > usedAttributes(const QgsRenderContext &context) const
Returns the set of attributes referenced by the layer.
void copyDataDefinedProperties(QgsSymbolLayer *destLayer) const
Copies all data defined properties of this layer to another symbol layer.
Property
Data definable properties.
@ SkipMultiples
Skip multiples of.
@ ArrowHeadLength
Arrow head length.
@ GradientType
Gradient fill type.
@ SecondaryColor
Secondary color (eg for gradient fills)
@ File
Filename, eg for svg files.
@ VerticalAnchor
Vertical anchor point.
@ GradientReference2Y
Gradient reference point 2 y.
@ GradientReference1X
Gradient reference point 1 x.
@ OffsetY
Vertical offset.
@ OffsetX
Horizontal offset.
@ GradientReference1Y
Gradient reference point 1 y.
@ ArrowWidth
Arrow tail width.
@ PointCount
Point count.
@ DashPatternOffset
Dash pattern offset,.
@ GradientSpread
Gradient spread mode.
@ OffsetAlongLine
Offset along line.
@ ArrowHeadType
Arrow head type.
@ CustomDash
Custom dash pattern.
@ ShapeburstMaxDistance
Shapeburst fill from edge distance.
@ HorizontalAnchor
Horizontal anchor point.
@ StrokeStyle
Stroke style (eg solid, dashed)
@ Name
Name, eg shape name for simple markers.
@ DistanceY
Vertical distance between points.
@ LineEndColorValue
End line color for interpolated line renderer.
@ DensityArea
Density area.
@ ClipPoints
Whether markers should be clipped to polygon boundaries.
@ ArrowHeadThickness
Arrow head thickness.
@ LineClipping
Line clipping mode.
@ ShapeburstIgnoreRings
Shapeburst ignore rings.
@ Character
Character, eg for font marker symbol layers.
@ ShapeburstUseWholeShape
Shapeburst use whole shape.
@ DisplacementX
Horizontal displacement.
@ ShowMarker
Show markers.
@ CoordinateMode
Gradient coordinate mode.
@ FillStyle
Fill style (eg solid, dots)
@ GradientReference2X
Gradient reference point 2 x.
@ StrokeColor
Stroke color.
@ TrimStart
Trim distance from start of line.
@ ArrowStartWidth
Arrow tail start width.
@ CapStyle
Line cap style.
@ BlurRadius
Shapeburst blur radius.
@ Placement
Line marker placement.
@ MarkerClipping
Marker clipping mode.
@ RandomSeed
Random number seed.
@ LineAngle
Line angle, or angle of hash lines for hash line symbols.
@ JoinStyle
Line join style.
@ RandomOffsetY
Random offset Y.
@ DisplacementY
Vertical displacement.
@ PreserveAspectRatio
Preserve aspect ratio between width and height.
@ LineStartColorValue
Start line color for interpolated line renderer.
@ DistanceX
Horizontal distance between points.
@ AverageAngleLength
Length to average symbol angles over.
@ LineEndWidthValue
End line width for interpolated line renderer.
@ GradientReference1IsCentroid
Gradient reference point 1 is centroid.
@ Interval
Line marker interval.
@ StrokeWidth
Stroke width.
@ FontFamily
Font family.
@ GradientReference2IsCentroid
Gradient reference point 2 is centroid.
@ LineStartWidthValue
Start line width for interpolated line renderer.
@ LineDistance
Distance between lines, or length of lines for hash line symbols.
@ Offset
Symbol offset.
@ RandomOffsetX
Random offset X.
@ TrimEnd
Trim distance from end of line.
@ Height
Symbol height.
@ LayerEnabled
Whether symbol layer is enabled.
void restoreOldDataDefinedProperties(const QVariantMap &stringMap)
Restores older data defined properties from string map.
void setPaintEffect(QgsPaintEffect *effect)
Sets the current paint effect for the layer.
void setRenderingPass(int renderingPass)
Specifies the rendering pass in which this symbol layer should be rendered.
QgsPaintEffect * paintEffect() const
Returns the current paint effect for the layer.
virtual void startRender(QgsSymbolRenderContext &context)=0
Called before a set of rendering operations commences on the supplied render context.
std::unique_ptr< QgsPaintEffect > mPaintEffect
virtual Qt::PenStyle dxfPenStyle() const
Gets pen style.
virtual void setFillColor(const QColor &color)
Sets the fill color for the symbol layer.
virtual void prepareExpressions(const QgsSymbolRenderContext &context)
Prepares all data defined property expressions for evaluation.
void setUserFlags(Qgis::SymbolLayerUserFlags flags)
Sets user-controlled flags which control the symbol layer's behavior.
virtual QColor dxfColor(QgsSymbolRenderContext &context) const
Gets color.
int renderingPass() const
Specifies the rendering pass in which this symbol layer should be rendered.
virtual void stopRender(QgsSymbolRenderContext &context)=0
Called after a set of rendering operations has finished on the supplied render context.
virtual bool isCompatibleWithSymbol(QgsSymbol *symbol) const
Returns if the layer can be used below the specified symbol.
QString id() const
Returns symbol layer identifier This id is unique in the whole project.
virtual void setDataDefinedProperty(Property key, const QgsProperty &property)
Sets a data defined property for the layer.
virtual void setColor(const QColor &color)
Sets the "representative" color for the symbol layer.
virtual QgsSymbol * subSymbol()
Returns the symbol's sub symbol, if present.
Qgis::SymbolLayerUserFlags userFlags() const
Returns user-controlled flags which control the symbol layer's behavior.
virtual QColor color() const
Returns the "representative" color of the symbol layer.
virtual void prepareMasks(const QgsSymbolRenderContext &context)
Prepares all mask internal objects according to what is defined in context This should be called prio...
virtual void stopFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called after the layer has been rendered for a particular feature.
static const QgsPropertiesDefinition & propertyDefinitions()
Returns the symbol layer property definitions.
virtual double dxfWidth(const QgsDxfExport &e, QgsSymbolRenderContext &context) const
Gets line width.
virtual QColor strokeColor() const
Returns the stroke color for the symbol layer.
virtual double dxfAngle(QgsSymbolRenderContext &context) const
Gets angle.
Qgis::SymbolLayerUserFlags mUserFlags
User controlled flags.
virtual bool canCauseArtifactsBetweenAdjacentTiles() const
Returns true if the symbol layer rendering can cause visible artifacts across a single feature when t...
virtual ~QgsSymbolLayer()
virtual bool usesMapUnits() const
Returns true if the symbol layer has any components which use map unit based sizes.
virtual bool writeDxf(QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift=QPointF(0.0, 0.0)) const
write as DXF
void copyPaintEffect(QgsSymbolLayer *destLayer) const
Copies paint effect of this layer to another symbol layer.
virtual Qgis::SymbolLayerFlags flags() const
Returns flags which control the symbol layer's behavior.
QgsPropertyCollection mDataDefinedProperties
virtual QList< QgsSymbolLayerReference > masks() const
Returns masks defined by this symbol layer.
QgsPropertyCollection & dataDefinedProperties()
Returns a reference to the symbol layer's property collection, used for data defined overrides.
virtual Qt::BrushStyle dxfBrushStyle() const
Gets brush/fill style.
virtual QVector< qreal > dxfCustomDashPattern(Qgis::RenderUnit &unit) const
Gets dash pattern.
virtual bool hasDataDefinedProperties() const
Returns true if the symbol layer (or any of its sub-symbols) contains data defined properties.
QgsSymbolLayer(const QgsSymbolLayer &other)
void setDataDefinedProperties(const QgsPropertyCollection &collection)
Sets the symbol layer's property collection, used for data defined overrides.
QgsFields fields() const
Fields of the layer.
bool selected() const
Returns true if symbols should be rendered using the selected symbol coloring and style.
void setOriginalValueVariable(const QVariant &value)
Sets the original value variable value for data defined symbology.
const QgsLegendPatchShape * patchShape() const
Returns the symbol patch shape, to use if rendering symbol preview icons.
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
Abstract base class for all rendered symbols.
Definition qgssymbol.h:231
Qgis::SymbolType type() const
Returns the symbol's type.
Definition qgssymbol.h:293
static bool isNull(const QVariant &variant, bool silenceNullWarnings=false)
Returns true if the specified variant should be considered a NULL value.
Qgis::VectorRenderingSimplificationFlags simplifyHints() const
Gets the simplification hints of the vector layer managed.
float threshold() const
Gets the simplification threshold of the vector layer managed.
Contains geos related utilities and functions.
Definition qgsgeos.h:75
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
QMap< int, QgsPropertyDefinition > QgsPropertiesDefinition
Definition of available properties.
QgsProperty propertyFromMap(const QVariantMap &map, const QString &baseName)
QPainterPath generateClipPath(const QgsRenderContext &renderContext, const QString &id, const QRectF *rect, bool &foundGeometries)
#define DEG2RAD(x)
Single variable definition for use within a QgsExpressionContextScope.