qgsfillsymbollayer.h

Go to the documentation of this file.

/***************************************************************************
 qgsfillsymbollayer.h
 ---------------------
 begin                : November 2009
 copyright            : (C) 2009 by Martin Dobias
 email                : wonder dot sk at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSFILLSYMBOLLAYER_H
#define QGSFILLSYMBOLLAYER_H
 
#include "qgis_core.h"
#include "qgis.h"
#include "qgssymbollayer.h"
 
#define DEFAULT_SIMPLEFILL_COLOR        QColor(0,0,255)
#define DEFAULT_SIMPLEFILL_STYLE        Qt::SolidPattern
#define DEFAULT_SIMPLEFILL_BORDERCOLOR  QColor( 35, 35, 35 )
#define DEFAULT_SIMPLEFILL_BORDERSTYLE  Qt::SolidLine
#define DEFAULT_SIMPLEFILL_BORDERWIDTH  DEFAULT_LINE_WIDTH
#define DEFAULT_SIMPLEFILL_JOINSTYLE    Qt::BevelJoin
 
#define INF 1E20
 
#include <QPen>
#include <QBrush>
 
class QgsMarkerSymbol;
class QgsLineSymbol;
class QgsPathResolver;
 
class CORE_EXPORT QgsSimpleFillSymbolLayer : public QgsFillSymbolLayer
{
  public:
    QgsSimpleFillSymbolLayer( const QColor &color = DEFAULT_SIMPLEFILL_COLOR,
                              Qt::BrushStyle style = DEFAULT_SIMPLEFILL_STYLE,
                              const QColor &strokeColor = DEFAULT_SIMPLEFILL_BORDERCOLOR,
                              Qt::PenStyle strokeStyle = DEFAULT_SIMPLEFILL_BORDERSTYLE,
                              double strokeWidth = DEFAULT_SIMPLEFILL_BORDERWIDTH,
                              Qt::PenJoinStyle penJoinStyle = DEFAULT_SIMPLEFILL_JOINSTYLE
                            );
 
    ~QgsSimpleFillSymbolLayer() override;
 
    // static stuff
 
    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
    static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
 
    // implemented from base classes
 
    QString layerType() const override;
 
    void startRender( QgsSymbolRenderContext &context ) override;
 
    void stopRender( QgsSymbolRenderContext &context ) override;
 
    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
 
    QVariantMap properties() const override;
 
    QgsSimpleFillSymbolLayer *clone() const override SIP_FACTORY;
 
    void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
 
    QString ogrFeatureStyle( double mmScaleFactor, double mapUnitScaleFactor ) const override;
 
    Qt::BrushStyle brushStyle() const { return mBrushStyle; }
    void setBrushStyle( Qt::BrushStyle style ) { mBrushStyle = style; }
 
    QColor strokeColor() const override { return mStrokeColor; }
    void setStrokeColor( const QColor &strokeColor ) override { mStrokeColor = strokeColor; }
 
    QColor fillColor() const override { return color(); }
    void setFillColor( const QColor &color ) override { setColor( color ); }
 
    Qt::PenStyle strokeStyle() const { return mStrokeStyle; }
    void setStrokeStyle( Qt::PenStyle strokeStyle ) { mStrokeStyle = strokeStyle; }
 
    double strokeWidth() const { return mStrokeWidth; }
    void setStrokeWidth( double strokeWidth ) { mStrokeWidth = strokeWidth; }
 
    Qt::PenJoinStyle penJoinStyle() const { return mPenJoinStyle; }
    void setPenJoinStyle( Qt::PenJoinStyle style ) { mPenJoinStyle = style; }
 
    void setOffset( QPointF offset ) { mOffset = offset; }
 
    QPointF offset() { return mOffset; }
 
    void setStrokeWidthUnit( QgsUnitTypes::RenderUnit unit ) { mStrokeWidthUnit = unit; }
 
    QgsUnitTypes::RenderUnit strokeWidthUnit() const { return mStrokeWidthUnit; }
 
    void setStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mStrokeWidthMapUnitScale = scale; }
    const QgsMapUnitScale &strokeWidthMapUnitScale() const { return mStrokeWidthMapUnitScale; }
 
    void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
 
    QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
 
    void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
 
    const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
 
    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
    QgsUnitTypes::RenderUnit outputUnit() const override;
    bool usesMapUnits() const override;
 
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
 
    double estimateMaxBleed( const QgsRenderContext &context ) const override;
 
    double dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const override;
    QColor dxfColor( QgsSymbolRenderContext &context ) const override;
    double dxfAngle( QgsSymbolRenderContext &context ) const override;
 
    Qt::PenStyle dxfPenStyle() const override;
    QColor dxfBrushColor( QgsSymbolRenderContext &context ) const override;
    Qt::BrushStyle dxfBrushStyle() const override;
 
  protected:
    QBrush mBrush;
    QBrush mSelBrush;
    Qt::BrushStyle mBrushStyle;
    QColor mStrokeColor;
    Qt::PenStyle mStrokeStyle;
    double mStrokeWidth;
    QgsUnitTypes::RenderUnit mStrokeWidthUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mStrokeWidthMapUnitScale;
    Qt::PenJoinStyle mPenJoinStyle;
    QPen mPen;
    QPen mSelPen;
 
    QPointF mOffset;
    QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mOffsetMapUnitScale;
 
  private:
    //helper functions for data defined symbology
    void applyDataDefinedSymbology( QgsSymbolRenderContext &context, QBrush &brush, QPen &pen, QPen &selPen );
};
 
class QgsColorRamp;
 
class CORE_EXPORT QgsGradientFillSymbolLayer : public QgsFillSymbolLayer
{
  public:
 
    QgsGradientFillSymbolLayer( const QColor &color = DEFAULT_SIMPLEFILL_COLOR,
                                const QColor &color2 = Qt::white,
                                Qgis::GradientColorSource gradientColorType = Qgis::GradientColorSource::SimpleTwoColor,
                                Qgis::GradientType gradientType = Qgis::GradientType::Linear,
                                Qgis::SymbolCoordinateReference coordinateMode = Qgis::SymbolCoordinateReference::Feature,
                                Qgis::GradientSpread gradientSpread = Qgis::GradientSpread::Pad
                              );
 
    ~QgsGradientFillSymbolLayer() override;
 
    // static stuff
 
    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
 
    // implemented from base classes
 
    QString layerType() const override;
    void startRender( QgsSymbolRenderContext &context ) override;
    void stopRender( QgsSymbolRenderContext &context ) override;
    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
    QVariantMap properties() const override;
    QgsGradientFillSymbolLayer *clone() const override SIP_FACTORY;
    double estimateMaxBleed( const QgsRenderContext &context ) const override;
    bool canCauseArtifactsBetweenAdjacentTiles() const override;
 
    Qgis::GradientType gradientType() const { return mGradientType; }
 
    void setGradientType( Qgis::GradientType gradientType ) { mGradientType = gradientType; }
 
    Qgis::GradientColorSource gradientColorType() const { return mGradientColorType; }
 
    void setGradientColorType( Qgis::GradientColorSource gradientColorType ) { mGradientColorType = gradientColorType; }
 
    QgsColorRamp *colorRamp() { return mGradientRamp; }
 
    void setColorRamp( QgsColorRamp *ramp SIP_TRANSFER );
 
    QColor color2() const { return mColor2; }
 
    void setColor2( const QColor &color2 ) { mColor2 = color2; }
 
    Qgis::SymbolCoordinateReference coordinateMode() const { return mCoordinateMode; }
 
    void setCoordinateMode( Qgis::SymbolCoordinateReference coordinateMode ) { mCoordinateMode = coordinateMode; }
 
    Qgis::GradientSpread gradientSpread() const { return mGradientSpread; }
 
    void setGradientSpread( Qgis::GradientSpread gradientSpread ) { mGradientSpread = gradientSpread; }
 
    void setReferencePoint1( QPointF referencePoint ) { mReferencePoint1 = referencePoint; }
 
    QPointF referencePoint1() const { return mReferencePoint1; }
 
    void setReferencePoint1IsCentroid( bool isCentroid ) { mReferencePoint1IsCentroid = isCentroid; }
 
    bool referencePoint1IsCentroid() const { return mReferencePoint1IsCentroid; }
 
    void setReferencePoint2( QPointF referencePoint ) { mReferencePoint2 = referencePoint; }
 
    QPointF referencePoint2() const { return mReferencePoint2; }
 
    void setReferencePoint2IsCentroid( bool isCentroid ) { mReferencePoint2IsCentroid = isCentroid; }
 
 
    bool referencePoint2IsCentroid() const { return mReferencePoint2IsCentroid; }
 
    void setOffset( QPointF offset ) { mOffset = offset; }
 
    QPointF offset() const { return mOffset; }
 
    void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
 
    QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
 
    void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
 
    const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
 
    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
    QgsUnitTypes::RenderUnit outputUnit() const override;
    bool usesMapUnits() const override;
 
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
 
  protected:
    QBrush mBrush;
    QBrush mSelBrush;
 
    Qgis::GradientColorSource mGradientColorType;
    QColor mColor2;
    QgsColorRamp *mGradientRamp = nullptr;
    Qgis::GradientType mGradientType;
    Qgis::SymbolCoordinateReference mCoordinateMode;
    Qgis::GradientSpread mGradientSpread;
 
    QPointF mReferencePoint1;
    bool mReferencePoint1IsCentroid = false;
    QPointF mReferencePoint2;
    bool mReferencePoint2IsCentroid = false;
 
    QPointF mOffset;
    QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mOffsetMapUnitScale;
 
  private:
 
    //helper functions for data defined symbology
    void applyDataDefinedSymbology( QgsSymbolRenderContext &context, const QPolygonF &points );
 
    void applyGradient( const QgsSymbolRenderContext &context, QBrush &brush, const QColor &color, const QColor &color2,
                        Qgis::GradientColorSource gradientColorType, QgsColorRamp *gradientRamp, Qgis::GradientType gradientType,
                        Qgis::SymbolCoordinateReference coordinateMode, Qgis::GradientSpread gradientSpread,
                        QPointF referencePoint1, QPointF referencePoint2, double angle );
 
    QPointF rotateReferencePoint( QPointF refPoint, double angle );
};
 
class CORE_EXPORT QgsShapeburstFillSymbolLayer : public QgsFillSymbolLayer
{
  public:
 
    QgsShapeburstFillSymbolLayer( const QColor &color = DEFAULT_SIMPLEFILL_COLOR, const QColor &color2 = Qt::white,
                                  Qgis::GradientColorSource colorType = Qgis::GradientColorSource::SimpleTwoColor,
                                  int blurRadius = 0, bool useWholeShape = true, double maxDistance = 5 );
 
    ~QgsShapeburstFillSymbolLayer() override;
 
    QgsShapeburstFillSymbolLayer( const QgsShapeburstFillSymbolLayer &other ) = delete;
 
    QgsShapeburstFillSymbolLayer &operator=( const QgsShapeburstFillSymbolLayer &other ) = delete;
 
    // static stuff
 
    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
 
    // implemented from base classes
 
    QString layerType() const override;
    void startRender( QgsSymbolRenderContext &context ) override;
    void stopRender( QgsSymbolRenderContext &context ) override;
    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
    QVariantMap properties() const override;
    QgsShapeburstFillSymbolLayer *clone() const override SIP_FACTORY;
    double estimateMaxBleed( const QgsRenderContext &context ) const override;
    bool canCauseArtifactsBetweenAdjacentTiles() const override;
 
    void setBlurRadius( int blurRadius ) { mBlurRadius = blurRadius; }
 
    int blurRadius() const { return mBlurRadius; }
 
    void setUseWholeShape( bool useWholeShape ) { mUseWholeShape = useWholeShape; }
 
    bool useWholeShape() const { return mUseWholeShape; }
 
    void setMaxDistance( double maxDistance ) { mMaxDistance = maxDistance; }
 
    double maxDistance() const { return mMaxDistance; }
 
    void setDistanceUnit( QgsUnitTypes::RenderUnit unit ) { mDistanceUnit = unit; }
 
    QgsUnitTypes::RenderUnit distanceUnit() const { return mDistanceUnit; }
 
    void setDistanceMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceMapUnitScale = scale; }
    const QgsMapUnitScale &distanceMapUnitScale() const { return mDistanceMapUnitScale; }
 
    void setColorType( Qgis::GradientColorSource colorType ) { mColorType = colorType; }
 
    Qgis::GradientColorSource colorType() const { return mColorType; }
 
    void setColorRamp( QgsColorRamp *ramp SIP_TRANSFER );
 
    QgsColorRamp *colorRamp() { return mGradientRamp.get(); }
 
    void setColor2( const QColor &color2 ) { mColor2 = color2; }
 
    QColor color2() const { return mColor2; }
 
    void setIgnoreRings( bool ignoreRings ) { mIgnoreRings = ignoreRings; }
 
    bool ignoreRings() const { return mIgnoreRings; }
 
    void setOffset( QPointF offset ) { mOffset = offset; }
 
    QPointF offset() const { return mOffset; }
 
    void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
 
    QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
 
    void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
    const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
 
    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
    QgsUnitTypes::RenderUnit outputUnit() const override;
    bool usesMapUnits() const override;
 
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
 
  private:
    QBrush mBrush;
    QBrush mSelBrush;
 
    int mBlurRadius = 0;
 
    bool mUseWholeShape = true;
    double mMaxDistance = 5.0;
    QgsUnitTypes::RenderUnit mDistanceUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mDistanceMapUnitScale;
 
    Qgis::GradientColorSource mColorType = Qgis::GradientColorSource::SimpleTwoColor;
    QColor mColor2;
 
    bool mIgnoreRings = false;
 
    QPointF mOffset;
    QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mOffsetMapUnitScale;
 
    std::unique_ptr< QgsColorRamp > mGradientRamp;
 
    //helper functions for data defined symbology
    void applyDataDefinedSymbology( QgsSymbolRenderContext &context, QColor &color, QColor &color2, int &blurRadius, bool &useWholeShape,
                                    double &maxDistance, bool &ignoreRings );
 
    /* distance transform of a 1d function using squared distance */
    void distanceTransform1d( double *f, int n, int *v, double *z, double *d );
    /* distance transform of 2d function using squared distance */
    void distanceTransform2d( double *im, int width, int height, QgsRenderContext &context );
    /* distance transform of a binary QImage */
    double *distanceTransform( QImage *im, QgsRenderContext &context );
 
    /* fills a QImage with values from an array of doubles containing squared distance transform values */
    void dtArrayToQImage( double *array, QImage *im, QgsColorRamp *ramp, QgsRenderContext &context, bool useWholeShape = true, int maxPixelDistance = 0 );
 
#ifdef SIP_RUN
    QgsShapeburstFillSymbolLayer( const QgsShapeburstFillSymbolLayer &other );
#endif
};
 
class CORE_EXPORT QgsImageFillSymbolLayer: public QgsFillSymbolLayer
{
  public:
 
    QgsImageFillSymbolLayer();
    ~QgsImageFillSymbolLayer() override;
 
    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
 
    void setStrokeWidthUnit( QgsUnitTypes::RenderUnit unit ) { mStrokeWidthUnit = unit; }
 
    QgsUnitTypes::RenderUnit strokeWidthUnit() const { return mStrokeWidthUnit; }
 
    void setStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mStrokeWidthMapUnitScale = scale; }
 
    const QgsMapUnitScale &strokeWidthMapUnitScale() const { return mStrokeWidthMapUnitScale; }
 
    void setCoordinateReference( Qgis::SymbolCoordinateReference coordinateReference ) { mCoordinateReference = coordinateReference; }
 
    Qgis::SymbolCoordinateReference coordinateReference() const { return mCoordinateReference; }
 
    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
    QgsUnitTypes::RenderUnit outputUnit() const override;
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
    double dxfWidth( const QgsDxfExport &e, QgsSymbolRenderContext &context ) const override;
    Qt::PenStyle dxfPenStyle() const override;
    QVariantMap properties() const override;
 
  protected:
    QBrush mBrush;
    Qgis::SymbolCoordinateReference mCoordinateReference = Qgis::SymbolCoordinateReference::Feature;
    double mNextAngle = 0.0; // mAngle / data defined angle
 
    double mStrokeWidth = 0.0;
    QgsUnitTypes::RenderUnit mStrokeWidthUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mStrokeWidthMapUnitScale;
 
    virtual void applyDataDefinedSettings( QgsSymbolRenderContext &context ) { Q_UNUSED( context ) }
 
    virtual bool applyBrushTransformFromContext( QgsSymbolRenderContext *context = nullptr ) const;
 
  private:
#ifdef SIP_RUN
    QgsImageFillSymbolLayer( const QgsImageFillSymbolLayer &other );
#endif
};
 
class CORE_EXPORT QgsRasterFillSymbolLayer: public QgsImageFillSymbolLayer
{
  public:
 
    QgsRasterFillSymbolLayer( const QString &imageFilePath = QString() );
 
    ~QgsRasterFillSymbolLayer() override;
 
    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
 
    static void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving );
 
    // implemented from base classes
    QString layerType() const override;
    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
    void startRender( QgsSymbolRenderContext &context ) override;
    void stopRender( QgsSymbolRenderContext &context ) override;
    QVariantMap properties() const override;
    QgsRasterFillSymbolLayer *clone() const override SIP_FACTORY;
    double estimateMaxBleed( const QgsRenderContext &context ) const override;
    bool usesMapUnits() const override;
    QColor color() const override;
 
    //override QgsImageFillSymbolLayer's support for sub symbols
    QgsSymbol *subSymbol() override { return nullptr; }
    bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
 
    void setImageFilePath( const QString &imagePath );
 
    QString imageFilePath() const { return mImageFilePath; }
 
    void setCoordinateMode( Qgis::SymbolCoordinateReference mode );
 
    Qgis::SymbolCoordinateReference coordinateMode() const { return mCoordinateMode; }
 
    void setOpacity( double opacity );
 
    double opacity() const { return mOpacity; }
 
    void setOffset( QPointF offset ) { mOffset = offset; }
 
    QPointF offset() const { return mOffset; }
 
    void setOffsetUnit( const QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
 
    QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
 
    void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
 
    const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
 
    void setWidth( const double width ) { mWidth = width; }
 
    double width() const { return mWidth; }
 
    void setWidthUnit( const QgsUnitTypes::RenderUnit unit ) { mWidthUnit = unit; }
 
    QgsUnitTypes::RenderUnit widthUnit() const { return mWidthUnit; }
 
    void setWidthMapUnitScale( const QgsMapUnitScale &scale ) { mWidthMapUnitScale = scale; }
 
    const QgsMapUnitScale &widthMapUnitScale() const { return mWidthMapUnitScale; }
 
  protected:
 
    void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
    bool applyBrushTransformFromContext( QgsSymbolRenderContext *context = nullptr ) const override;
  private:
 
    QString mImageFilePath;
    Qgis::SymbolCoordinateReference mCoordinateMode = Qgis::SymbolCoordinateReference::Feature;
    double mOpacity = 1.0;
 
    QPointF mOffset;
    QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mOffsetMapUnitScale;
 
    double mWidth = 0.0;
    QgsUnitTypes::RenderUnit mWidthUnit = QgsUnitTypes::RenderPixels;
    QgsMapUnitScale mWidthMapUnitScale;
 
    void applyPattern( QBrush &brush, const QString &imageFilePath, double width, double opacity,
                       const QgsSymbolRenderContext &context );
};
 
class CORE_EXPORT QgsSVGFillSymbolLayer: public QgsImageFillSymbolLayer
{
  public:
 
    QgsSVGFillSymbolLayer( const QString &svgFilePath, double width = 20, double rotation = 0.0 );
 
    QgsSVGFillSymbolLayer( const QByteArray &svgData, double width = 20, double rotation = 0.0 );
 
    ~QgsSVGFillSymbolLayer() override;
 
    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
 
    static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
 
    static void resolvePaths( QVariantMap &properties, const QgsPathResolver &pathResolver, bool saving );
 
    // implemented from base classes
 
    QString layerType() const override;
    void startRender( QgsSymbolRenderContext &context ) override;
    void stopRender( QgsSymbolRenderContext &context ) override;
    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
    QVariantMap properties() const override;
    QgsSVGFillSymbolLayer *clone() const override SIP_FACTORY;
    void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
    bool usesMapUnits() const override;
    QgsSymbol *subSymbol() override;
    bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
    double estimateMaxBleed( const QgsRenderContext &context ) const override;
    QColor dxfColor( QgsSymbolRenderContext &context ) const override;
    QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
    bool hasDataDefinedProperties() const override;
 
    void setSvgFilePath( const QString &svgPath );
 
    QString svgFilePath() const { return mSvgFilePath; }
 
    void setPatternWidth( double width ) { mPatternWidth = width;}
 
    double patternWidth() const { return mPatternWidth; }
 
    void setSvgFillColor( const QColor &c ) { setColor( c );  }
 
    QColor svgFillColor() const { return color(); }
 
    void setSvgStrokeColor( const QColor &c ) { mSvgStrokeColor = c; }
 
    QColor svgStrokeColor() const { return mSvgStrokeColor; }
 
    void setSvgStrokeWidth( double w ) { mSvgStrokeWidth = w; }
 
    double svgStrokeWidth() const { return mSvgStrokeWidth; }
 
    void setPatternWidthUnit( QgsUnitTypes::RenderUnit unit ) { mPatternWidthUnit = unit; }
 
    QgsUnitTypes::RenderUnit patternWidthUnit() const { return mPatternWidthUnit; }
 
    void setPatternWidthMapUnitScale( const QgsMapUnitScale &scale ) { mPatternWidthMapUnitScale = scale; }
 
    const QgsMapUnitScale &patternWidthMapUnitScale() const { return mPatternWidthMapUnitScale; }
 
    void setSvgStrokeWidthUnit( QgsUnitTypes::RenderUnit unit ) { mSvgStrokeWidthUnit = unit; }
 
    QgsUnitTypes::RenderUnit svgStrokeWidthUnit() const { return mSvgStrokeWidthUnit; }
 
    void setSvgStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mSvgStrokeWidthMapUnitScale = scale; }
 
    const QgsMapUnitScale &svgStrokeWidthMapUnitScale() const { return mSvgStrokeWidthMapUnitScale; }
 
    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
    QgsUnitTypes::RenderUnit outputUnit() const override;
 
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
 
    QMap<QString, QgsProperty> parameters() const { return mParameters; }
 
    void setParameters( const QMap<QString, QgsProperty> &parameters );
 
  protected:
 
    void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
 
  private:
 
    double mPatternWidth = 20;
    QgsUnitTypes::RenderUnit mPatternWidthUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mPatternWidthMapUnitScale;
    QMap<QString, QgsProperty> mParameters;
 
    QByteArray mSvgData;
    QString mSvgFilePath;
    QRectF mSvgViewBox;
 
    //param(fill), param(stroke), param(stroke-width) are going
    //to be replaced in memory
    QColor mSvgStrokeColor = QColor( 35, 35, 35 );
    double mSvgStrokeWidth = 0.2;
    QgsUnitTypes::RenderUnit mSvgStrokeWidthUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mSvgStrokeWidthMapUnitScale;
 
    std::unique_ptr< QgsLineSymbol > mStroke;
 
    void storeViewBox();
    void setDefaultSvgParams(); //fills mSvgFillColor, mSvgStrokeColor, mSvgStrokeWidth with default values for mSvgFilePath
 
    void applyPattern( QBrush &brush, const QString &svgFilePath, double patternWidth, QgsUnitTypes::RenderUnit patternWidthUnit, const QColor &svgFillColor, const QColor &svgStrokeColor,
                       double svgStrokeWidth, QgsUnitTypes::RenderUnit svgStrokeWidthUnit, const QgsSymbolRenderContext &context, const QgsMapUnitScale &patternWidthMapUnitScale, const QgsMapUnitScale &svgStrokeWidthMapUnitScale,
                       const QgsStringMap svgParameters );
};
 
class CORE_EXPORT QgsLinePatternFillSymbolLayer: public QgsImageFillSymbolLayer
{
  public:
    QgsLinePatternFillSymbolLayer();
    ~QgsLinePatternFillSymbolLayer() override;
 
    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
 
    static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
 
    QString layerType() const override;
    void startRender( QgsSymbolRenderContext &context ) override;
    void stopRender( QgsSymbolRenderContext &context ) override;
    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
    QVariantMap properties() const override;
    QgsLinePatternFillSymbolLayer *clone() const override SIP_FACTORY;
    void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
    double estimateMaxBleed( const QgsRenderContext &context ) const override;
 
    QString ogrFeatureStyleWidth( double widthScaleFactor ) const;
 
    void setLineAngle( double a ) { mLineAngle = a; }
 
    double lineAngle() const { return mLineAngle; }
 
    void setDistance( double d ) { mDistance = d; }
 
    double distance() const { return mDistance; }
 
    void setLineWidth( double w );
 
    double lineWidth() const { return mLineWidth; }
 
    void setColor( const QColor &c ) override;
    QColor color() const override;
 
    void setOffset( double offset ) { mOffset = offset; }
 
    double offset() const { return mOffset; }
 
    void setDistanceUnit( QgsUnitTypes::RenderUnit unit ) { mDistanceUnit = unit; }
 
    QgsUnitTypes::RenderUnit distanceUnit() const { return mDistanceUnit; }
 
    void setDistanceMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceMapUnitScale = scale; }
 
    const QgsMapUnitScale &distanceMapUnitScale() const { return mDistanceMapUnitScale; }
 
    void setLineWidthUnit( QgsUnitTypes::RenderUnit unit ) { mLineWidthUnit = unit; }
 
    QgsUnitTypes::RenderUnit lineWidthUnit() const { return mLineWidthUnit; }
 
    void setLineWidthMapUnitScale( const QgsMapUnitScale &scale ) { mLineWidthMapUnitScale = scale; }
 
    const QgsMapUnitScale &lineWidthMapUnitScale() const { return mLineWidthMapUnitScale; }
 
    void setOffsetUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetUnit = unit; }
 
    QgsUnitTypes::RenderUnit offsetUnit() const { return mOffsetUnit; }
 
    void setOffsetMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetMapUnitScale = scale; }
 
    const QgsMapUnitScale &offsetMapUnitScale() const { return mOffsetMapUnitScale; }
 
    Qgis::LineClipMode clipMode() const { return mClipMode; }
 
    void setClipMode( Qgis::LineClipMode mode ) { mClipMode = mode; }
 
    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
    QgsUnitTypes::RenderUnit outputUnit() const override;
    bool usesMapUnits() const override;
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
    bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
    QgsSymbol *subSymbol() override;
    QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
    bool hasDataDefinedProperties() const override;
    void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
    void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
 
  protected:
 
    void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
 
  private:
    double mDistance = 5.0;
    QgsUnitTypes::RenderUnit mDistanceUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mDistanceMapUnitScale;
    double mLineWidth = 0;
    QgsUnitTypes::RenderUnit mLineWidthUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mLineWidthMapUnitScale;
    double mLineAngle = 45.0;
    double mOffset = 0.0;
    QgsUnitTypes::RenderUnit mOffsetUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mOffsetMapUnitScale;
 
    bool mRenderUsingLines = false;
 
#ifdef SIP_RUN
    QgsLinePatternFillSymbolLayer( const QgsLinePatternFillSymbolLayer &other );
#endif
 
    void applyPattern( const QgsSymbolRenderContext &context, QBrush &brush, double lineAngle, double distance );
 
    std::unique_ptr< QgsLineSymbol > mFillLineSymbol;
 
    Qgis::LineClipMode mClipMode = Qgis::LineClipMode::ClipPainterOnly;
};
 
class CORE_EXPORT QgsPointPatternFillSymbolLayer: public QgsImageFillSymbolLayer
{
  public:
    QgsPointPatternFillSymbolLayer();
    ~QgsPointPatternFillSymbolLayer() override;
 
    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
    static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
 
    QString layerType() const override;
    void startRender( QgsSymbolRenderContext &context ) override;
    void stopRender( QgsSymbolRenderContext &context ) override;
    void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
    void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
    QVariantMap properties() const override;
    QgsPointPatternFillSymbolLayer *clone() const override SIP_FACTORY;
    void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
    double estimateMaxBleed( const QgsRenderContext &context ) const override;
    bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
    QgsSymbol *subSymbol() override;
    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
    QgsUnitTypes::RenderUnit outputUnit() const override;
    bool usesMapUnits() const override;
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
    QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
    bool hasDataDefinedProperties() const override;
    void setColor( const QColor &c ) override;
    QColor color() const override;
 
    double distanceX() const { return mDistanceX; }
 
    void setDistanceX( double d ) { mDistanceX = d; }
 
    void setDistanceXUnit( QgsUnitTypes::RenderUnit unit ) { mDistanceXUnit = unit; }
 
    QgsUnitTypes::RenderUnit distanceXUnit() const { return mDistanceXUnit; }
 
    void setDistanceXMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceXMapUnitScale = scale; }
 
    const QgsMapUnitScale &distanceXMapUnitScale() const { return mDistanceXMapUnitScale; }
 
    double distanceY() const { return mDistanceY; }
 
    void setDistanceY( double d ) { mDistanceY = d; }
 
    void setDistanceYUnit( QgsUnitTypes::RenderUnit unit ) { mDistanceYUnit = unit; }
 
    QgsUnitTypes::RenderUnit distanceYUnit() const { return mDistanceYUnit; }
 
    void setDistanceYMapUnitScale( const QgsMapUnitScale &scale ) { mDistanceYMapUnitScale = scale; }
 
    const QgsMapUnitScale &distanceYMapUnitScale() const { return mDistanceYMapUnitScale; }
 
    double displacementX() const { return mDisplacementX; }
 
    void setDisplacementX( double d ) { mDisplacementX = d; }
 
    void setDisplacementXUnit( QgsUnitTypes::RenderUnit unit ) { mDisplacementXUnit = unit; }
 
    QgsUnitTypes::RenderUnit displacementXUnit() const { return mDisplacementXUnit; }
 
    void setDisplacementXMapUnitScale( const QgsMapUnitScale &scale ) { mDisplacementXMapUnitScale = scale; }
 
    const QgsMapUnitScale &displacementXMapUnitScale() const { return mDisplacementXMapUnitScale; }
 
    double displacementY() const { return mDisplacementY; }
 
    void setDisplacementY( double d ) { mDisplacementY = d; }
 
    void setDisplacementYUnit( QgsUnitTypes::RenderUnit unit ) { mDisplacementYUnit = unit; }
 
    QgsUnitTypes::RenderUnit displacementYUnit() const { return mDisplacementYUnit; }
 
    void setDisplacementYMapUnitScale( const QgsMapUnitScale &scale ) { mDisplacementYMapUnitScale = scale; }
 
    const QgsMapUnitScale &displacementYMapUnitScale() const { return mDisplacementYMapUnitScale; }
 
    void setOffsetX( double offset ) { mOffsetX = offset; }
 
    double offsetX() const { return mOffsetX; }
 
    void setOffsetY( double offset ) { mOffsetY = offset; }
 
    double offsetY() const { return mOffsetY; }
 
    void setOffsetXUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetXUnit = unit; }
 
    QgsUnitTypes::RenderUnit offsetXUnit() const { return mOffsetXUnit; }
 
    void setOffsetXMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetXMapUnitScale = scale; }
 
    const QgsMapUnitScale &offsetXMapUnitScale() const { return mOffsetXMapUnitScale; }
 
    void setOffsetYUnit( QgsUnitTypes::RenderUnit unit ) { mOffsetYUnit = unit; }
 
    QgsUnitTypes::RenderUnit offsetYUnit() const { return mOffsetYUnit; }
 
    void setOffsetYMapUnitScale( const QgsMapUnitScale &scale ) { mOffsetYMapUnitScale = scale; }
 
    const QgsMapUnitScale &offsetYMapUnitScale() const { return mOffsetYMapUnitScale; }
 
    Qgis::MarkerClipMode clipMode() const { return mClipMode; }
 
    void setClipMode( Qgis::MarkerClipMode mode ) { mClipMode = mode; }
 
    void setMaximumRandomDeviationX( double deviation ) { mRandomDeviationX = deviation; }
 
    double maximumRandomDeviationX() const { return mRandomDeviationX; }
 
    void setMaximumRandomDeviationY( double deviation ) { mRandomDeviationY = deviation; }
 
    double maximumRandomDeviationY() const { return mRandomDeviationY; }
 
    void setRandomDeviationXUnit( QgsUnitTypes::RenderUnit unit ) { mRandomDeviationXUnit = unit; }
 
    QgsUnitTypes::RenderUnit randomDeviationXUnit() const { return mRandomDeviationXUnit; }
 
    void setRandomDeviationYUnit( QgsUnitTypes::RenderUnit unit ) { mRandomDeviationYUnit = unit; }
 
    QgsUnitTypes::RenderUnit randomDeviationYUnit() const { return mRandomDeviationYUnit; }
 
    const QgsMapUnitScale &randomDeviationXMapUnitScale() const { return mRandomDeviationXMapUnitScale; }
 
    const QgsMapUnitScale &randomDeviationYMapUnitScale() const { return mRandomDeviationYMapUnitScale; }
 
    void setRandomDeviationXMapUnitScale( const QgsMapUnitScale &scale ) { mRandomDeviationXMapUnitScale = scale; }
 
    void setRandomDeviationYMapUnitScale( const QgsMapUnitScale &scale ) { mRandomDeviationYMapUnitScale = scale; }
 
    unsigned long seed() const { return mSeed; }
 
    void setSeed( unsigned long seed ) { mSeed = seed; }
 
    double angle() const { return mAngle; }
 
    void setAngle( double angle ) { mAngle = angle; }
 
  protected:
    std::unique_ptr< QgsMarkerSymbol > mMarkerSymbol;
    double mDistanceX = 15;
    QgsUnitTypes::RenderUnit mDistanceXUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mDistanceXMapUnitScale;
    double mDistanceY = 15;
    QgsUnitTypes::RenderUnit mDistanceYUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mDistanceYMapUnitScale;
    double mDisplacementX = 0;
    QgsUnitTypes::RenderUnit mDisplacementXUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mDisplacementXMapUnitScale;
    double mDisplacementY = 0;
    QgsUnitTypes::RenderUnit mDisplacementYUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mDisplacementYMapUnitScale;
    double mOffsetX = 0;
    QgsUnitTypes::RenderUnit mOffsetXUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mOffsetXMapUnitScale;
    double mOffsetY = 0;
    QgsUnitTypes::RenderUnit mOffsetYUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mOffsetYMapUnitScale;
 
    double mRandomDeviationX = 0;
    QgsUnitTypes::RenderUnit mRandomDeviationXUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mRandomDeviationXMapUnitScale;
    double mRandomDeviationY = 0;
    QgsUnitTypes::RenderUnit mRandomDeviationYUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mRandomDeviationYMapUnitScale;
    unsigned long mSeed = 0;
 
    double mAngle = 0;
 
    void applyDataDefinedSettings( QgsSymbolRenderContext &context ) override;
 
  private:
#ifdef SIP_RUN
    QgsPointPatternFillSymbolLayer( const QgsPointPatternFillSymbolLayer &other );
#endif
 
    void applyPattern( const QgsSymbolRenderContext &context, QBrush &brush, double distanceX, double distanceY,
                       double displacementX, double displacementY, double offsetX, double offsetY );
 
    Qgis::MarkerClipMode mClipMode = Qgis::MarkerClipMode::Shape;
 
    bool mRenderUsingMarkers = false;
};
 
class CORE_EXPORT QgsRandomMarkerFillSymbolLayer : public QgsFillSymbolLayer
{
  public:
 
    QgsRandomMarkerFillSymbolLayer( int pointCount = 10, Qgis::PointCountMethod method = Qgis::PointCountMethod::Absolute, double densityArea = 250.0, unsigned long seed = 0 );
 
    ~QgsRandomMarkerFillSymbolLayer() override;
 
    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
 
    QString layerType() const override;
    void startRender( QgsSymbolRenderContext &context ) override;
    void stopRender( QgsSymbolRenderContext &context ) override;
    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
    QVariantMap properties() const override;
    QgsRandomMarkerFillSymbolLayer *clone() const override SIP_FACTORY;
    bool canCauseArtifactsBetweenAdjacentTiles() const override;
 
    void setColor( const QColor &color ) override;
    QColor color() const override;
 
    QgsSymbol *subSymbol() override;
    bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
 
    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
    QgsUnitTypes::RenderUnit outputUnit() const override;
    bool usesMapUnits() const override;
 
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
 
    QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
    bool hasDataDefinedProperties() const override;
 
    int pointCount() const;
 
    void setPointCount( int count );
 
    unsigned long seed() const;
 
    void setSeed( unsigned long seed );
 
    bool clipPoints() const;
 
    void setClipPoints( bool clipped );
 
    Qgis::PointCountMethod countMethod() const;
 
    void setCountMethod( Qgis::PointCountMethod method );
 
    double densityArea() const;
 
    void setDensityArea( double area );
 
    void setDensityAreaUnit( QgsUnitTypes::RenderUnit unit ) { mDensityAreaUnit = unit; }
 
    QgsUnitTypes::RenderUnit densityAreaUnit() const { return mDensityAreaUnit; }
 
    void setDensityAreaUnitScale( const QgsMapUnitScale &scale ) { mDensityAreaUnitScale = scale; }
 
    const QgsMapUnitScale &densityAreaUnitScale() const { return mDensityAreaUnitScale; }
 
    void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
    void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
 
  private:
#ifdef SIP_RUN
    QgsRandomMarkerFillSymbolLayer( const QgsRandomMarkerFillSymbolLayer &other );
#endif
 
    struct Part
    {
      QPolygonF exterior;
      QVector<QPolygonF> rings;
    };
 
    QVector< Part > mCurrentParts;
 
    void render( QgsRenderContext &context, const QVector< Part > &parts, const QgsFeature &feature, bool selected );
 
    std::unique_ptr< QgsMarkerSymbol > mMarker;
    Qgis::PointCountMethod mCountMethod = Qgis::PointCountMethod::Absolute;
    int mPointCount = 10;
    double mDensityArea = 250.0;
    QgsUnitTypes::RenderUnit mDensityAreaUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mDensityAreaUnitScale;
    unsigned long mSeed = 0;
    bool mClipPoints = false;
 
    bool mRenderingFeature = false;
    double mFeatureSymbolOpacity = 1;
};
 
 
class CORE_EXPORT QgsCentroidFillSymbolLayer : public QgsFillSymbolLayer
{
  public:
    QgsCentroidFillSymbolLayer();
    ~QgsCentroidFillSymbolLayer() override;
 
    // static stuff
 
    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
    static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
 
    // implemented from base classes
 
    QString layerType() const override;
    void startRender( QgsSymbolRenderContext &context ) override;
    void stopRender( QgsSymbolRenderContext &context ) override;
    void renderPolygon( const QPolygonF &points, const QVector<QPolygonF> *rings, QgsSymbolRenderContext &context ) override;
    QVariantMap properties() const override;
    QgsCentroidFillSymbolLayer *clone() const override SIP_FACTORY;
    void toSld( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
    void setColor( const QColor &color ) override;
    QColor color() const override;
    QgsSymbol *subSymbol() override;
    bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
    QgsUnitTypes::RenderUnit outputUnit() const override;
    bool usesMapUnits() const override;
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
    QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
    bool hasDataDefinedProperties() const override;
    bool canCauseArtifactsBetweenAdjacentTiles() const override;
 
    void setPointOnSurface( bool pointOnSurface ) { mPointOnSurface = pointOnSurface; }
    bool pointOnSurface() const { return mPointOnSurface; }
 
    void setPointOnAllParts( bool pointOnAllParts ) { mPointOnAllParts = pointOnAllParts; }
 
    bool pointOnAllParts() const { return mPointOnAllParts; }
 
    bool clipPoints() const { return mClipPoints; }
 
    void setClipPoints( bool clipPoints ) { mClipPoints = clipPoints; }
 
    bool clipOnCurrentPartOnly() const { return mClipOnCurrentPartOnly; }
 
    void setClipOnCurrentPartOnly( bool clipOnCurrentPartOnly ) { mClipOnCurrentPartOnly = clipOnCurrentPartOnly; }
 
    void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
    void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
 
  protected:
 
    std::unique_ptr< QgsMarkerSymbol > mMarker;
    bool mPointOnSurface = false;
    bool mPointOnAllParts = true;
    bool mClipPoints = false;
    bool mClipOnCurrentPartOnly = false;
 
    bool mRenderingFeature = false;
    double mFeatureSymbolOpacity = 1;
 
  private:
#ifdef SIP_RUN
    QgsCentroidFillSymbolLayer( const QgsCentroidFillSymbolLayer &other );
#endif
    struct Part
    {
      QPolygonF exterior;
      QVector<QPolygonF> rings;
    };
 
    void render( QgsRenderContext &context, const QVector<Part> &parts, const QgsFeature &feature, bool selected );
    QVector<Part> mCurrentParts;
};
 
#endif