QGIS API Documentation  3.27.0-Master (aef1b1ec20)
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 
35 class QgsMarkerSymbol;
36 class QgsLineSymbol;
37 class QgsPathResolver;
38 
43 class CORE_EXPORT QgsSimpleFillSymbolLayer : public QgsFillSymbolLayer
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;
187  QColor mStrokeColor;
188  Qt::PenStyle mStrokeStyle;
189  double mStrokeWidth;
192  Qt::PenJoinStyle mPenJoinStyle;
193  QPen mPen;
194  QPen mSelPen;
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 
205 class QgsColorRamp;
206 
212 {
213  public:
214 
219  const QColor &color2 = Qt::white,
224  );
225 
226  ~QgsGradientFillSymbolLayer() override;
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;
244  QgsGradientFillSymbolLayer *clone() const override SIP_FACTORY;
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:1523
@ Shape
Clip to polygon shape.
LineClipMode
Line clipping modes.
Definition: qgis.h:1537
@ ClipPainterOnly
Applying clipping on the painter only (i.e. line endpoints will coincide with polygon bounding box,...
GradientColorSource
Gradient color sources.
Definition: qgis.h:1452
@ 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:1496
@ 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:1511
GradientType
Gradient types.
Definition: qgis.h:1466
@ Linear
Linear gradient.
SymbolCoordinateReference
Symbol coordinate reference modes.
Definition: qgis.h:1481
@ 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
QgsColorRamp * colorRamp()
Returns the color ramp used for the gradient fill.
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...
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.
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
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the fill's offset.
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.
~QgsImageFillSymbolLayer() override
const QgsMapUnitScale & strokeWidthMapUnitScale() const
Returns the stroke width map unit scale.
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.
const QgsMapUnitScale & lineWidthMapUnitScale() const
Returns the map unit scale for the pattern's line width.
QgsUnitTypes::RenderUnit lineWidthUnit() const
Returns the units for the line's width.
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the pattern's line offset.
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.
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.
void setClipMode(Qgis::LineClipMode mode)
Sets the line clipping mode, which defines how lines are clipped at the edges of shapes.
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...
const QgsMapUnitScale & distanceMapUnitScale() const
Returns the map unit scale for the pattern's line distance.
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.
void setDisplacementX(double d)
Sets the horizontal displacement for odd numbered rows in the pattern.
const QgsMapUnitScale & displacementYMapUnitScale() const
Returns the map unit scale for the vertical displacement between odd numbered columns 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.
void setRandomDeviationYMapUnitScale(const QgsMapUnitScale &scale)
Sets the unit scale for the vertical random deviation of points in the pattern.
const QgsMapUnitScale & offsetYMapUnitScale() const
Returns the unit scale for the vertical offset between rows 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.
const QgsMapUnitScale & distanceYMapUnitScale() const
Returns the map unit scale for the vertical distance between 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.
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 & offsetXMapUnitScale() const
Returns the unit scale for the horizontal 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 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.
const QgsMapUnitScale & randomDeviationYMapUnitScale() const
Returns the unit scale for the vertical 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.
const QgsMapUnitScale & distanceXMapUnitScale() const
Returns the map unit scale for the horizontal distance between points 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.
const QgsMapUnitScale & displacementXMapUnitScale() const
Returns the map unit scale for the horizontal displacement between odd numbered rows in the pattern.
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.
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
const QgsMapUnitScale & widthMapUnitScale() const
Returns the map unit scale for the image's width.
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.
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale for the fill's offset.
QPointF offset() const
Returns the offset for the fill.
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.
QMap< QString, QgsProperty > parameters() const
Returns the dynamic SVG parameters.
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.
const QgsMapUnitScale & svgStrokeWidthMapUnitScale() const
Returns the map unit scale for the pattern's stroke.
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.
double svgStrokeWidth() const
Returns the stroke width used for rendering the SVG content.
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.
const QgsMapUnitScale & patternWidthMapUnitScale() const
Returns the map unit scale for the pattern's width.
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.
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
int blurRadius() const
Returns the blur radius, which controls the amount of blurring applied to the fill.
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
QgsColorRamp * colorRamp()
Returns the color ramp used for the shapeburst fill.
void setOffset(QPointF offset)
Sets the offset for the shapeburst fill.
const QgsMapUnitScale & distanceMapUnitScale() const
void setUseWholeShape(bool useWholeShape)
Sets whether the shapeburst fill should be drawn using the entire shape.
QgsShapeburstFillSymbolLayer & operator=(const QgsShapeburstFillSymbolLayer &other)=delete
QgsShapeburstFillSymbolLayer cannot be copied.
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.
const QgsMapUnitScale & offsetMapUnitScale() const
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.
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.
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 & offsetMapUnitScale() const
Returns the map unit scale for the fill's offset.
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
const QgsMapUnitScale & strokeWidthMapUnitScale() const
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
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 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 QgsSymbolLayer * clone() const =0
Shall be reimplemented by subclasses to create a deep copy of the instance.
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:2776
#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