QGIS API Documentation 3.34.0-Prizren (ffbdd678812)
Loading...
Searching...
No Matches
qgsfillsymbollayer.h
Go to the documentation of this file.
1/***************************************************************************
2 qgsfillsymbollayer.h
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#ifndef QGSFILLSYMBOLLAYER_H
17#define QGSFILLSYMBOLLAYER_H
18
19#include "qgis_core.h"
20#include "qgis.h"
21#include "qgssymbollayer.h"
22
23#define DEFAULT_SIMPLEFILL_COLOR QColor(0,0,255)
24#define DEFAULT_SIMPLEFILL_STYLE Qt::SolidPattern
25#define DEFAULT_SIMPLEFILL_BORDERCOLOR QColor( 35, 35, 35 )
26#define DEFAULT_SIMPLEFILL_BORDERSTYLE Qt::SolidLine
27#define DEFAULT_SIMPLEFILL_BORDERWIDTH DEFAULT_LINE_WIDTH
28#define DEFAULT_SIMPLEFILL_JOINSTYLE Qt::BevelJoin
29
30#define INF 1E20
31
32#include <QPen>
33#include <QBrush>
34
35class QgsMarkerSymbol;
36class QgsLineSymbol;
37class QgsPathResolver;
38
44{
45 public:
47 Qt::BrushStyle style = DEFAULT_SIMPLEFILL_STYLE,
48 const QColor &strokeColor = DEFAULT_SIMPLEFILL_BORDERCOLOR,
49 Qt::PenStyle strokeStyle = DEFAULT_SIMPLEFILL_BORDERSTYLE,
50 double strokeWidth = DEFAULT_SIMPLEFILL_BORDERWIDTH,
51 Qt::PenJoinStyle penJoinStyle = DEFAULT_SIMPLEFILL_JOINSTYLE
52 );
53
55
56 // static stuff
57
63 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
64 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
65
66 // implemented from base classes
67
68 QString layerType() const override;
69
70 void startRender( QgsSymbolRenderContext &context ) override;
71
72 void stopRender( QgsSymbolRenderContext &context ) override;
73
74 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
75
76 QVariantMap properties() const override;
77
78 QgsSimpleFillSymbolLayer *clone() const override SIP_FACTORY;
79
80 void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
81
82 QString ogrFeatureStyle( double mmScaleFactor, double mapUnitScaleFactor ) const override;
83
84 Qt::BrushStyle brushStyle() const { return mBrushStyle; }
85 void setBrushStyle( Qt::BrushStyle style ) { mBrushStyle = style; }
86
87 QColor strokeColor() const override { return mStrokeColor; }
88 void setStrokeColor( const QColor &strokeColor ) override { mStrokeColor = strokeColor; }
89
90 QColor fillColor() const override { return color(); }
91 void setFillColor( const QColor &color ) override { setColor( color ); }
92
93 Qt::PenStyle strokeStyle() const { return mStrokeStyle; }
94 void setStrokeStyle( Qt::PenStyle strokeStyle ) { mStrokeStyle = strokeStyle; }
95
96 double strokeWidth() const { return mStrokeWidth; }
97 void setStrokeWidth( double strokeWidth ) { mStrokeWidth = strokeWidth; }
98
99 Qt::PenJoinStyle penJoinStyle() const { return mPenJoinStyle; }
100 void setPenJoinStyle( Qt::PenJoinStyle style ) { mPenJoinStyle = style; }
101
110 void setOffset( QPointF offset ) { mOffset = offset; }
111
120 QPointF offset() const { return mOffset; }
121
127 void setStrokeWidthUnit( Qgis::RenderUnit unit ) { mStrokeWidthUnit = unit; }
128
133 Qgis::RenderUnit strokeWidthUnit() const { return mStrokeWidthUnit; }
134
135 void setStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mStrokeWidthMapUnitScale = scale; }
136 const QgsMapUnitScale &strokeWidthMapUnitScale() const { return mStrokeWidthMapUnitScale; }
137
143 void setOffsetUnit( Qgis::RenderUnit unit ) { mOffsetUnit = unit; }
144
150 Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }
151
157 void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
158
164 const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
165
166 void setOutputUnit( Qgis::RenderUnit unit ) override;
167 Qgis::RenderUnit outputUnit() const override;
168 bool usesMapUnits() const override;
169
170 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
171 QgsMapUnitScale mapUnitScale() const override;
172
173 double estimateMaxBleed( const QgsRenderContext &context ) const override;
174
175 double dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const override;
176 QColor dxfColor( QgsSymbolRenderContext &context ) const override;
177 double dxfAngle( QgsSymbolRenderContext &context ) const override;
178
179 Qt::PenStyle dxfPenStyle() const override;
180 QColor dxfBrushColor( QgsSymbolRenderContext &context ) const override;
181 Qt::BrushStyle dxfBrushStyle() const override;
182 QImage toTiledPatternImage( ) const override;
183
184 protected:
185 QBrush mBrush;
186 QBrush mSelBrush;
187 Qt::BrushStyle mBrushStyle;
189 Qt::PenStyle mStrokeStyle;
193 Qt::PenJoinStyle mPenJoinStyle;
194 QPen mPen;
196
197 QPointF mOffset;
200
201 private:
202 //helper functions for data defined symbology
203 void applyDataDefinedSymbology( QgsSymbolRenderContext &context, QBrush &brush, QPen &pen, QPen &selPen );
204
205};
206
207class QgsColorRamp;
208
214{
215 public:
216
221 const QColor &color2 = Qt::white,
226 );
227
229
230 // static stuff
231
237 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
238
239 // implemented from base classes
240
241 QString layerType() const override;
242 void startRender( QgsSymbolRenderContext &context ) override;
243 void stopRender( QgsSymbolRenderContext &context ) override;
244 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
245 QVariantMap properties() const override;
247 double estimateMaxBleed( const QgsRenderContext &context ) const override;
248 bool canCauseArtifactsBetweenAdjacentTiles() const override;
249
255 Qgis::GradientType gradientType() const { return mGradientType; }
256
262 void setGradientType( Qgis::GradientType gradientType ) { mGradientType = gradientType; }
263
269 Qgis::GradientColorSource gradientColorType() const { return mGradientColorType; }
270
276 void setGradientColorType( Qgis::GradientColorSource gradientColorType ) { mGradientColorType = gradientColorType; }
277
284 QgsColorRamp *colorRamp() { return mGradientRamp; }
285
293 void setColorRamp( QgsColorRamp *ramp SIP_TRANSFER );
294
300 QColor color2() const { return mColor2; }
301
307 void setColor2( const QColor &color2 ) { mColor2 = color2; }
308
314 Qgis::SymbolCoordinateReference coordinateMode() const { return mCoordinateMode; }
315
321 void setCoordinateMode( Qgis::SymbolCoordinateReference coordinateMode ) { mCoordinateMode = coordinateMode; }
322
328 Qgis::GradientSpread gradientSpread() const { return mGradientSpread; }
329
335 void setGradientSpread( Qgis::GradientSpread gradientSpread ) { mGradientSpread = gradientSpread; }
336
342 void setReferencePoint1( QPointF referencePoint ) { mReferencePoint1 = referencePoint; }
343
349 QPointF referencePoint1() const { return mReferencePoint1; }
350
356 void setReferencePoint1IsCentroid( bool isCentroid ) { mReferencePoint1IsCentroid = isCentroid; }
357
363 bool referencePoint1IsCentroid() const { return mReferencePoint1IsCentroid; }
364
370 void setReferencePoint2( QPointF referencePoint ) { mReferencePoint2 = referencePoint; }
371
377 QPointF referencePoint2() const { return mReferencePoint2; }
378
384 void setReferencePoint2IsCentroid( bool isCentroid ) { mReferencePoint2IsCentroid = isCentroid; }
385
386
392 bool referencePoint2IsCentroid() const { return mReferencePoint2IsCentroid; }
393
402 void setOffset( QPointF offset ) { mOffset = offset; }
403
412 QPointF offset() const { return mOffset; }
413
419 void setOffsetUnit( Qgis::RenderUnit unit ) { mOffsetUnit = unit; }
420
426 Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }
427
433 void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
434
440 const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
441
442 void setOutputUnit( Qgis::RenderUnit unit ) override;
443 Qgis::RenderUnit outputUnit() const override;
444 bool usesMapUnits() const override;
445
446 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
447 QgsMapUnitScale mapUnitScale() const override;
448
449 protected:
450 QBrush mBrush;
451 QBrush mSelBrush;
452
454 QColor mColor2;
455 QgsColorRamp *mGradientRamp = nullptr;
459
461 bool mReferencePoint1IsCentroid = false;
463 bool mReferencePoint2IsCentroid = false;
464
465 QPointF mOffset;
468
469 private:
470
471 //helper functions for data defined symbology
472 void applyDataDefinedSymbology( QgsSymbolRenderContext &context, const QPolygonF &points );
473
475 void applyGradient( const QgsSymbolRenderContext &context, QBrush &brush, const QColor &color, const QColor &color2,
476 Qgis::GradientColorSource gradientColorType, QgsColorRamp *gradientRamp, Qgis::GradientType gradientType,
477 Qgis::SymbolCoordinateReference coordinateMode, Qgis::GradientSpread gradientSpread,
478 QPointF referencePoint1, QPointF referencePoint2, double angle );
479
481 QPointF rotateReferencePoint( QPointF refPoint, double angle );
482};
483
489{
490 public:
491
495 QgsShapeburstFillSymbolLayer( const QColor &color = DEFAULT_SIMPLEFILL_COLOR, const QColor &color2 = Qt::white,
497 int blurRadius = 0, bool useWholeShape = true, double maxDistance = 5 );
498
500
506
512
513 // static stuff
514
520 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
521
522 // implemented from base classes
523
524 QString layerType() const override;
525 void startRender( QgsSymbolRenderContext &context ) override;
526 void stopRender( QgsSymbolRenderContext &context ) override;
527 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
528 QVariantMap properties() const override;
529 QgsShapeburstFillSymbolLayer *clone() const override SIP_FACTORY;
530 double estimateMaxBleed( const QgsRenderContext &context ) const override;
531 bool canCauseArtifactsBetweenAdjacentTiles() const override;
532
539 void setBlurRadius( int blurRadius ) { mBlurRadius = blurRadius; }
540
547 int blurRadius() const { return mBlurRadius; }
548
557 void setUseWholeShape( bool useWholeShape ) { mUseWholeShape = useWholeShape; }
558
566 bool useWholeShape() const { return mUseWholeShape; }
567
576 void setMaxDistance( double maxDistance ) { mMaxDistance = maxDistance; }
577
586 double maxDistance() const { return mMaxDistance; }
587
595 void setDistanceUnit( Qgis::RenderUnit unit ) { mDistanceUnit = unit; }
596
604 Qgis::RenderUnit distanceUnit() const { return mDistanceUnit; }
605
606 void setDistanceMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceMapUnitScale = scale; }
607 const QgsMapUnitScale &distanceMapUnitScale() const { return mDistanceMapUnitScale; }
608
619 void setColorType( Qgis::GradientColorSource colorType ) { mColorType = colorType; }
620
631 Qgis::GradientColorSource colorType() const { return mColorType; }
632
642 void setColorRamp( QgsColorRamp *ramp SIP_TRANSFER );
643
651 QgsColorRamp *colorRamp() { return mGradientRamp.get(); }
652
660 void setColor2( const QColor &color2 ) { mColor2 = color2; }
661
669 QColor color2() const { return mColor2; }
670
678 void setIgnoreRings( bool ignoreRings ) { mIgnoreRings = ignoreRings; }
679
686 bool ignoreRings() const { return mIgnoreRings; }
687
695 void setOffset( QPointF offset ) { mOffset = offset; }
696
704 QPointF offset() const { return mOffset; }
705
713 void setOffsetUnit( Qgis::RenderUnit unit ) { mOffsetUnit = unit; }
714
722 Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }
723
724 void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
725 const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
726
727 void setOutputUnit( Qgis::RenderUnit unit ) override;
728 Qgis::RenderUnit outputUnit() const override;
729 bool usesMapUnits() const override;
730
731 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
732 QgsMapUnitScale mapUnitScale() const override;
733
734 private:
735 QBrush mBrush;
736 QBrush mSelBrush;
737
738 int mBlurRadius = 0;
739
740 bool mUseWholeShape = true;
741 double mMaxDistance = 5.0;
743 QgsMapUnitScale mDistanceMapUnitScale;
744
746 QColor mColor2;
747
748 bool mIgnoreRings = false;
749
750 QPointF mOffset;
752 QgsMapUnitScale mOffsetMapUnitScale;
753
754 std::unique_ptr< QgsColorRamp > mGradientRamp;
755
756 //helper functions for data defined symbology
757 void applyDataDefinedSymbology( QgsSymbolRenderContext &context, QColor &color, QColor &color2, int &blurRadius, bool &useWholeShape,
758 double &maxDistance, bool &ignoreRings );
759
760 /* distance transform of a 1d function using squared distance */
761 void distanceTransform1d( double *f, int n, int *v, double *z, double *d );
762 /* distance transform of 2d function using squared distance */
763 void distanceTransform2d( double *im, int width, int height, QgsRenderContext &context );
764 /* distance transform of a binary QImage */
765 double *distanceTransform( QImage *im, QgsRenderContext &context );
766
767 /* fills a QImage with values from an array of doubles containing squared distance transform values */
768 void dtArrayToQImage( double *array, QImage *im, QgsColorRamp *ramp, QgsRenderContext &context, bool useWholeShape = true, int maxPixelDistance = 0 );
769
770#ifdef SIP_RUN
772#endif
773};
774
780{
781 public:
782
785
786 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
787
793 void setStrokeWidthUnit( Qgis::RenderUnit unit ) { mStrokeWidthUnit = unit; }
794
800 Qgis::RenderUnit strokeWidthUnit() const { return mStrokeWidthUnit; }
801
808 void setStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mStrokeWidthMapUnitScale = scale; }
809
818 const QgsMapUnitScale &strokeWidthMapUnitScale() const { return mStrokeWidthMapUnitScale; }
819
827 void setCoordinateReference( Qgis::SymbolCoordinateReference coordinateReference ) { mCoordinateReference = coordinateReference; }
828
836 Qgis::SymbolCoordinateReference coordinateReference() const { return mCoordinateReference; }
837
838 void setOutputUnit( Qgis::RenderUnit unit ) override;
839 Qgis::RenderUnit outputUnit() const override;
840 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
841 QgsMapUnitScale mapUnitScale() const override;
842 double dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const override;
843 Qt::PenStyle dxfPenStyle() const override;
844 QVariantMap properties() const override;
845
846 protected:
847 QBrush mBrush;
849 double mNextAngle = 0.0; // mAngle / data defined angle
850
852 double mStrokeWidth = 0.0;
855
859 virtual void applyDataDefinedSettings( QgsSymbolRenderContext &context ) { Q_UNUSED( context ) }
860
866 virtual bool applyBrushTransformFromContext( QgsSymbolRenderContext *context = nullptr ) const;
867
868 private:
869#ifdef SIP_RUN
871#endif
872};
873
881{
882 public:
883
888 QgsRasterFillSymbolLayer( const QString &imageFilePath = QString() );
889
891
896 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
897
903 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
904
910 static void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving );
911
912 // implemented from base classes
913 QString layerType() const override;
914 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
915 void startRender( QgsSymbolRenderContext &context ) override;
916 void stopRender( QgsSymbolRenderContext &context ) override;
917 QVariantMap properties() const override;
918 QgsRasterFillSymbolLayer *clone() const override SIP_FACTORY;
919 double estimateMaxBleed( const QgsRenderContext &context ) const override;
920 bool usesMapUnits() const override;
921 QColor color() const override;
922 void setOutputUnit( Qgis::RenderUnit unit ) override;
923
924 //override QgsImageFillSymbolLayer's support for sub symbols
925 QgsSymbol *subSymbol() override { return nullptr; }
926 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
927
933 void setImageFilePath( const QString &imagePath );
934
940 QString imageFilePath() const { return mImageFilePath; }
941
948 void setCoordinateMode( Qgis::SymbolCoordinateReference mode );
949
956 Qgis::SymbolCoordinateReference coordinateMode() const { return mCoordinateMode; }
957
963 void setOpacity( double opacity );
964
970 double opacity() const { return mOpacity; }
971
979 void setOffset( QPointF offset ) { mOffset = offset; }
980
988 QPointF offset() const { return mOffset; }
989
997 void setOffsetUnit( const Qgis::RenderUnit unit ) { mOffsetUnit = unit; }
998
1006 Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }
1007
1015 void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
1016
1024 const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
1025
1034 void setWidth( const double width ) { mWidth = width; }
1035
1044 double width() const { return mWidth; }
1045
1053 void setWidthUnit( const Qgis::RenderUnit unit ) { mWidthUnit = unit; }
1054
1062 Qgis::RenderUnit widthUnit() const { return mWidthUnit; }
1063
1071 void setWidthMapUnitScale( const QgsMapUnitScale &scale ) { mWidthMapUnitScale = scale; }
1072
1080 const QgsMapUnitScale &widthMapUnitScale() const { return mWidthMapUnitScale; }
1081
1082 protected:
1083
1084 void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
1085 bool applyBrushTransformFromContext( QgsSymbolRenderContext *context = nullptr ) const override;
1086 private:
1087
1089 QString mImageFilePath;
1091 double mOpacity = 1.0;
1092
1093 QPointF mOffset;
1095 QgsMapUnitScale mOffsetMapUnitScale;
1096
1097 double mWidth = 0.0;
1099 QgsMapUnitScale mWidthMapUnitScale;
1100
1102 void applyPattern( QBrush &brush, const QString &imageFilePath, double width, double opacity,
1103 const QgsSymbolRenderContext &context );
1104};
1105
1111{
1112 public:
1113
1117 QgsSVGFillSymbolLayer( const QString &svgFilePath, double width = 20, double rotation = 0.0 );
1118
1122 QgsSVGFillSymbolLayer( const QByteArray &svgData, double width = 20, double rotation = 0.0 );
1123
1125
1130 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
1131
1136 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
1137
1143 static void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving );
1144
1145 // implemented from base classes
1146
1147 QString layerType() const override;
1148 void startRender( QgsSymbolRenderContext &context ) override;
1149 void stopRender( QgsSymbolRenderContext &context ) override;
1150 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
1151 QVariantMap properties() const override;
1152 QgsSVGFillSymbolLayer *clone() const override SIP_FACTORY;
1153 void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
1154 bool usesMapUnits() const override;
1155 QgsSymbol *subSymbol() override;
1156 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
1157 double estimateMaxBleed( const QgsRenderContext &context ) const override;
1158 QColor dxfColor( QgsSymbolRenderContext &context ) const override;
1159 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
1160 bool hasDataDefinedProperties() const override;
1161
1173 void setSvgFilePath( const QString &svgPath );
1174
1180 QString svgFilePath() const { return mSvgFilePath; }
1181
1191 void setPatternWidth( double width ) { mPatternWidth = width;}
1192
1202 double patternWidth() const { return mPatternWidth; }
1203
1213 void setSvgFillColor( const QColor &c ) { setColor( c ); }
1214
1223 QColor svgFillColor() const { return color(); }
1224
1234 void setSvgStrokeColor( const QColor &c ) { mSvgStrokeColor = c; }
1235
1244 QColor svgStrokeColor() const { return mSvgStrokeColor; }
1245
1256 void setSvgStrokeWidth( double w ) { mSvgStrokeWidth = w; }
1257
1268 double svgStrokeWidth() const { return mSvgStrokeWidth; }
1269
1277 void setPatternWidthUnit( Qgis::RenderUnit unit ) { mPatternWidthUnit = unit; }
1278
1286 Qgis::RenderUnit patternWidthUnit() const { return mPatternWidthUnit; }
1287
1295 void setPatternWidthMapUnitScale( const QgsMapUnitScale &scale ) { mPatternWidthMapUnitScale = scale; }
1296
1304 const QgsMapUnitScale &patternWidthMapUnitScale() const { return mPatternWidthMapUnitScale; }
1305
1313 void setSvgStrokeWidthUnit( Qgis::RenderUnit unit ) { mSvgStrokeWidthUnit = unit; }
1314
1322 Qgis::RenderUnit svgStrokeWidthUnit() const { return mSvgStrokeWidthUnit; }
1323
1331 void setSvgStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mSvgStrokeWidthMapUnitScale = scale; }
1332
1340 const QgsMapUnitScale &svgStrokeWidthMapUnitScale() const { return mSvgStrokeWidthMapUnitScale; }
1341
1342 void setOutputUnit( Qgis::RenderUnit unit ) override;
1343 Qgis::RenderUnit outputUnit() const override;
1344
1345 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
1346 QgsMapUnitScale mapUnitScale() const override;
1347
1352 QMap<QString, QgsProperty> parameters() const { return mParameters; }
1353
1358 void setParameters( const QMap<QString, QgsProperty> &parameters );
1359
1360 protected:
1361
1362 void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
1363
1364 private:
1365
1367 double mPatternWidth = 20;
1369 QgsMapUnitScale mPatternWidthMapUnitScale;
1370 QMap<QString, QgsProperty> mParameters;
1371
1373 QByteArray mSvgData;
1375 QString mSvgFilePath;
1377 QRectF mSvgViewBox;
1378
1379 //param(fill), param(stroke), param(stroke-width) are going
1380 //to be replaced in memory
1381 QColor mSvgStrokeColor = QColor( 35, 35, 35 );
1382 double mSvgStrokeWidth = 0.2;
1383 Qgis::RenderUnit mSvgStrokeWidthUnit = Qgis::RenderUnit::Millimeters;
1384 QgsMapUnitScale mSvgStrokeWidthMapUnitScale;
1385
1387 std::unique_ptr< QgsLineSymbol > mStroke;
1388
1390 void storeViewBox();
1391 void setDefaultSvgParams(); //fills mSvgFillColor, mSvgStrokeColor, mSvgStrokeWidth with default values for mSvgFilePath
1392
1394 void applyPattern( QBrush &brush, const QString &svgFilePath, double patternWidth, Qgis::RenderUnit patternWidthUnit, const QColor &svgFillColor, const QColor &svgStrokeColor,
1395 double svgStrokeWidth, Qgis::RenderUnit svgStrokeWidthUnit, const QgsSymbolRenderContext &context, const QgsMapUnitScale &patternWidthMapUnitScale, const QgsMapUnitScale &svgStrokeWidthMapUnitScale,
1396 const QgsStringMap svgParameters );
1397};
1398
1405{
1406 public:
1409
1414 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
1415
1420 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
1421
1422 QString layerType() const override;
1423 void startRender( QgsSymbolRenderContext &context ) override;
1424 void stopRender( QgsSymbolRenderContext &context ) override;
1425 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
1426 QVariantMap properties() const override;
1427 QgsLinePatternFillSymbolLayer *clone() const override SIP_FACTORY;
1428 void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
1429 QImage toTiledPatternImage( ) const override;
1430 double estimateMaxBleed( const QgsRenderContext &context ) const override;
1431
1432 QString ogrFeatureStyleWidth( double widthScaleFactor ) const;
1433
1441 void setLineAngle( double a ) { mLineAngle = a; }
1442
1450 double lineAngle() const { return mLineAngle; }
1451
1458 void setDistance( double d ) { mDistance = d; }
1459
1465 double distance() const { return mDistance; }
1466
1473 void setLineWidth( double w );
1474
1481 double lineWidth() const { return mLineWidth; }
1482
1483 void setColor( const QColor &c ) override;
1484 QColor color() const override;
1485
1497 void setOffset( double offset ) { mOffset = offset; }
1498
1510 double offset() const { return mOffset; }
1511
1518 void setDistanceUnit( Qgis::RenderUnit unit ) { mDistanceUnit = unit; }
1519
1526 Qgis::RenderUnit distanceUnit() const { return mDistanceUnit; }
1527
1535 void setDistanceMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceMapUnitScale = scale; }
1536
1544 const QgsMapUnitScale &distanceMapUnitScale() const { return mDistanceMapUnitScale; }
1545
1551 void setLineWidthUnit( Qgis::RenderUnit unit ) { mLineWidthUnit = unit; }
1552
1558 Qgis::RenderUnit lineWidthUnit() const { return mLineWidthUnit; }
1559
1567 void setLineWidthMapUnitScale( const QgsMapUnitScale &scale ) { mLineWidthMapUnitScale = scale; }
1568
1576 const QgsMapUnitScale &lineWidthMapUnitScale() const { return mLineWidthMapUnitScale; }
1577
1583 void setOffsetUnit( Qgis::RenderUnit unit ) { mOffsetUnit = unit; }
1584
1590 Qgis::RenderUnit offsetUnit() const { return mOffsetUnit; }
1591
1599 void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
1600
1608 const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
1609
1616 Qgis::LineClipMode clipMode() const { return mClipMode; }
1617
1624 void setClipMode( Qgis::LineClipMode mode ) { mClipMode = mode; }
1625
1626 void setOutputUnit( Qgis::RenderUnit unit ) override;
1627 Qgis::RenderUnit outputUnit() const override;
1628 bool usesMapUnits() const override;
1629 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
1630 QgsMapUnitScale mapUnitScale() const override;
1631 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
1632 QgsSymbol *subSymbol() override;
1633 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
1634 bool hasDataDefinedProperties() const override;
1635 void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
1636 void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
1637
1638 protected:
1639
1640 void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
1641
1642 private:
1644 double mDistance = 5.0;
1646 QgsMapUnitScale mDistanceMapUnitScale;
1648 double mLineWidth = 0;
1650 QgsMapUnitScale mLineWidthMapUnitScale;
1652 double mLineAngle = 45.0;
1654 double mOffset = 0.0;
1656 QgsMapUnitScale mOffsetMapUnitScale;
1657
1658 bool mRenderUsingLines = false;
1659
1660#ifdef SIP_RUN
1662#endif
1663
1665 bool applyPattern( const QgsSymbolRenderContext &context, QBrush &brush, double lineAngle, double distance );
1666
1668 std::unique_ptr< QgsLineSymbol > mFillLineSymbol;
1669
1671};
1672
1679{
1680 public:
1683
1689 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
1690 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
1691
1692 QString layerType() const override;
1693 void startRender( QgsSymbolRenderContext &context ) override;
1694 void stopRender( QgsSymbolRenderContext &context ) override;
1695 void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
1696 void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
1697 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
1698 QVariantMap properties() const override;
1699 QgsPointPatternFillSymbolLayer *clone() const override SIP_FACTORY;
1700 void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
1701 QImage toTiledPatternImage( ) const override;
1702 double estimateMaxBleed( const QgsRenderContext &context ) const override;
1703 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
1704 QgsSymbol *subSymbol() override;
1705 void setOutputUnit( Qgis::RenderUnit unit ) override;
1706 Qgis::RenderUnit outputUnit() const override;
1707 bool usesMapUnits() const override;
1708 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
1709 QgsMapUnitScale mapUnitScale() const override;
1710 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
1711 bool hasDataDefinedProperties() const override;
1712 void setColor( const QColor &c ) override;
1713 QColor color() const override;
1714
1724 double distanceX() const { return mDistanceX; }
1725
1735 void setDistanceX( double d ) { mDistanceX = d; }
1736
1743 void setDistanceXUnit( Qgis::RenderUnit unit ) { mDistanceXUnit = unit; }
1744
1750 Qgis::RenderUnit distanceXUnit() const { return mDistanceXUnit; }
1751
1758 void setDistanceXMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceXMapUnitScale = scale; }
1759
1766 const QgsMapUnitScale &distanceXMapUnitScale() const { return mDistanceXMapUnitScale; }
1767
1777 double distanceY() const { return mDistanceY; }
1778
1788 void setDistanceY( double d ) { mDistanceY = d; }
1789
1796 void setDistanceYUnit( Qgis::RenderUnit unit ) { mDistanceYUnit = unit; }
1797
1803 Qgis::RenderUnit distanceYUnit() const { return mDistanceYUnit; }
1804
1811 void setDistanceYMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceYMapUnitScale = scale; }
1812
1819 const QgsMapUnitScale &distanceYMapUnitScale() const { return mDistanceYMapUnitScale; }
1820
1830 double displacementX() const { return mDisplacementX; }
1831
1841 void setDisplacementX( double d ) { mDisplacementX = d; }
1842
1849 void setDisplacementXUnit( Qgis::RenderUnit unit ) { mDisplacementXUnit = unit; }
1850
1856 Qgis::RenderUnit displacementXUnit() const { return mDisplacementXUnit; }
1857
1864 void setDisplacementXMapUnitScale( const QgsMapUnitScale &scale ) { mDisplacementXMapUnitScale = scale; }
1865
1872 const QgsMapUnitScale &displacementXMapUnitScale() const { return mDisplacementXMapUnitScale; }
1873
1883 double displacementY() const { return mDisplacementY; }
1884
1894 void setDisplacementY( double d ) { mDisplacementY = d; }
1895
1902 void setDisplacementYUnit( Qgis::RenderUnit unit ) { mDisplacementYUnit = unit; }
1903
1909 Qgis::RenderUnit displacementYUnit() const { return mDisplacementYUnit; }
1910
1917 void setDisplacementYMapUnitScale( const QgsMapUnitScale &scale ) { mDisplacementYMapUnitScale = scale; }
1918
1925 const QgsMapUnitScale &displacementYMapUnitScale() const { return mDisplacementYMapUnitScale; }
1926
1934 void setOffsetX( double offset ) { mOffsetX = offset; }
1935
1942 double offsetX() const { return mOffsetX; }
1943
1951 void setOffsetY( double offset ) { mOffsetY = offset; }
1952
1959 double offsetY() const { return mOffsetY; }
1960
1968 void setOffsetXUnit( Qgis::RenderUnit unit ) { mOffsetXUnit = unit; }
1969
1976 Qgis::RenderUnit offsetXUnit() const { return mOffsetXUnit; }
1977
1985 void setOffsetXMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetXMapUnitScale = scale; }
1986
1993 const QgsMapUnitScale &offsetXMapUnitScale() const { return mOffsetXMapUnitScale; }
1994
2002 void setOffsetYUnit( Qgis::RenderUnit unit ) { mOffsetYUnit = unit; }
2003
2010 Qgis::RenderUnit offsetYUnit() const { return mOffsetYUnit; }
2011
2019 void setOffsetYMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetYMapUnitScale = scale; }
2020
2027 const QgsMapUnitScale &offsetYMapUnitScale() const { return mOffsetYMapUnitScale; }
2028
2035 Qgis::MarkerClipMode clipMode() const { return mClipMode; }
2036
2043 void setClipMode( Qgis::MarkerClipMode mode ) { mClipMode = mode; }
2044
2054 void setMaximumRandomDeviationX( double deviation ) { mRandomDeviationX = deviation; }
2055
2065 double maximumRandomDeviationX() const { return mRandomDeviationX; }
2066
2076 void setMaximumRandomDeviationY( double deviation ) { mRandomDeviationY = deviation; }
2077
2087 double maximumRandomDeviationY() const { return mRandomDeviationY; }
2088
2096 void setRandomDeviationXUnit( Qgis::RenderUnit unit ) { mRandomDeviationXUnit = unit; }
2097
2105 Qgis::RenderUnit randomDeviationXUnit() const { return mRandomDeviationXUnit; }
2106
2114 void setRandomDeviationYUnit( Qgis::RenderUnit unit ) { mRandomDeviationYUnit = unit; }
2115
2124 Qgis::RenderUnit randomDeviationYUnit() const { return mRandomDeviationYUnit; }
2125
2133 const QgsMapUnitScale &randomDeviationXMapUnitScale() const { return mRandomDeviationXMapUnitScale; }
2134
2142 const QgsMapUnitScale &randomDeviationYMapUnitScale() const { return mRandomDeviationYMapUnitScale; }
2143
2151 void setRandomDeviationXMapUnitScale( const QgsMapUnitScale &scale ) { mRandomDeviationXMapUnitScale = scale; }
2152
2160 void setRandomDeviationYMapUnitScale( const QgsMapUnitScale &scale ) { mRandomDeviationYMapUnitScale = scale; }
2161
2168 unsigned long seed() const { return mSeed; }
2169
2178 void setSeed( unsigned long seed ) { mSeed = seed; }
2179
2180 protected:
2181 std::unique_ptr< QgsMarkerSymbol > mMarkerSymbol;
2182 double mDistanceX = 15;
2185 double mDistanceY = 15;
2188 double mDisplacementX = 0;
2191 double mDisplacementY = 0;
2194 double mOffsetX = 0;
2197 double mOffsetY = 0;
2200
2201 double mRandomDeviationX = 0;
2204 double mRandomDeviationY = 0;
2207 unsigned long mSeed = 0;
2208
2209 void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
2210
2211 private:
2212#ifdef SIP_RUN
2214#endif
2215
2216 bool applyPattern( const QgsSymbolRenderContext &context, QBrush &brush, double distanceX, double distanceY,
2217 double displacementX, double displacementY, double offsetX, double offsetY );
2218
2220
2221 bool mRenderUsingMarkers = false;
2222};
2223
2233{
2234 public:
2235
2242 QgsRandomMarkerFillSymbolLayer( int pointCount = 10, Qgis::PointCountMethod method = Qgis::PointCountMethod::Absolute, double densityArea = 250.0, unsigned long seed = 0 );
2243
2245
2251 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
2252
2253 QString layerType() const override;
2254 void startRender( QgsSymbolRenderContext &context ) override;
2255 void stopRender( QgsSymbolRenderContext &context ) override;
2256 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
2257 QVariantMap properties() const override;
2258 QgsRandomMarkerFillSymbolLayer *clone() const override SIP_FACTORY;
2259 bool canCauseArtifactsBetweenAdjacentTiles() const override;
2260
2261 void setColor( const QColor &color ) override;
2262 QColor color() const override;
2263
2264 QgsSymbol *subSymbol() override;
2265 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
2266
2267 void setOutputUnit( Qgis::RenderUnit unit ) override;
2268 Qgis::RenderUnit outputUnit() const override;
2269 bool usesMapUnits() const override;
2270
2271 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
2272 QgsMapUnitScale mapUnitScale() const override;
2273
2274 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
2275 bool hasDataDefinedProperties() const override;
2276
2282 int pointCount() const;
2283
2289 void setPointCount( int count );
2290
2296 unsigned long seed() const;
2297
2305 void setSeed( unsigned long seed );
2306
2312 bool clipPoints() const;
2313
2319 void setClipPoints( bool clipped );
2320
2326 Qgis::PointCountMethod countMethod() const;
2327
2333 void setCountMethod( Qgis::PointCountMethod method );
2334
2344 double densityArea() const;
2345
2351 void setDensityArea( double area );
2352
2358 void setDensityAreaUnit( Qgis::RenderUnit unit ) { mDensityAreaUnit = unit; }
2359
2364 Qgis::RenderUnit densityAreaUnit() const { return mDensityAreaUnit; }
2365
2373 void setDensityAreaUnitScale( const QgsMapUnitScale &scale ) { mDensityAreaUnitScale = scale; }
2374
2381 const QgsMapUnitScale &densityAreaUnitScale() const { return mDensityAreaUnitScale; }
2382
2383 void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
2384 void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
2385
2386 private:
2387#ifdef SIP_RUN
2389#endif
2390
2391 struct Part
2392 {
2393 QPolygonF exterior;
2394 QVector<QPolygonF> rings;
2395 };
2396
2397 QVector< Part > mCurrentParts;
2398
2399 void render( QgsRenderContext &context, const QVector< Part > &parts, const QgsFeature &feature, bool selected );
2400
2401 std::unique_ptr< QgsMarkerSymbol > mMarker;
2403 int mPointCount = 10;
2404 double mDensityArea = 250.0;
2406 QgsMapUnitScale mDensityAreaUnitScale;
2407 unsigned long mSeed = 0;
2408 bool mClipPoints = false;
2409
2410 bool mRenderingFeature = false;
2411 double mFeatureSymbolOpacity = 1;
2412};
2413
2414
2420{
2421 public:
2424
2425 // static stuff
2426
2432 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
2433 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
2434
2435 // implemented from base classes
2436
2437 QString layerType() const override;
2438 void startRender( QgsSymbolRenderContext &context ) override;
2439 void stopRender( QgsSymbolRenderContext &context ) override;
2440 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
2441 QVariantMap properties() const override;
2442 QgsCentroidFillSymbolLayer *clone() const override SIP_FACTORY;
2443 void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
2444 void setColor( const QColor &color ) override;
2445 QColor color() const override;
2446 QgsSymbol *subSymbol() override;
2447 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
2448 void setOutputUnit( Qgis::RenderUnit unit ) override;
2449 Qgis::RenderUnit outputUnit() const override;
2450 bool usesMapUnits() const override;
2451 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
2452 QgsMapUnitScale mapUnitScale() const override;
2453 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
2454 bool hasDataDefinedProperties() const override;
2455 bool canCauseArtifactsBetweenAdjacentTiles() const override;
2456
2457 void setPointOnSurface( bool pointOnSurface ) { mPointOnSurface = pointOnSurface; }
2458 bool pointOnSurface() const { return mPointOnSurface; }
2459
2465 void setPointOnAllParts( bool pointOnAllParts ) { mPointOnAllParts = pointOnAllParts; }
2466
2472 bool pointOnAllParts() const { return mPointOnAllParts; }
2473
2480 bool clipPoints() const { return mClipPoints; }
2481
2488 void setClipPoints( bool clipPoints ) { mClipPoints = clipPoints; }
2489
2496 bool clipOnCurrentPartOnly() const { return mClipOnCurrentPartOnly; }
2497
2504 void setClipOnCurrentPartOnly( bool clipOnCurrentPartOnly ) { mClipOnCurrentPartOnly = clipOnCurrentPartOnly; }
2505
2506 void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
2507 void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
2508
2509 protected:
2510
2511 std::unique_ptr< QgsMarkerSymbol > mMarker;
2512 bool mPointOnSurface = false;
2513 bool mPointOnAllParts = true;
2514 bool mClipPoints = false;
2515 bool mClipOnCurrentPartOnly = false;
2516
2517 bool mRenderingFeature = false;
2518 double mFeatureSymbolOpacity = 1;
2519
2520 private:
2521#ifdef SIP_RUN
2523#endif
2524 struct Part
2525 {
2526 QPolygonF exterior;
2527 QVector<QPolygonF> rings;
2528 };
2529
2530 void render( QgsRenderContext &context, const QVector<Part> &parts, const QgsFeature &feature, bool selected );
2531 QVector<Part> mCurrentParts;
2532};
2533
2534#endif
The Qgis class provides global constants for use throughout the application.
Definition qgis.h:54
MarkerClipMode
Marker clipping modes.
Definition qgis.h:2379
@ Shape
Clip to polygon shape.
LineClipMode
Line clipping modes.
Definition qgis.h:2393
@ ClipPainterOnly
Applying clipping on the painter only (i.e. line endpoints will coincide with polygon bounding box,...
GradientColorSource
Gradient color sources.
Definition qgis.h:2308
@ SimpleTwoColor
Simple two color gradient.
GradientSpread
Gradient spread options, which control how gradients are rendered outside of their start and end poin...
Definition qgis.h:2352
@ Pad
Pad out gradient using colors at endpoint of gradient.
PointCountMethod
Methods which define the number of points randomly filling a polygon.
Definition qgis.h:2367
@ Absolute
The point count is used as an absolute count of markers.
RenderUnit
Rendering size units.
Definition qgis.h:3627
@ Millimeters
Millimeters.
GradientType
Gradient types.
Definition qgis.h:2322
@ Linear
Linear gradient.
SymbolCoordinateReference
Symbol coordinate reference modes.
Definition qgis.h:2337
@ Feature
Relative to feature/shape being rendered.
void setPointOnAllParts(bool pointOnAllParts)
Sets whether a point is drawn for all parts or only on the biggest part of multi-part features.
void setClipOnCurrentPartOnly(bool clipOnCurrentPartOnly)
Sets whether point markers should be clipped to the current part boundary only.
void setClipPoints(bool clipPoints)
Sets whether point markers should be clipped to the polygon boundary.
std::unique_ptr< QgsMarkerSymbol > mMarker
bool pointOnAllParts() const
Returns whether a point is drawn for all parts or only on the biggest part of multi-part features.
bool clipPoints() const
Returns true if point markers should be clipped to the polygon boundary.
~QgsCentroidFillSymbolLayer() override
bool clipOnCurrentPartOnly() const
Returns true if point markers should be clipped to the current part boundary only.
Abstract base class for color ramps.
Exports QGIS layers to the DXF format.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:56
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,...
virtual QImage toTiledPatternImage() const
Renders the symbol layer as an image that can be used as a seamless pattern fill for polygons,...
QColor color2() const
Returns the color for endpoint of gradient, only used if the gradient color type is set to SimpleTwoC...
void setGradientSpread(Qgis::GradientSpread gradientSpread)
Sets the gradient spread mode, which controls how the gradient behaves outside of the predefined stop...
Qgis::RenderUnit offsetUnit() const
Returns the units for the fill's offset.
Qgis::SymbolCoordinateReference coordinateMode() const
Returns the coordinate mode for gradient, which controls how the gradient stops are positioned.
bool referencePoint2IsCentroid() const
Returns whether the end point for the gradient is taken from the feature centroid.
void setGradientType(Qgis::GradientType gradientType)
Sets the type of gradient, e.g., linear or radial.
void setReferencePoint2(QPointF referencePoint)
Sets the end point of gradient fill, in the range [0,0] - [1,1].
void setOffsetUnit(Qgis::RenderUnit unit)
Sets the unit for the fill's offset.
void setCoordinateMode(Qgis::SymbolCoordinateReference coordinateMode)
Sets the coordinate mode for gradient, which controls how the gradient stops are positioned.
Qgis::SymbolCoordinateReference mCoordinateMode
Qgis::GradientSpread mGradientSpread
void setReferencePoint2IsCentroid(bool isCentroid)
Sets whether the end point for the gradient is taken from the feature centroid.
void setReferencePoint1IsCentroid(bool isCentroid)
Sets whether the starting point for the gradient is taken from the feature centroid.
void setOffset(QPointF offset)
Sets an offset by which polygons will be translated during rendering.
void setGradientColorType(Qgis::GradientColorSource gradientColorType)
Sets the gradient color mode, which controls how gradient color stops are created.
QPointF referencePoint1() const
Returns the starting point of gradient fill, in the range [0,0] - [1,1].
Qgis::GradientSpread gradientSpread() const
Returns the gradient spread mode, which controls how the gradient behaves outside of the predefined s...
QgsColorRamp * colorRamp()
Returns the color ramp used for the gradient fill.
void setReferencePoint1(QPointF referencePoint)
Sets the starting point of gradient fill, in the range [0,0] - [1,1].
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the fill's offset.
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the fill's offset.
Qgis::GradientColorSource gradientColorType() const
Returns the gradient color mode, which controls how gradient color stops are created.
QPointF offset() const
Returns the offset by which polygons will be translated during rendering.
Qgis::GradientColorSource mGradientColorType
Qgis::GradientType gradientType() const
Returns the type of gradient, e.g., linear or radial.
bool referencePoint1IsCentroid() const
Returns whether the starting point for the gradient is taken from the feature centroid.
QPointF referencePoint2() const
Returns the end point of gradient fill, in the range [0,0] - [1,1].
void setColor2(const QColor &color2)
Sets the color for endpoint of gradient, only used if the gradient color type is set to SimpleTwoColo...
Base class for polygon renderers generating texture images.
QgsMapUnitScale mStrokeWidthMapUnitScale
void setStrokeWidthUnit(Qgis::RenderUnit unit)
Sets the units fo the symbol's stroke width.
void setStrokeWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the stroke width map unit scale.
Qgis::SymbolCoordinateReference coordinateReference() const
Returns the coordinate reference mode for fill which controls how the top left corner of the image fi...
void setCoordinateReference(Qgis::SymbolCoordinateReference coordinateReference)
Sets the coordinate reference mode for fill which controls how the top left corner of the image fill ...
Qgis::RenderUnit strokeWidthUnit() const
Returns the units for the symbol's stroke width.
virtual void applyDataDefinedSettings(QgsSymbolRenderContext &context)
Applies data defined settings prior to generating the fill symbol brush.
const QgsMapUnitScale & strokeWidthMapUnitScale() const
Returns the stroke width map unit scale.
~QgsImageFillSymbolLayer() override
A symbol fill consisting of repeated parallel lines.
Qgis::RenderUnit distanceUnit() const
Returns the units for the distance between lines in the fill pattern.
void setLineWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's line width.
double lineWidth() const
Returns the width of the line subsymbol used to render the parallel lines in the fill.
void setDistanceMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's line distance.
Qgis::LineClipMode clipMode() const
Returns the line clipping mode, which defines how lines are clipped at the edges of shapes.
double lineAngle() const
Returns the angle for the parallel lines used to fill the symbol.
Qgis::RenderUnit lineWidthUnit() const
Returns the units for the line's width.
void setLineWidthUnit(Qgis::RenderUnit unit)
Sets the unit for the line's width.
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the pattern's line offset.
void setDistance(double d)
Sets the distance between lines in the fill pattern.
const QgsMapUnitScale & lineWidthMapUnitScale() const
Returns the map unit scale for the pattern's line width.
void setClipMode(Qgis::LineClipMode mode)
Sets the line clipping mode, which defines how lines are clipped at the edges of shapes.
void setOffsetUnit(Qgis::RenderUnit unit)
Sets the unit for the line pattern's offset.
const QgsMapUnitScale & distanceMapUnitScale() const
Returns the map unit scale for the pattern's line distance.
double offset() const
Returns the offset distance for lines within the fill, which is the distance to offset the parallel l...
void setDistanceUnit(Qgis::RenderUnit unit)
Sets the unit for the distance between lines in the fill pattern.
double distance() const
Returns the distance between lines in the fill pattern.
void setOffset(double offset)
Sets the offset distance for lines within the fill, which is the distance to offset the parallel line...
Qgis::RenderUnit offsetUnit() const
Returns the units for the line pattern's offset.
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's line offset.
~QgsLinePatternFillSymbolLayer() override
A line symbol type, for rendering LineString and MultiLineString geometries.
Struct for storing maximum and minimum scales for measurements in map units.
A marker symbol type, for rendering Point and MultiPoint geometries.
Resolves relative paths into absolute paths and vice versa.
A fill symbol layer which fills polygon shapes with repeating marker symbols.
const QgsMapUnitScale & distanceYMapUnitScale() const
Returns the map unit scale for the vertical distance between points in the pattern.
void setDisplacementX(double d)
Sets the horizontal displacement for odd numbered rows in the pattern.
void setOffsetXUnit(Qgis::RenderUnit unit)
Sets the units for the horizontal offset between rows in the pattern.
Qgis::RenderUnit offsetYUnit() const
Returns the units for the vertical offset for rows in the pattern.
const QgsMapUnitScale & randomDeviationXMapUnitScale() const
Returns the unit scale for the horizontal random deviation of points in the pattern.
void setOffsetX(double offset)
Sets the horizontal offset values for points in the pattern.
double maximumRandomDeviationY() const
Returns the maximum vertical random deviation of points in the pattern.
void setDistanceYUnit(Qgis::RenderUnit unit)
Sets the unit for the vertical distance between points in the pattern.
Qgis::RenderUnit randomDeviationYUnit() const
Returns the units for the vertical random deviation of points in the pattern.
double displacementY() const
Returns the vertical displacement for odd numbered columns in the pattern.
void setDisplacementYUnit(Qgis::RenderUnit unit)
Sets the units for the vertical displacement between rows in the pattern.
void setRandomDeviationYUnit(Qgis::RenderUnit unit)
Sets the unit for the vertical random deviation of points in the pattern.
const QgsMapUnitScale & distanceXMapUnitScale() const
Returns the map unit scale for the horizontal distance between points in the pattern.
void setRandomDeviationYMapUnitScale(const QgsMapUnitScale &scale)
Sets the unit scale for the vertical random deviation of points in the pattern.
unsigned long seed() const
Returns the random number seed to use when randomly shifting points, or 0 if a truly random sequence ...
Qgis::MarkerClipMode clipMode() const
Returns the marker clipping mode, which defines how markers are clipped at the edges of shapes.
void setRandomDeviationXMapUnitScale(const QgsMapUnitScale &scale)
Sets the unit scale for the horizontal random deviation of points in the pattern.
Qgis::RenderUnit distanceXUnit() const
Returns the units for the horizontal distance between points in the pattern.
double offsetY() const
Returns the vertical offset values for points in the pattern.
void setDisplacementY(double d)
Sets the vertical displacement for odd numbered columns in the pattern.
void setMaximumRandomDeviationX(double deviation)
Sets the maximum horizontal random deviation of points in the pattern.
void setDisplacementYMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the vertical displacement between odd numbered columns in the pattern.
void setSeed(unsigned long seed)
Sets the random number seed to use when randomly shifting points, or 0 if a truly random sequence wil...
void setOffsetY(double offset)
Sets the vertical offset values for points in the pattern.
const QgsMapUnitScale & offsetXMapUnitScale() const
Returns the unit scale for the horizontal offset for rows in the pattern.
const QgsMapUnitScale & displacementXMapUnitScale() const
Returns the map unit scale for the horizontal displacement between odd numbered rows in the pattern.
const QgsMapUnitScale & offsetYMapUnitScale() const
Returns the unit scale for the vertical offset between rows in the pattern.
void setDistanceXMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the horizontal distance between points in the pattern.
Qgis::RenderUnit distanceYUnit() const
Returns the units for the vertical distance between points in the pattern.
const QgsMapUnitScale & displacementYMapUnitScale() const
Returns the map unit scale for the vertical displacement between odd numbered columns in the pattern.
void setDistanceXUnit(Qgis::RenderUnit unit)
Sets the unit for the horizontal distance between points in the pattern.
void setOffsetYUnit(Qgis::RenderUnit unit)
Sets the units for the vertical offset for rows in the pattern.
const QgsMapUnitScale & randomDeviationYMapUnitScale() const
Returns the unit scale for the vertical random deviation of points in the pattern.
Qgis::RenderUnit offsetXUnit() const
Returns the units for the horizontal offset for rows in the pattern.
void setOffsetYMapUnitScale(const QgsMapUnitScale &scale)
Sets the unit scale for the vertical offset for rows in the pattern.
void setDistanceY(double d)
Sets the vertical distance between rendered markers in the fill.
Qgis::RenderUnit displacementXUnit() const
Returns the units for the horizontal displacement between rows in the pattern.
Qgis::RenderUnit randomDeviationXUnit() const
Returns the units for the horizontal random deviation of points in the pattern.
void setDisplacementXUnit(Qgis::RenderUnit unit)
Sets the units for the horizontal displacement between rows in the pattern.
void setDistanceX(double d)
Sets the horizontal distance between rendered markers in the fill.
double offsetX() const
Returns the horizontal offset values for points in the pattern.
void setRandomDeviationXUnit(Qgis::RenderUnit unit)
Sets the unit for the horizontal random deviation of points in the pattern.
double maximumRandomDeviationX() const
Returns the maximum horizontal random deviation of points in the pattern.
std::unique_ptr< QgsMarkerSymbol > mMarkerSymbol
void setDisplacementXMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the horizontal displacement between odd numbered rows in the pattern.
void setMaximumRandomDeviationY(double deviation)
Sets the maximum vertical random deviation of points in the pattern.
void setDistanceYMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the vertical distance between points in the pattern.
Qgis::RenderUnit displacementYUnit() const
Returns the units for the vertical displacement between rows in the pattern.
double displacementX() const
Returns the horizontal displacement for odd numbered rows in the pattern.
void setOffsetXMapUnitScale(const QgsMapUnitScale &scale)
Sets the unit scale for the horizontal offset for rows in the pattern.
~QgsPointPatternFillSymbolLayer() override
double distanceY() const
Returns the vertical distance between rendered markers in the fill.
void setClipMode(Qgis::MarkerClipMode mode)
Sets the marker clipping mode, which defines how markers are clipped at the edges of shapes.
A fill symbol layer which places markers at random locations within polygons.
~QgsRandomMarkerFillSymbolLayer() override
void setDensityAreaUnitScale(const QgsMapUnitScale &scale)
Sets the map scale for the density area.
Qgis::RenderUnit densityAreaUnit() const
Returns the units for the density area.
const QgsMapUnitScale & densityAreaUnitScale() const
Returns the map scale for the density area.
A class for filling symbols with a repeated raster image.
double width() const
Returns the width used for scaling the image used in the fill.
void setOffsetUnit(const Qgis::RenderUnit unit)
Sets the units for the fill's offset.
Qgis::SymbolCoordinateReference coordinateMode() const
Coordinate mode for fill.
const QgsMapUnitScale & widthMapUnitScale() const
Returns the map unit scale for the image's width.
void setWidthUnit(const Qgis::RenderUnit unit)
Sets the units for the image's width.
Qgis::RenderUnit widthUnit() const
Returns the units for the image's width.
void setWidth(const double width)
Sets the width for scaling the image used in the fill.
Qgis::RenderUnit offsetUnit() const
Returns the units for the fill's offset.
double opacity() const
Returns the opacity for the raster image used in the fill.
~QgsRasterFillSymbolLayer() override
void setWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the image's width.
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the fill's offset.
QString imageFilePath() const
The path to the raster image used for the fill.
QPointF offset() const
Returns the offset for the fill.
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the fill's offset.
void setOffset(QPointF offset)
Sets the offset for the fill.
Contains information about the context of a rendering operation.
A class for filling symbols with a repeated SVG file.
void setSvgStrokeWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's stroke.
QColor svgStrokeColor() const
Returns the stroke color used for rendering the SVG content.
void setSvgStrokeWidthUnit(Qgis::RenderUnit unit)
Sets the unit for the stroke width.
Qgis::RenderUnit patternWidthUnit() const
Returns the units for the width of the SVG images in the pattern.
void setSvgFillColor(const QColor &c)
Sets the fill color used for rendering the SVG content.
const QgsMapUnitScale & svgStrokeWidthMapUnitScale() const
Returns the map unit scale for the pattern's stroke.
double svgStrokeWidth() const
Returns the stroke width used for rendering the SVG content.
QMap< QString, QgsProperty > parameters() const
Returns the dynamic SVG parameters.
void setSvgStrokeWidth(double w)
Sets the stroke width used for rendering the SVG content.
void setPatternWidthUnit(Qgis::RenderUnit unit)
Sets the unit for the width of the SVG images in the pattern.
QColor svgFillColor() const
Returns the fill color used for rendering the SVG content.
void setSvgStrokeColor(const QColor &c)
Sets the stroke color used for rendering the SVG content.
const QgsMapUnitScale & patternWidthMapUnitScale() const
Returns the map unit scale for the pattern's width.
Qgis::RenderUnit svgStrokeWidthUnit() const
Returns the units for the stroke width.
void setPatternWidth(double width)
Sets the width to render the SVG content as within the fill (i.e.
double patternWidth() const
Returns the width of the rendered SVG content within the fill (i.e.
~QgsSVGFillSymbolLayer() override
void setPatternWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's width.
~QgsShapeburstFillSymbolLayer() override
Qgis::RenderUnit offsetUnit() const
Returns the units used for the offset of the shapeburst fill.
QgsColorRamp * colorRamp()
Returns the color ramp used for the shapeburst fill.
int blurRadius() const
Returns the blur radius, which controls the amount of blurring applied to the fill.
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
void setOffsetUnit(Qgis::RenderUnit unit)
Sets the units used for the offset for the shapeburst fill.
void setOffset(QPointF offset)
Sets the offset for the shapeburst fill.
void setUseWholeShape(bool useWholeShape)
Sets whether the shapeburst fill should be drawn using the entire shape.
QColor color2() const
Returns the color used for the endpoint of the shapeburst fill.
void setIgnoreRings(bool ignoreRings)
Sets whether the shapeburst fill should ignore polygon rings when calculating the buffered shading.
void setMaxDistance(double maxDistance)
Sets the maximum distance to shape inside of the shape from the polygon's boundary.
void setColor2(const QColor &color2)
Sets the color for the endpoint of the shapeburst fill.
QgsShapeburstFillSymbolLayer & operator=(const QgsShapeburstFillSymbolLayer &other)=delete
QgsShapeburstFillSymbolLayer cannot be copied.
Qgis::RenderUnit distanceUnit() const
Returns the unit for the maximum distance to shade inside of the shape from the polygon's boundary.
QPointF offset() const
Returns the offset for the shapeburst fill.
bool useWholeShape() const
Returns whether the shapeburst fill is set to cover the entire shape.
bool ignoreRings() const
Returns whether the shapeburst fill is set to ignore polygon interior rings.
double maxDistance() const
Returns the maximum distance from the shape's boundary which is shaded.
const QgsMapUnitScale & offsetMapUnitScale() const
void setDistanceUnit(Qgis::RenderUnit unit)
Sets the unit for the maximum distance to shade inside of the shape from the polygon's boundary.
void setDistanceMapUnitScale(const QgsMapUnitScale &scale)
void setColorType(Qgis::GradientColorSource colorType)
Sets the color mode to use for the shapeburst fill.
Qgis::GradientColorSource colorType() const
Returns the color mode used for the shapeburst fill.
QgsShapeburstFillSymbolLayer(const QgsShapeburstFillSymbolLayer &other)=delete
QgsShapeburstFillSymbolLayer cannot be copied.
const QgsMapUnitScale & distanceMapUnitScale() const
Qgis::RenderUnit strokeWidthUnit() const
Returns the units for the width of the fill's stroke.
Qt::PenJoinStyle penJoinStyle() const
QColor strokeColor() const override
Returns the stroke color for the symbol layer.
void setBrushStyle(Qt::BrushStyle style)
void setStrokeWidthMapUnitScale(const QgsMapUnitScale &scale)
const QgsMapUnitScale & strokeWidthMapUnitScale() const
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the fill's offset.
void setStrokeWidthUnit(Qgis::RenderUnit unit)
Sets the units for the width of the fill's stroke.
~QgsSimpleFillSymbolLayer() override
void setPenJoinStyle(Qt::PenJoinStyle style)
QColor fillColor() const override
Returns the fill color for the symbol layer.
Qt::PenStyle strokeStyle() const
QgsMapUnitScale mOffsetMapUnitScale
void setStrokeWidth(double strokeWidth)
QPointF offset() const
Returns the offset by which polygons will be translated during rendering.
Qgis::RenderUnit offsetUnit() const
Returns the units for the fill's offset.
void setStrokeStyle(Qt::PenStyle strokeStyle)
QgsMapUnitScale mStrokeWidthMapUnitScale
void setOffsetUnit(Qgis::RenderUnit unit)
Sets the unit for the fill's offset.
void setFillColor(const QColor &color) override
Sets the fill color for the symbol layer.
void setOffset(QPointF offset)
Sets an offset by which polygons will be translated during rendering.
void setStrokeColor(const QColor &strokeColor) override
Sets the stroke color for the symbol layer.
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the fill's offset.
virtual QgsSymbolLayer * clone() const =0
Shall be reimplemented by subclasses to create a deep copy of the instance.
virtual bool setSubSymbol(QgsSymbol *symbol)
Sets layer's subsymbol. takes ownership of the passed symbol.
virtual void startFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called before the layer will be rendered for a particular feature.
virtual QgsMapUnitScale mapUnitScale() const
virtual QColor dxfBrushColor(QgsSymbolRenderContext &context) const
Gets brush/fill color.
virtual QSet< QString > usedAttributes(const QgsRenderContext &context) const
Returns the set of attributes referenced by the layer.
virtual double estimateMaxBleed(const QgsRenderContext &context) const
Returns the estimated maximum distance which the layer style will bleed outside the drawn shape when ...
virtual void startRender(QgsSymbolRenderContext &context)=0
Called before a set of rendering operations commences on the supplied render context.
virtual QVariantMap properties() const =0
Should be reimplemented by subclasses to return a string map that contains the configuration informat...
virtual Qt::PenStyle dxfPenStyle() const
Gets pen style.
virtual QColor dxfColor(QgsSymbolRenderContext &context) const
Gets color.
virtual QString layerType() const =0
Returns a string that represents this layer type.
virtual void stopRender(QgsSymbolRenderContext &context)=0
Called after a set of rendering operations has finished on the supplied render context.
virtual Qgis::RenderUnit outputUnit() const
Returns the units to use for sizes and widths within the symbol 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.
virtual QColor color() const
Returns the "representative" color of the symbol layer.
virtual void stopFeatureRender(const QgsFeature &feature, QgsRenderContext &context)
Called after the layer has been rendered for a particular feature.
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.
virtual bool canCauseArtifactsBetweenAdjacentTiles() const
Returns true if the symbol layer rendering can cause visible artifacts across a single feature when t...
virtual void setMapUnitScale(const QgsMapUnitScale &scale)
virtual bool usesMapUnits() const
Returns true if the symbol layer has any components which use map unit based sizes.
virtual void setOutputUnit(Qgis::RenderUnit unit)
Sets the units to use for sizes and widths within the symbol layer.
virtual Qt::BrushStyle dxfBrushStyle() const
Gets brush/fill style.
virtual bool hasDataDefinedProperties() const
Returns true if the symbol layer (or any of its sub-symbols) contains data defined properties.
Abstract base class for all rendered symbols.
Definition qgssymbol.h:94
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< QString, QString > QgsStringMap
Definition qgis.h:4877
#define SIP_TRANSFER
Definition qgis_sip.h:36
#define SIP_ABSTRACT
Definition qgis_sip.h:208
#define SIP_FACTORY
Definition qgis_sip.h:76
#define DEFAULT_SIMPLEFILL_JOINSTYLE
#define DEFAULT_SIMPLEFILL_COLOR
#define DEFAULT_SIMPLEFILL_STYLE
#define DEFAULT_SIMPLEFILL_BORDERSTYLE
#define DEFAULT_SIMPLEFILL_BORDERCOLOR
#define DEFAULT_SIMPLEFILL_BORDERWIDTH