QGIS API Documentation 3.29.0-Master (8c80f25a4f)
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( QgsUnitTypes::RenderUnit unit ) { mStrokeWidthUnit = unit; }
128
133 QgsUnitTypes::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( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
144
150 QgsUnitTypes::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( QgsUnitTypes::RenderUnit unit ) override;
167 QgsUnitTypes::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
183 protected:
184 QBrush mBrush;
185 QBrush mSelBrush;
186 Qt::BrushStyle mBrushStyle;
188 Qt::PenStyle mStrokeStyle;
192 Qt::PenJoinStyle mPenJoinStyle;
193 QPen mPen;
195
196 QPointF mOffset;
199
200 private:
201 //helper functions for data defined symbology
202 void applyDataDefinedSymbology( QgsSymbolRenderContext &context, QBrush &brush, QPen &pen, QPen &selPen );
203};
204
205class QgsColorRamp;
206
212{
213 public:
214
219 const QColor &color2 = Qt::white,
224 );
225
227
228 // static stuff
229
235 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
236
237 // implemented from base classes
238
239 QString layerType() const override;
240 void startRender( QgsSymbolRenderContext &context ) override;
241 void stopRender( QgsSymbolRenderContext &context ) override;
242 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
243 QVariantMap properties() const override;
245 double estimateMaxBleed( const QgsRenderContext &context ) const override;
246 bool canCauseArtifactsBetweenAdjacentTiles() const override;
247
253 Qgis::GradientType gradientType() const { return mGradientType; }
254
260 void setGradientType( Qgis::GradientType gradientType ) { mGradientType = gradientType; }
261
267 Qgis::GradientColorSource gradientColorType() const { return mGradientColorType; }
268
274 void setGradientColorType( Qgis::GradientColorSource gradientColorType ) { mGradientColorType = gradientColorType; }
275
282 QgsColorRamp *colorRamp() { return mGradientRamp; }
283
291 void setColorRamp( QgsColorRamp *ramp SIP_TRANSFER );
292
298 QColor color2() const { return mColor2; }
299
305 void setColor2( const QColor &color2 ) { mColor2 = color2; }
306
312 Qgis::SymbolCoordinateReference coordinateMode() const { return mCoordinateMode; }
313
319 void setCoordinateMode( Qgis::SymbolCoordinateReference coordinateMode ) { mCoordinateMode = coordinateMode; }
320
326 Qgis::GradientSpread gradientSpread() const { return mGradientSpread; }
327
333 void setGradientSpread( Qgis::GradientSpread gradientSpread ) { mGradientSpread = gradientSpread; }
334
340 void setReferencePoint1( QPointF referencePoint ) { mReferencePoint1 = referencePoint; }
341
347 QPointF referencePoint1() const { return mReferencePoint1; }
348
354 void setReferencePoint1IsCentroid( bool isCentroid ) { mReferencePoint1IsCentroid = isCentroid; }
355
361 bool referencePoint1IsCentroid() const { return mReferencePoint1IsCentroid; }
362
368 void setReferencePoint2( QPointF referencePoint ) { mReferencePoint2 = referencePoint; }
369
375 QPointF referencePoint2() const { return mReferencePoint2; }
376
382 void setReferencePoint2IsCentroid( bool isCentroid ) { mReferencePoint2IsCentroid = isCentroid; }
383
384
390 bool referencePoint2IsCentroid() const { return mReferencePoint2IsCentroid; }
391
400 void setOffset( QPointF offset ) { mOffset = offset; }
401
410 QPointF offset() const { return mOffset; }
411
417 void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
418
424 QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
425
431 void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
432
438 const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
439
440 void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
441 QgsUnitTypes::RenderUnit outputUnit() const override;
442 bool usesMapUnits() const override;
443
444 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
445 QgsMapUnitScale mapUnitScale() const override;
446
447 protected:
448 QBrush mBrush;
449 QBrush mSelBrush;
450
452 QColor mColor2;
453 QgsColorRamp *mGradientRamp = nullptr;
457
459 bool mReferencePoint1IsCentroid = false;
461 bool mReferencePoint2IsCentroid = false;
462
463 QPointF mOffset;
466
467 private:
468
469 //helper functions for data defined symbology
470 void applyDataDefinedSymbology( QgsSymbolRenderContext &context, const QPolygonF &points );
471
473 void applyGradient( const QgsSymbolRenderContext &context, QBrush &brush, const QColor &color, const QColor &color2,
474 Qgis::GradientColorSource gradientColorType, QgsColorRamp *gradientRamp, Qgis::GradientType gradientType,
475 Qgis::SymbolCoordinateReference coordinateMode, Qgis::GradientSpread gradientSpread,
476 QPointF referencePoint1, QPointF referencePoint2, double angle );
477
479 QPointF rotateReferencePoint( QPointF refPoint, double angle );
480};
481
487{
488 public:
489
493 QgsShapeburstFillSymbolLayer( const QColor &color = DEFAULT_SIMPLEFILL_COLOR, const QColor &color2 = Qt::white,
495 int blurRadius = 0, bool useWholeShape = true, double maxDistance = 5 );
496
498
504
510
511 // static stuff
512
518 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
519
520 // implemented from base classes
521
522 QString layerType() const override;
523 void startRender( QgsSymbolRenderContext &context ) override;
524 void stopRender( QgsSymbolRenderContext &context ) override;
525 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
526 QVariantMap properties() const override;
527 QgsShapeburstFillSymbolLayer *clone() const override SIP_FACTORY;
528 double estimateMaxBleed( const QgsRenderContext &context ) const override;
529 bool canCauseArtifactsBetweenAdjacentTiles() const override;
530
537 void setBlurRadius( int blurRadius ) { mBlurRadius = blurRadius; }
538
545 int blurRadius() const { return mBlurRadius; }
546
555 void setUseWholeShape( bool useWholeShape ) { mUseWholeShape = useWholeShape; }
556
564 bool useWholeShape() const { return mUseWholeShape; }
565
574 void setMaxDistance( double maxDistance ) { mMaxDistance = maxDistance; }
575
584 double maxDistance() const { return mMaxDistance; }
585
593 void setDistanceUnit( QgsUnitTypes::RenderUnit unit ) { mDistanceUnit = unit; }
594
602 QgsUnitTypes::RenderUnit distanceUnit() const { return mDistanceUnit; }
603
604 void setDistanceMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceMapUnitScale = scale; }
605 const QgsMapUnitScale &distanceMapUnitScale() const { return mDistanceMapUnitScale; }
606
617 void setColorType( Qgis::GradientColorSource colorType ) { mColorType = colorType; }
618
629 Qgis::GradientColorSource colorType() const { return mColorType; }
630
640 void setColorRamp( QgsColorRamp *ramp SIP_TRANSFER );
641
649 QgsColorRamp *colorRamp() { return mGradientRamp.get(); }
650
658 void setColor2( const QColor &color2 ) { mColor2 = color2; }
659
667 QColor color2() const { return mColor2; }
668
676 void setIgnoreRings( bool ignoreRings ) { mIgnoreRings = ignoreRings; }
677
684 bool ignoreRings() const { return mIgnoreRings; }
685
693 void setOffset( QPointF offset ) { mOffset = offset; }
694
702 QPointF offset() const { return mOffset; }
703
711 void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
712
720 QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
721
722 void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
723 const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
724
725 void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
726 QgsUnitTypes::RenderUnit outputUnit() const override;
727 bool usesMapUnits() const override;
728
729 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
730 QgsMapUnitScale mapUnitScale() const override;
731
732 private:
733 QBrush mBrush;
734 QBrush mSelBrush;
735
736 int mBlurRadius = 0;
737
738 bool mUseWholeShape = true;
739 double mMaxDistance = 5.0;
741 QgsMapUnitScale mDistanceMapUnitScale;
742
744 QColor mColor2;
745
746 bool mIgnoreRings = false;
747
748 QPointF mOffset;
750 QgsMapUnitScale mOffsetMapUnitScale;
751
752 std::unique_ptr< QgsColorRamp > mGradientRamp;
753
754 //helper functions for data defined symbology
755 void applyDataDefinedSymbology( QgsSymbolRenderContext &context, QColor &color, QColor &color2, int &blurRadius, bool &useWholeShape,
756 double &maxDistance, bool &ignoreRings );
757
758 /* distance transform of a 1d function using squared distance */
759 void distanceTransform1d( double *f, int n, int *v, double *z, double *d );
760 /* distance transform of 2d function using squared distance */
761 void distanceTransform2d( double *im, int width, int height, QgsRenderContext &context );
762 /* distance transform of a binary QImage */
763 double *distanceTransform( QImage *im, QgsRenderContext &context );
764
765 /* fills a QImage with values from an array of doubles containing squared distance transform values */
766 void dtArrayToQImage( double *array, QImage *im, QgsColorRamp *ramp, QgsRenderContext &context, bool useWholeShape = true, int maxPixelDistance = 0 );
767
768#ifdef SIP_RUN
770#endif
771};
772
778{
779 public:
780
783
784 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
785
791 void setStrokeWidthUnit( QgsUnitTypes::RenderUnit unit ) { mStrokeWidthUnit = unit; }
792
798 QgsUnitTypes::RenderUnit strokeWidthUnit() const { return mStrokeWidthUnit; }
799
806 void setStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mStrokeWidthMapUnitScale = scale; }
807
816 const QgsMapUnitScale &strokeWidthMapUnitScale() const { return mStrokeWidthMapUnitScale; }
817
825 void setCoordinateReference( Qgis::SymbolCoordinateReference coordinateReference ) { mCoordinateReference = coordinateReference; }
826
834 Qgis::SymbolCoordinateReference coordinateReference() const { return mCoordinateReference; }
835
836 void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
837 QgsUnitTypes::RenderUnit outputUnit() const override;
838 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
839 QgsMapUnitScale mapUnitScale() const override;
840 double dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const override;
841 Qt::PenStyle dxfPenStyle() const override;
842 QVariantMap properties() const override;
843
844 protected:
845 QBrush mBrush;
847 double mNextAngle = 0.0; // mAngle / data defined angle
848
850 double mStrokeWidth = 0.0;
853
857 virtual void applyDataDefinedSettings( QgsSymbolRenderContext &context ) { Q_UNUSED( context ) }
858
864 virtual bool applyBrushTransformFromContext( QgsSymbolRenderContext *context = nullptr ) const;
865
866 private:
867#ifdef SIP_RUN
869#endif
870};
871
879{
880 public:
881
886 QgsRasterFillSymbolLayer( const QString &imageFilePath = QString() );
887
889
894 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
895
901 static void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving );
902
903 // implemented from base classes
904 QString layerType() const override;
905 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
906 void startRender( QgsSymbolRenderContext &context ) override;
907 void stopRender( QgsSymbolRenderContext &context ) override;
908 QVariantMap properties() const override;
909 QgsRasterFillSymbolLayer *clone() const override SIP_FACTORY;
910 double estimateMaxBleed( const QgsRenderContext &context ) const override;
911 bool usesMapUnits() const override;
912 QColor color() const override;
913 void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
914
915 //override QgsImageFillSymbolLayer's support for sub symbols
916 QgsSymbol *subSymbol() override { return nullptr; }
917 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
918
924 void setImageFilePath( const QString &imagePath );
925
931 QString imageFilePath() const { return mImageFilePath; }
932
939 void setCoordinateMode( Qgis::SymbolCoordinateReference mode );
940
947 Qgis::SymbolCoordinateReference coordinateMode() const { return mCoordinateMode; }
948
954 void setOpacity( double opacity );
955
961 double opacity() const { return mOpacity; }
962
970 void setOffset( QPointF offset ) { mOffset = offset; }
971
979 QPointF offset() const { return mOffset; }
980
988 void setOffsetUnit( const QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
989
997 QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
998
1006 void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
1007
1015 const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
1016
1025 void setWidth( const double width ) { mWidth = width; }
1026
1035 double width() const { return mWidth; }
1036
1044 void setWidthUnit( const QgsUnitTypes::RenderUnit unit ) { mWidthUnit = unit; }
1045
1053 QgsUnitTypes::RenderUnit widthUnit() const { return mWidthUnit; }
1054
1062 void setWidthMapUnitScale( const QgsMapUnitScale &scale ) { mWidthMapUnitScale = scale; }
1063
1071 const QgsMapUnitScale &widthMapUnitScale() const { return mWidthMapUnitScale; }
1072
1073 protected:
1074
1075 void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
1076 bool applyBrushTransformFromContext( QgsSymbolRenderContext *context = nullptr ) const override;
1077 private:
1078
1080 QString mImageFilePath;
1082 double mOpacity = 1.0;
1083
1084 QPointF mOffset;
1086 QgsMapUnitScale mOffsetMapUnitScale;
1087
1088 double mWidth = 0.0;
1090 QgsMapUnitScale mWidthMapUnitScale;
1091
1093 void applyPattern( QBrush &brush, const QString &imageFilePath, double width, double opacity,
1094 const QgsSymbolRenderContext &context );
1095};
1096
1102{
1103 public:
1104
1108 QgsSVGFillSymbolLayer( const QString &svgFilePath, double width = 20, double rotation = 0.0 );
1109
1113 QgsSVGFillSymbolLayer( const QByteArray &svgData, double width = 20, double rotation = 0.0 );
1114
1116
1121 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
1122
1127 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
1128
1134 static void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving );
1135
1136 // implemented from base classes
1137
1138 QString layerType() const override;
1139 void startRender( QgsSymbolRenderContext &context ) override;
1140 void stopRender( QgsSymbolRenderContext &context ) override;
1141 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
1142 QVariantMap properties() const override;
1143 QgsSVGFillSymbolLayer *clone() const override SIP_FACTORY;
1144 void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
1145 bool usesMapUnits() const override;
1146 QgsSymbol *subSymbol() override;
1147 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
1148 double estimateMaxBleed( const QgsRenderContext &context ) const override;
1149 QColor dxfColor( QgsSymbolRenderContext &context ) const override;
1150 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
1151 bool hasDataDefinedProperties() const override;
1152
1164 void setSvgFilePath( const QString &svgPath );
1165
1171 QString svgFilePath() const { return mSvgFilePath; }
1172
1182 void setPatternWidth( double width ) { mPatternWidth = width;}
1183
1193 double patternWidth() const { return mPatternWidth; }
1194
1204 void setSvgFillColor( const QColor &c ) { setColor( c ); }
1205
1214 QColor svgFillColor() const { return color(); }
1215
1225 void setSvgStrokeColor( const QColor &c ) { mSvgStrokeColor = c; }
1226
1235 QColor svgStrokeColor() const { return mSvgStrokeColor; }
1236
1247 void setSvgStrokeWidth( double w ) { mSvgStrokeWidth = w; }
1248
1259 double svgStrokeWidth() const { return mSvgStrokeWidth; }
1260
1268 void setPatternWidthUnit( QgsUnitTypes::RenderUnit unit ) { mPatternWidthUnit = unit; }
1269
1277 QgsUnitTypes::RenderUnit patternWidthUnit() const { return mPatternWidthUnit; }
1278
1286 void setPatternWidthMapUnitScale( const QgsMapUnitScale &scale ) { mPatternWidthMapUnitScale = scale; }
1287
1295 const QgsMapUnitScale &patternWidthMapUnitScale() const { return mPatternWidthMapUnitScale; }
1296
1304 void setSvgStrokeWidthUnit( QgsUnitTypes::RenderUnit unit ) { mSvgStrokeWidthUnit = unit; }
1305
1313 QgsUnitTypes::RenderUnit svgStrokeWidthUnit() const { return mSvgStrokeWidthUnit; }
1314
1322 void setSvgStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mSvgStrokeWidthMapUnitScale = scale; }
1323
1331 const QgsMapUnitScale &svgStrokeWidthMapUnitScale() const { return mSvgStrokeWidthMapUnitScale; }
1332
1333 void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
1334 QgsUnitTypes::RenderUnit outputUnit() const override;
1335
1336 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
1337 QgsMapUnitScale mapUnitScale() const override;
1338
1343 QMap<QString, QgsProperty> parameters() const { return mParameters; }
1344
1349 void setParameters( const QMap<QString, QgsProperty> &parameters );
1350
1351 protected:
1352
1353 void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
1354
1355 private:
1356
1358 double mPatternWidth = 20;
1360 QgsMapUnitScale mPatternWidthMapUnitScale;
1361 QMap<QString, QgsProperty> mParameters;
1362
1364 QByteArray mSvgData;
1366 QString mSvgFilePath;
1368 QRectF mSvgViewBox;
1369
1370 //param(fill), param(stroke), param(stroke-width) are going
1371 //to be replaced in memory
1372 QColor mSvgStrokeColor = QColor( 35, 35, 35 );
1373 double mSvgStrokeWidth = 0.2;
1375 QgsMapUnitScale mSvgStrokeWidthMapUnitScale;
1376
1378 std::unique_ptr< QgsLineSymbol > mStroke;
1379
1381 void storeViewBox();
1382 void setDefaultSvgParams(); //fills mSvgFillColor, mSvgStrokeColor, mSvgStrokeWidth with default values for mSvgFilePath
1383
1385 void applyPattern( QBrush &brush, const QString &svgFilePath, double patternWidth, QgsUnitTypes::RenderUnit patternWidthUnit, const QColor &svgFillColor, const QColor &svgStrokeColor,
1386 double svgStrokeWidth, QgsUnitTypes::RenderUnit svgStrokeWidthUnit, const QgsSymbolRenderContext &context, const QgsMapUnitScale &patternWidthMapUnitScale, const QgsMapUnitScale &svgStrokeWidthMapUnitScale,
1387 const QgsStringMap svgParameters );
1388};
1389
1396{
1397 public:
1400
1405 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
1406
1411 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
1412
1413 QString layerType() const override;
1414 void startRender( QgsSymbolRenderContext &context ) override;
1415 void stopRender( QgsSymbolRenderContext &context ) override;
1416 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
1417 QVariantMap properties() const override;
1418 QgsLinePatternFillSymbolLayer *clone() const override SIP_FACTORY;
1419 void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
1420 double estimateMaxBleed( const QgsRenderContext &context ) const override;
1421
1422 QString ogrFeatureStyleWidth( double widthScaleFactor ) const;
1423
1431 void setLineAngle( double a ) { mLineAngle = a; }
1432
1440 double lineAngle() const { return mLineAngle; }
1441
1448 void setDistance( double d ) { mDistance = d; }
1449
1455 double distance() const { return mDistance; }
1456
1463 void setLineWidth( double w );
1464
1471 double lineWidth() const { return mLineWidth; }
1472
1473 void setColor( const QColor &c ) override;
1474 QColor color() const override;
1475
1487 void setOffset( double offset ) { mOffset = offset; }
1488
1500 double offset() const { return mOffset; }
1501
1508 void setDistanceUnit( QgsUnitTypes::RenderUnit unit ) { mDistanceUnit = unit; }
1509
1516 QgsUnitTypes::RenderUnit distanceUnit() const { return mDistanceUnit; }
1517
1525 void setDistanceMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceMapUnitScale = scale; }
1526
1534 const QgsMapUnitScale &distanceMapUnitScale() const { return mDistanceMapUnitScale; }
1535
1541 void setLineWidthUnit( QgsUnitTypes::RenderUnit unit ) { mLineWidthUnit = unit; }
1542
1548 QgsUnitTypes::RenderUnit lineWidthUnit() const { return mLineWidthUnit; }
1549
1557 void setLineWidthMapUnitScale( const QgsMapUnitScale &scale ) { mLineWidthMapUnitScale = scale; }
1558
1566 const QgsMapUnitScale &lineWidthMapUnitScale() const { return mLineWidthMapUnitScale; }
1567
1573 void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
1574
1580 QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
1581
1589 void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
1590
1598 const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
1599
1606 Qgis::LineClipMode clipMode() const { return mClipMode; }
1607
1614 void setClipMode( Qgis::LineClipMode mode ) { mClipMode = mode; }
1615
1616 void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
1617 QgsUnitTypes::RenderUnit outputUnit() const override;
1618 bool usesMapUnits() const override;
1619 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
1620 QgsMapUnitScale mapUnitScale() const override;
1621 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
1622 QgsSymbol *subSymbol() override;
1623 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
1624 bool hasDataDefinedProperties() const override;
1625 void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
1626 void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
1627
1628 protected:
1629
1630 void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
1631
1632 private:
1634 double mDistance = 5.0;
1636 QgsMapUnitScale mDistanceMapUnitScale;
1638 double mLineWidth = 0;
1640 QgsMapUnitScale mLineWidthMapUnitScale;
1642 double mLineAngle = 45.0;
1644 double mOffset = 0.0;
1646 QgsMapUnitScale mOffsetMapUnitScale;
1647
1648 bool mRenderUsingLines = false;
1649
1650#ifdef SIP_RUN
1652#endif
1653
1655 void applyPattern( const QgsSymbolRenderContext &context, QBrush &brush, double lineAngle, double distance );
1656
1658 std::unique_ptr< QgsLineSymbol > mFillLineSymbol;
1659
1661};
1662
1669{
1670 public:
1673
1679 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
1680 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
1681
1682 QString layerType() const override;
1683 void startRender( QgsSymbolRenderContext &context ) override;
1684 void stopRender( QgsSymbolRenderContext &context ) override;
1685 void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
1686 void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
1687 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
1688 QVariantMap properties() const override;
1689 QgsPointPatternFillSymbolLayer *clone() const override SIP_FACTORY;
1690 void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
1691 double estimateMaxBleed( const QgsRenderContext &context ) const override;
1692 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
1693 QgsSymbol *subSymbol() override;
1694 void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
1695 QgsUnitTypes::RenderUnit outputUnit() const override;
1696 bool usesMapUnits() const override;
1697 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
1698 QgsMapUnitScale mapUnitScale() const override;
1699 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
1700 bool hasDataDefinedProperties() const override;
1701 void setColor( const QColor &c ) override;
1702 QColor color() const override;
1703
1713 double distanceX() const { return mDistanceX; }
1714
1724 void setDistanceX( double d ) { mDistanceX = d; }
1725
1732 void setDistanceXUnit( QgsUnitTypes::RenderUnit unit ) { mDistanceXUnit = unit; }
1733
1739 QgsUnitTypes::RenderUnit distanceXUnit() const { return mDistanceXUnit; }
1740
1747 void setDistanceXMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceXMapUnitScale = scale; }
1748
1755 const QgsMapUnitScale &distanceXMapUnitScale() const { return mDistanceXMapUnitScale; }
1756
1766 double distanceY() const { return mDistanceY; }
1767
1777 void setDistanceY( double d ) { mDistanceY = d; }
1778
1785 void setDistanceYUnit( QgsUnitTypes::RenderUnit unit ) { mDistanceYUnit = unit; }
1786
1792 QgsUnitTypes::RenderUnit distanceYUnit() const { return mDistanceYUnit; }
1793
1800 void setDistanceYMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceYMapUnitScale = scale; }
1801
1808 const QgsMapUnitScale &distanceYMapUnitScale() const { return mDistanceYMapUnitScale; }
1809
1819 double displacementX() const { return mDisplacementX; }
1820
1830 void setDisplacementX( double d ) { mDisplacementX = d; }
1831
1838 void setDisplacementXUnit( QgsUnitTypes::RenderUnit unit ) { mDisplacementXUnit = unit; }
1839
1845 QgsUnitTypes::RenderUnit displacementXUnit() const { return mDisplacementXUnit; }
1846
1853 void setDisplacementXMapUnitScale( const QgsMapUnitScale &scale ) { mDisplacementXMapUnitScale = scale; }
1854
1861 const QgsMapUnitScale &displacementXMapUnitScale() const { return mDisplacementXMapUnitScale; }
1862
1872 double displacementY() const { return mDisplacementY; }
1873
1883 void setDisplacementY( double d ) { mDisplacementY = d; }
1884
1891 void setDisplacementYUnit( QgsUnitTypes::RenderUnit unit ) { mDisplacementYUnit = unit; }
1892
1898 QgsUnitTypes::RenderUnit displacementYUnit() const { return mDisplacementYUnit; }
1899
1906 void setDisplacementYMapUnitScale( const QgsMapUnitScale &scale ) { mDisplacementYMapUnitScale = scale; }
1907
1914 const QgsMapUnitScale &displacementYMapUnitScale() const { return mDisplacementYMapUnitScale; }
1915
1923 void setOffsetX( double offset ) { mOffsetX = offset; }
1924
1931 double offsetX() const { return mOffsetX; }
1932
1940 void setOffsetY( double offset ) { mOffsetY = offset; }
1941
1948 double offsetY() const { return mOffsetY; }
1949
1957 void setOffsetXUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetXUnit = unit; }
1958
1965 QgsUnitTypes::RenderUnit offsetXUnit() const { return mOffsetXUnit; }
1966
1974 void setOffsetXMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetXMapUnitScale = scale; }
1975
1982 const QgsMapUnitScale &offsetXMapUnitScale() const { return mOffsetXMapUnitScale; }
1983
1991 void setOffsetYUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetYUnit = unit; }
1992
1999 QgsUnitTypes::RenderUnit offsetYUnit() const { return mOffsetYUnit; }
2000
2008 void setOffsetYMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetYMapUnitScale = scale; }
2009
2016 const QgsMapUnitScale &offsetYMapUnitScale() const { return mOffsetYMapUnitScale; }
2017
2024 Qgis::MarkerClipMode clipMode() const { return mClipMode; }
2025
2032 void setClipMode( Qgis::MarkerClipMode mode ) { mClipMode = mode; }
2033
2043 void setMaximumRandomDeviationX( double deviation ) { mRandomDeviationX = deviation; }
2044
2054 double maximumRandomDeviationX() const { return mRandomDeviationX; }
2055
2065 void setMaximumRandomDeviationY( double deviation ) { mRandomDeviationY = deviation; }
2066
2076 double maximumRandomDeviationY() const { return mRandomDeviationY; }
2077
2085 void setRandomDeviationXUnit( QgsUnitTypes::RenderUnit unit ) { mRandomDeviationXUnit = unit; }
2086
2094 QgsUnitTypes::RenderUnit randomDeviationXUnit() const { return mRandomDeviationXUnit; }
2095
2103 void setRandomDeviationYUnit( QgsUnitTypes::RenderUnit unit ) { mRandomDeviationYUnit = unit; }
2104
2113 QgsUnitTypes::RenderUnit randomDeviationYUnit() const { return mRandomDeviationYUnit; }
2114
2122 const QgsMapUnitScale &randomDeviationXMapUnitScale() const { return mRandomDeviationXMapUnitScale; }
2123
2131 const QgsMapUnitScale &randomDeviationYMapUnitScale() const { return mRandomDeviationYMapUnitScale; }
2132
2140 void setRandomDeviationXMapUnitScale( const QgsMapUnitScale &scale ) { mRandomDeviationXMapUnitScale = scale; }
2141
2149 void setRandomDeviationYMapUnitScale( const QgsMapUnitScale &scale ) { mRandomDeviationYMapUnitScale = scale; }
2150
2157 unsigned long seed() const { return mSeed; }
2158
2167 void setSeed( unsigned long seed ) { mSeed = seed; }
2168
2175 double angle() const { return mAngle; }
2176
2183 void setAngle( double angle ) { mAngle = angle; }
2184
2185 protected:
2186 std::unique_ptr< QgsMarkerSymbol > mMarkerSymbol;
2187 double mDistanceX = 15;
2190 double mDistanceY = 15;
2193 double mDisplacementX = 0;
2196 double mDisplacementY = 0;
2199 double mOffsetX = 0;
2202 double mOffsetY = 0;
2205
2206 double mRandomDeviationX = 0;
2209 double mRandomDeviationY = 0;
2212 unsigned long mSeed = 0;
2213
2214 double mAngle = 0;
2215
2216 void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
2217
2218 private:
2219#ifdef SIP_RUN
2221#endif
2222
2223 void applyPattern( const QgsSymbolRenderContext &context, QBrush &brush, double distanceX, double distanceY,
2224 double displacementX, double displacementY, double offsetX, double offsetY );
2225
2227
2228 bool mRenderUsingMarkers = false;
2229};
2230
2240{
2241 public:
2242
2249 QgsRandomMarkerFillSymbolLayer( int pointCount = 10, Qgis::PointCountMethod method = Qgis::PointCountMethod::Absolute, double densityArea = 250.0, unsigned long seed = 0 );
2250
2252
2258 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
2259
2260 QString layerType() const override;
2261 void startRender( QgsSymbolRenderContext &context ) override;
2262 void stopRender( QgsSymbolRenderContext &context ) override;
2263 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
2264 QVariantMap properties() const override;
2265 QgsRandomMarkerFillSymbolLayer *clone() const override SIP_FACTORY;
2266 bool canCauseArtifactsBetweenAdjacentTiles() const override;
2267
2268 void setColor( const QColor &color ) override;
2269 QColor color() const override;
2270
2271 QgsSymbol *subSymbol() override;
2272 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
2273
2274 void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
2275 QgsUnitTypes::RenderUnit outputUnit() const override;
2276 bool usesMapUnits() const override;
2277
2278 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
2279 QgsMapUnitScale mapUnitScale() const override;
2280
2281 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
2282 bool hasDataDefinedProperties() const override;
2283
2289 int pointCount() const;
2290
2296 void setPointCount( int count );
2297
2303 unsigned long seed() const;
2304
2312 void setSeed( unsigned long seed );
2313
2319 bool clipPoints() const;
2320
2326 void setClipPoints( bool clipped );
2327
2333 Qgis::PointCountMethod countMethod() const;
2334
2340 void setCountMethod( Qgis::PointCountMethod method );
2341
2351 double densityArea() const;
2352
2358 void setDensityArea( double area );
2359
2365 void setDensityAreaUnit( QgsUnitTypes::RenderUnit unit ) { mDensityAreaUnit = unit; }
2366
2371 QgsUnitTypes::RenderUnit densityAreaUnit() const { return mDensityAreaUnit; }
2372
2380 void setDensityAreaUnitScale( const QgsMapUnitScale &scale ) { mDensityAreaUnitScale = scale; }
2381
2388 const QgsMapUnitScale &densityAreaUnitScale() const { return mDensityAreaUnitScale; }
2389
2390 void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
2391 void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
2392
2393 private:
2394#ifdef SIP_RUN
2396#endif
2397
2398 struct Part
2399 {
2400 QPolygonF exterior;
2401 QVector<QPolygonF> rings;
2402 };
2403
2404 QVector< Part > mCurrentParts;
2405
2406 void render( QgsRenderContext &context, const QVector< Part > &parts, const QgsFeature &feature, bool selected );
2407
2408 std::unique_ptr< QgsMarkerSymbol > mMarker;
2409 Qgis::PointCountMethod mCountMethod = Qgis::PointCountMethod::Absolute;
2410 int mPointCount = 10;
2411 double mDensityArea = 250.0;
2413 QgsMapUnitScale mDensityAreaUnitScale;
2414 unsigned long mSeed = 0;
2415 bool mClipPoints = false;
2416
2417 bool mRenderingFeature = false;
2418 double mFeatureSymbolOpacity = 1;
2419};
2420
2421
2427{
2428 public:
2431
2432 // static stuff
2433
2439 static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
2440 static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
2441
2442 // implemented from base classes
2443
2444 QString layerType() const override;
2445 void startRender( QgsSymbolRenderContext &context ) override;
2446 void stopRender( QgsSymbolRenderContext &context ) override;
2447 void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
2448 QVariantMap properties() const override;
2449 QgsCentroidFillSymbolLayer *clone() const override SIP_FACTORY;
2450 void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
2451 void setColor( const QColor &color ) override;
2452 QColor color() const override;
2453 QgsSymbol *subSymbol() override;
2454 bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
2455 void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
2456 QgsUnitTypes::RenderUnit outputUnit() const override;
2457 bool usesMapUnits() const override;
2458 void setMapUnitScale( const QgsMapUnitScale &scale ) override;
2459 QgsMapUnitScale mapUnitScale() const override;
2460 QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
2461 bool hasDataDefinedProperties() const override;
2462 bool canCauseArtifactsBetweenAdjacentTiles() const override;
2463
2464 void setPointOnSurface( bool pointOnSurface ) { mPointOnSurface = pointOnSurface; }
2465 bool pointOnSurface() const { return mPointOnSurface; }
2466
2472 void setPointOnAllParts( bool pointOnAllParts ) { mPointOnAllParts = pointOnAllParts; }
2473
2479 bool pointOnAllParts() const { return mPointOnAllParts; }
2480
2487 bool clipPoints() const { return mClipPoints; }
2488
2495 void setClipPoints( bool clipPoints ) { mClipPoints = clipPoints; }
2496
2503 bool clipOnCurrentPartOnly() const { return mClipOnCurrentPartOnly; }
2504
2511 void setClipOnCurrentPartOnly( bool clipOnCurrentPartOnly ) { mClipOnCurrentPartOnly = clipOnCurrentPartOnly; }
2512
2513 void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
2514 void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
2515
2516 protected:
2517
2518 std::unique_ptr< QgsMarkerSymbol > mMarker;
2519 bool mPointOnSurface = false;
2520 bool mPointOnAllParts = true;
2521 bool mClipPoints = false;
2522 bool mClipOnCurrentPartOnly = false;
2523
2524 bool mRenderingFeature = false;
2525 double mFeatureSymbolOpacity = 1;
2526
2527 private:
2528#ifdef SIP_RUN
2530#endif
2531 struct Part
2532 {
2533 QPolygonF exterior;
2534 QVector<QPolygonF> rings;
2535 };
2536
2537 void render( QgsRenderContext &context, const QVector<Part> &parts, const QgsFeature &feature, bool selected );
2538 QVector<Part> mCurrentParts;
2539};
2540
2541#endif
2542
2543
The Qgis class provides global constants for use throughout the application.
Definition: qgis.h:72
MarkerClipMode
Marker clipping modes.
Definition: qgis.h:1881
@ Shape
Clip to polygon shape.
LineClipMode
Line clipping modes.
Definition: qgis.h:1895
@ ClipPainterOnly
Applying clipping on the painter only (i.e. line endpoints will coincide with polygon bounding box,...
GradientColorSource
Gradient color sources.
Definition: qgis.h:1810
@ 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:1854
@ 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:1869
GradientType
Gradient types.
Definition: qgis.h:1824
@ Linear
Linear gradient.
SymbolCoordinateReference
Symbol coordinate reference modes.
Definition: qgis.h:1839
@ 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.
Definition: qgscolorramp.h:30
Exports QGIS layers to the DXF format.
Definition: qgsdxfexport.h:65
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,...
double angle() const
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::SymbolCoordinateReference coordinateMode() const
Returns the coordinate mode for gradient, which controls how the gradient stops are positioned.
void setOffsetUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the fill's offset.
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 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.
Qgis::GradientType mGradientType
QgsUnitTypes::RenderUnit offsetUnit() const
Returns the units for the fill's offset.
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 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 ...
QgsUnitTypes::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.
void setStrokeWidthUnit(QgsUnitTypes::RenderUnit unit)
Sets the units fo the symbol's stroke width.
const QgsMapUnitScale & strokeWidthMapUnitScale() const
Returns the stroke width map unit scale.
~QgsImageFillSymbolLayer() override
A symbol fill consisting of repeated parallel lines.
void setLineWidthUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the line's width.
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.
QgsUnitTypes::RenderUnit lineWidthUnit() const
Returns the units for the line's width.
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.
QgsUnitTypes::RenderUnit offsetUnit() const
Returns the units for the line pattern's offset.
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.
void setDistanceUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for 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.
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 setOffsetUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the line pattern's offset.
double distance() const
Returns the distance between lines in the fill pattern.
QgsUnitTypes::RenderUnit distanceUnit() const
Returns the units for 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...
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.
Definition: qgslinesymbol.h:30
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.
const QgsMapUnitScale & randomDeviationXMapUnitScale() const
Returns the unit scale for the horizontal random deviation of points in the pattern.
void setOffsetYUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the vertical offset for rows in the pattern.
void setRandomDeviationXUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit 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.
QgsUnitTypes::RenderUnit offsetYUnit() const
Returns the units for the vertical offset for rows in the pattern.
double displacementY() const
Returns the vertical displacement for odd numbered columns 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.
QgsUnitTypes::RenderUnit displacementYUnit() const
Returns the units for the vertical displacement between rows in the pattern.
void setRandomDeviationXMapUnitScale(const QgsMapUnitScale &scale)
Sets the unit scale for the horizontal random deviation of points in the pattern.
QgsUnitTypes::RenderUnit distanceYUnit() const
Returns the units for the vertical distance between points in the pattern.
QgsUnitTypes::RenderUnit randomDeviationYUnit() const
Returns the units for the vertical random deviation of 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.
QgsUnitTypes::RenderUnit randomDeviationXUnit() const
Returns the units for the horizontal random deviation of points 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.
QgsUnitTypes::RenderUnit offsetXUnit() const
Returns the units for the horizontal offset for rows 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 setDistanceXUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the horizontal distance between points in the pattern.
void setDistanceXMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the horizontal 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.
const QgsMapUnitScale & randomDeviationYMapUnitScale() const
Returns the unit scale for the vertical random deviation of points 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.
void setDisplacementYUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the vertical 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.
double maximumRandomDeviationX() const
Returns the maximum horizontal random deviation of points in the pattern.
std::unique_ptr< QgsMarkerSymbol > mMarkerSymbol
void setDisplacementXUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the horizontal displacement between rows in the pattern.
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.
void setRandomDeviationYUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the vertical random deviation of points in the pattern.
QgsUnitTypes::RenderUnit displacementXUnit() const
Returns the units for the horizontal 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.
double angle() const
Returns the rotation angle of the pattern, in degrees clockwise.
void setOffsetXUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the horizontal offset between rows in the pattern.
~QgsPointPatternFillSymbolLayer() override
QgsUnitTypes::RenderUnit distanceXUnit() const
Returns the units for the horizontal distance between points in the pattern.
void setDistanceYUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the vertical distance between points in the pattern.
void setAngle(double angle)
Sets the rotation angle of the pattern, in degrees clockwise.
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
QgsUnitTypes::RenderUnit densityAreaUnit() const
Returns the units for the density area.
void setDensityAreaUnitScale(const QgsMapUnitScale &scale)
Sets the map scale 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 setWidthUnit(const QgsUnitTypes::RenderUnit unit)
Sets the units for the image's width.
void setOffsetUnit(const QgsUnitTypes::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.
QgsUnitTypes::RenderUnit offsetUnit() const
Returns the units for the fill's offset.
QgsUnitTypes::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.
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.
void setPatternWidthUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the width of the SVG images in the pattern.
QColor svgStrokeColor() const
Returns the stroke color used for rendering the SVG content.
void setSvgFillColor(const QColor &c)
Sets the fill color used for rendering the SVG content.
QgsUnitTypes::RenderUnit svgStrokeWidthUnit() const
Returns the units for the stroke width.
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.
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.
void setSvgStrokeWidthUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the stroke width.
const QgsMapUnitScale & patternWidthMapUnitScale() const
Returns the map unit scale for the pattern's 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
QgsUnitTypes::RenderUnit patternWidthUnit() const
Returns the units for the width of the SVG images in the pattern.
void setPatternWidthMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the pattern's width.
~QgsShapeburstFillSymbolLayer() override
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 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 setDistanceUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the maximum distance to shade inside of the shape from the polygon's boundary.
QgsUnitTypes::RenderUnit distanceUnit() const
Returns the unit for the maximum distance to shade inside of the shape from the polygon's boundary.
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.
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
QgsUnitTypes::RenderUnit offsetUnit() const
Returns the units used for the offset of the shapeburst fill.
void setDistanceMapUnitScale(const QgsMapUnitScale &scale)
void setOffsetUnit(QgsUnitTypes::RenderUnit unit)
Sets the units used for the offset for the shapeburst fill.
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
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.
QgsUnitTypes::RenderUnit strokeWidthUnit() const
Returns 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.
void setStrokeStyle(Qt::PenStyle strokeStyle)
QgsMapUnitScale mStrokeWidthMapUnitScale
void setFillColor(const QColor &color) override
Sets the fill color for the symbol layer.
QgsUnitTypes::RenderUnit offsetUnit() const
Returns the units for the fill's offset.
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.
Qt::PenJoinStyle mPenJoinStyle
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the fill's offset.
void setOffsetUnit(QgsUnitTypes::RenderUnit unit)
Sets the unit for the fill's offset.
void setStrokeWidthUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the width of the fill's stroke.
virtual void setOutputUnit(QgsUnitTypes::RenderUnit unit)
Sets the units to use for sizes and widths within the symbol layer.
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 QgsUnitTypes::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 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:93
Helper functions for various unit types.
Definition: qgsunittypes.h:39
RenderUnit
Rendering size units.
Definition: qgsunittypes.h:168
@ RenderPixels
Pixels.
Definition: qgsunittypes.h:171
@ RenderMillimeters
Millimeters.
Definition: qgsunittypes.h:169
double ANALYSIS_EXPORT angle(QgsPoint *p1, QgsPoint *p2, QgsPoint *p3, QgsPoint *p4)
Calculates the angle between two segments (in 2 dimension, z-values are ignored)
Definition: MathUtils.cpp:786
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:3460
#define SIP_TRANSFER
Definition: qgis_sip.h:36
#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