qgsmarkersymbollayer.h

Go to the documentation of this file.

/***************************************************************************
 qgsmarkersymbollayer.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 QGSMARKERSYMBOLLAYER_H
#define QGSMARKERSYMBOLLAYER_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgssymbollayer.h"
 
#define DEFAULT_SIMPLEMARKER_NAME         "circle"
#define DEFAULT_SIMPLEMARKER_COLOR        QColor(255,0,0)
#define DEFAULT_SIMPLEMARKER_BORDERCOLOR  QColor( 35, 35, 35 )
#define DEFAULT_SIMPLEMARKER_JOINSTYLE    Qt::BevelJoin
#define DEFAULT_SIMPLEMARKER_SIZE         DEFAULT_POINT_SIZE
#define DEFAULT_SIMPLEMARKER_ANGLE        0
 
#include <QPen>
#include <QBrush>
#include <QPicture>
#include <QPolygonF>
#include <QFont>
 
class QgsFillSymbol;
class QgsPathResolver;
 
class CORE_EXPORT QgsSimpleMarkerSymbolLayerBase : public QgsMarkerSymbolLayer
{
 
  public:
 
    static QList< Qgis::MarkerShape > availableShapes();
 
    static bool shapeIsFilled( Qgis::MarkerShape shape );
 
    QgsSimpleMarkerSymbolLayerBase( Qgis::MarkerShape shape = Qgis::MarkerShape::Circle,
                                    double size = DEFAULT_SIMPLEMARKER_SIZE,
                                    double angle = DEFAULT_SIMPLEMARKER_ANGLE,
                                    Qgis::ScaleMethod scaleMethod = DEFAULT_SCALE_METHOD );
 
    ~QgsSimpleMarkerSymbolLayerBase() override;
 
    Qgis::MarkerShape shape() const { return mShape; }
 
    void setShape( Qgis::MarkerShape shape ) { mShape = shape; }
 
    static Qgis::MarkerShape decodeShape( const QString &name, bool *ok = nullptr );
 
    static QString encodeShape( Qgis::MarkerShape shape );
 
    void startRender( QgsSymbolRenderContext &context ) override;
    void stopRender( QgsSymbolRenderContext &context ) override;
    void renderPoint( QPointF point, QgsSymbolRenderContext &context ) override;
    QRectF bounds( QPointF point, QgsSymbolRenderContext &context ) override;
 
  protected:
 
    bool prepareMarkerShape( Qgis::MarkerShape shape );
 
    bool prepareMarkerPath( Qgis::MarkerShape symbol );
 
    bool shapeToPolygon( Qgis::MarkerShape shape, QPolygonF &polygon ) const;
 
    double calculateSize( QgsSymbolRenderContext &context, bool &hasDataDefinedSize ) const;
 
    void calculateOffsetAndRotation( QgsSymbolRenderContext &context, double scaledSize, bool &hasDataDefinedRotation, QPointF &offset, double &angle ) const;
 
    QPolygonF mPolygon;
 
    QPainterPath mPath;
 
    Qgis::MarkerShape mShape;
 
  private:
 
    virtual void draw( QgsSymbolRenderContext &context, Qgis::MarkerShape shape, const QPolygonF &polygon, const QPainterPath &path ) = 0 SIP_FORCE;
};
 
class CORE_EXPORT QgsSimpleMarkerSymbolLayer : public QgsSimpleMarkerSymbolLayerBase
{
  public:
 
    QgsSimpleMarkerSymbolLayer( Qgis::MarkerShape shape = Qgis::MarkerShape::Circle,
                                double size = DEFAULT_SIMPLEMARKER_SIZE,
                                double angle = DEFAULT_SIMPLEMARKER_ANGLE,
                                Qgis::ScaleMethod scaleMethod = DEFAULT_SCALE_METHOD,
                                const QColor &color = DEFAULT_SIMPLEMARKER_COLOR,
                                const QColor &strokeColor = DEFAULT_SIMPLEMARKER_BORDERCOLOR,
                                Qt::PenJoinStyle penJoinStyle = DEFAULT_SIMPLEMARKER_JOINSTYLE );
 
    ~QgsSimpleMarkerSymbolLayer() override;
 
    // static methods
 
    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
 
    static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
 
    // reimplemented from base classes
 
    QString layerType() const override;
    void startRender( QgsSymbolRenderContext &context ) override;
    void renderPoint( QPointF point, QgsSymbolRenderContext &context ) override;
    QVariantMap properties() const override;
    QgsSimpleMarkerSymbolLayer *clone() const override SIP_FACTORY;
    void writeSldMarker( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
    QString ogrFeatureStyle( double mmScaleFactor, double mapUnitScaleFactor ) const override;
    bool writeDxf( QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift = QPointF( 0.0, 0.0 ) ) const override;
    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
    QgsUnitTypes::RenderUnit outputUnit() const override;
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
    bool usesMapUnits() const override;
    QRectF bounds( QPointF point, QgsSymbolRenderContext &context ) override;
    QColor fillColor() const override { return mColor; }
    void setFillColor( const QColor &color ) override { mColor = color; }
    void setColor( const QColor &color ) override;
    QColor color() const override;
 
    // new methods
 
    QColor strokeColor() const override { return mStrokeColor; }
 
    void setStrokeColor( const QColor &color ) override { mStrokeColor = color; }
 
    Qt::PenStyle strokeStyle() const { return mStrokeStyle; }
 
    void setStrokeStyle( Qt::PenStyle strokeStyle ) { mStrokeStyle = strokeStyle; }
 
    Qt::PenJoinStyle penJoinStyle() const { return mPenJoinStyle; }
 
    void setPenJoinStyle( Qt::PenJoinStyle style ) { mPenJoinStyle = style; }
 
    Qt::PenCapStyle penCapStyle() const { return mPenCapStyle; }
 
    void setPenCapStyle( Qt::PenCapStyle style ) { mPenCapStyle = style; }
 
    double strokeWidth() const { return mStrokeWidth; }
 
    void setStrokeWidth( double w ) { mStrokeWidth = w; }
 
    void setStrokeWidthUnit( QgsUnitTypes::RenderUnit u ) { mStrokeWidthUnit = u; }
 
    QgsUnitTypes::RenderUnit strokeWidthUnit() const { return mStrokeWidthUnit; }
 
    void setStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mStrokeWidthMapUnitScale = scale; }
 
    const QgsMapUnitScale &strokeWidthMapUnitScale() const { return mStrokeWidthMapUnitScale; }
 
  protected:
 
    void drawMarker( QPainter *p, QgsSymbolRenderContext &context );
 
    bool prepareCache( QgsSymbolRenderContext &context );
 
    QColor mStrokeColor;
    Qt::PenStyle mStrokeStyle = Qt::SolidLine;
    double mStrokeWidth = 0;
    QgsUnitTypes::RenderUnit mStrokeWidthUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mStrokeWidthMapUnitScale;
    Qt::PenJoinStyle mPenJoinStyle;
    Qt::PenCapStyle mPenCapStyle = Qt::SquareCap;
    QPen mPen;
    QBrush mBrush;
 
    QImage mCache;
    QPen mSelPen;
    QBrush mSelBrush;
    QImage mSelCache;
 
    bool mUsingCache = false;
 
    static const int MAXIMUM_CACHE_WIDTH = 3000;
 
  private:
    // cppcheck-suppress unusedPrivateFunction
    void draw( QgsSymbolRenderContext &context, Qgis::MarkerShape shape, const QPolygonF &polygon, const QPainterPath &path ) override SIP_FORCE;
 
    double mCachedOpacity = 1.0;
 
};
 
class CORE_EXPORT QgsFilledMarkerSymbolLayer : public QgsSimpleMarkerSymbolLayerBase
{
  public:
 
    QgsFilledMarkerSymbolLayer( Qgis::MarkerShape shape = Qgis::MarkerShape::Circle,
                                double size = DEFAULT_SIMPLEMARKER_SIZE,
                                double angle = DEFAULT_SIMPLEMARKER_ANGLE,
                                Qgis::ScaleMethod scaleMethod = DEFAULT_SCALE_METHOD );
 
    ~QgsFilledMarkerSymbolLayer() override;
 
    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
 
    QString layerType() const override;
    void startRender( QgsSymbolRenderContext &context ) override;
    void stopRender( QgsSymbolRenderContext &context ) override;
    QVariantMap properties() const override;
    QgsFilledMarkerSymbolLayer *clone() const override SIP_FACTORY;
    QgsSymbol *subSymbol() override;
    bool setSubSymbol( QgsSymbol *symbol SIP_TRANSFER ) override;
    double estimateMaxBleed( const QgsRenderContext &context ) const override;
    QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
    bool hasDataDefinedProperties() const override;
    void setColor( const QColor &c ) override;
    QColor color() const override;
    bool usesMapUnits() const override;
    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
 
  private:
#ifdef SIP_RUN
    QgsFilledMarkerSymbolLayer( const QgsFilledMarkerSymbolLayer & );
#endif
 
    // cppcheck-suppress unusedPrivateFunction
    void draw( QgsSymbolRenderContext &context, Qgis::MarkerShape shape, const QPolygonF &polygon, const QPainterPath &path ) override SIP_FORCE;
 
    std::unique_ptr< QgsFillSymbol > mFill;
};
 
 
#define DEFAULT_SVGMARKER_SIZE         2*DEFAULT_POINT_SIZE
#define DEFAULT_SVGMARKER_ANGLE        0
 
class CORE_EXPORT QgsSvgMarkerSymbolLayer : public QgsMarkerSymbolLayer
{
  public:
    QgsSvgMarkerSymbolLayer( const QString &path,
                             double size = DEFAULT_SVGMARKER_SIZE,
                             double angle = DEFAULT_SVGMARKER_ANGLE,
                             Qgis::ScaleMethod scaleMethod = DEFAULT_SCALE_METHOD );
 
    ~QgsSvgMarkerSymbolLayer() override;
 
    // static stuff
 
    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 renderPoint( QPointF point, QgsSymbolRenderContext &context ) override;
 
    QVariantMap properties() const override;
    bool usesMapUnits() const override;
 
    QgsSvgMarkerSymbolLayer *clone() const override SIP_FACTORY;
 
    void writeSldMarker( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
 
    QString path() const { return mPath; }
 
    void setPath( const QString &path );
 
    double defaultAspectRatio() const { return mDefaultAspectRatio; }
 
    double updateDefaultAspectRatio();
 
    bool preservedAspectRatio() const { return mFixedAspectRatio <= 0.0; }
 
    bool setPreservedAspectRatio( bool par );
 
    double fixedAspectRatio() const { return mFixedAspectRatio; }
 
    void setFixedAspectRatio( double ratio ) { mFixedAspectRatio = ratio; }
 
    QColor fillColor() const override { return color(); }
    void setFillColor( const QColor &color ) override { setColor( color ); }
 
    QColor strokeColor() const override { return mStrokeColor; }
    void setStrokeColor( const QColor &c ) override { mStrokeColor = c; }
 
    double strokeWidth() const { return mStrokeWidth; }
    void setStrokeWidth( double w ) { mStrokeWidth = w; }
 
    QMap<QString, QgsProperty> parameters() const { return mParameters; }
 
    void setParameters( const QMap<QString, QgsProperty> &parameters );
 
    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 setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
    QgsUnitTypes::RenderUnit outputUnit() const override;
 
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
 
    bool writeDxf( QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolRenderContext &context, QPointF shift = QPointF( 0.0, 0.0 ) ) const override;
 
    QRectF bounds( QPointF point, QgsSymbolRenderContext &context ) override;
 
    void prepareExpressions( const QgsSymbolRenderContext &context ) override;
 
    QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
 
  protected:
 
    double calculateAspectRatio( QgsSymbolRenderContext &context, double scaledSize, bool &hasDataDefinedAspectRatio ) const;
 
    QString mPath;
 
    double mDefaultAspectRatio = 0.0;
    double mFixedAspectRatio = 0.0;
    //param(fill), param(stroke), param(stroke-width) are going
    //to be replaced in memory
    bool mHasFillParam = false;
    QColor mStrokeColor;
    double mStrokeWidth;
    QMap<QString, QgsProperty> mParameters;
 
    QgsUnitTypes::RenderUnit mStrokeWidthUnit;
    QgsMapUnitScale mStrokeWidthMapUnitScale;
 
  private:
    double calculateSize( QgsSymbolRenderContext &context, bool &hasDataDefinedSize ) const;
    void calculateOffsetAndRotation( QgsSymbolRenderContext &context, double scaledWidth, double scaledHeight, QPointF &offset, double &angle ) const;
 
};
 
 
 
#define DEFAULT_RASTERMARKER_SIZE         2*DEFAULT_POINT_SIZE
#define DEFAULT_RASTERMARKER_ANGLE        0
 
class CORE_EXPORT QgsRasterMarkerSymbolLayer : public QgsMarkerSymbolLayer
{
  public:
    QgsRasterMarkerSymbolLayer( const QString &path = QString(),
                                double size = DEFAULT_SVGMARKER_SIZE,
                                double angle = DEFAULT_SVGMARKER_ANGLE,
                                Qgis::ScaleMethod scaleMethod = DEFAULT_SCALE_METHOD );
 
    ~QgsRasterMarkerSymbolLayer() override;
 
    // static stuff
 
    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 renderPoint( QPointF point, QgsSymbolRenderContext &context ) override;
    QVariantMap properties() const override;
    QgsRasterMarkerSymbolLayer *clone() const override SIP_FACTORY;
    bool usesMapUnits() const override;
    QColor color() const override;
 
    double calculateAspectRatio( QgsSymbolRenderContext &context, double scaledSize, bool &hasDataDefinedAspectRatio ) const;
 
    QString path() const { return mPath; }
 
    void setPath( const QString &path );
 
    double opacity() const { return mOpacity; }
 
    void setOpacity( double opacity ) { mOpacity = opacity; }
 
    double defaultAspectRatio() const { return mDefaultAspectRatio; }
 
    double updateDefaultAspectRatio();
 
    bool preservedAspectRatio() const { return mFixedAspectRatio <= 0.0; }
 
    bool setPreservedAspectRatio( bool par );
 
    double fixedAspectRatio() const { return mFixedAspectRatio; }
 
    void setFixedAspectRatio( double ratio ) { mFixedAspectRatio = ratio; }
 
    void setMapUnitScale( const QgsMapUnitScale &scale ) override;
    QgsMapUnitScale mapUnitScale() const override;
 
    QRectF bounds( QPointF point, QgsSymbolRenderContext &context ) override;
 
  protected:
 
    void setCommonProperties( const QVariantMap &properties );
 
    void copyCommonProperties( QgsRasterMarkerSymbolLayer *other ) const;
 
    virtual QImage fetchImage( QgsRenderContext &context, const QString &path, QSize size, bool preserveAspectRatio, double opacity ) const SIP_SKIP;
 
    QString mPath;
    double mOpacity = 1.0;
    double mDefaultAspectRatio = 0.0;
    double mFixedAspectRatio = 0.0;
 
  private:
    double calculateSize( QgsSymbolRenderContext &context, bool &hasDataDefinedSize ) const;
    void calculateOffsetAndRotation( QgsSymbolRenderContext &context, double scaledWidth, double scaledHeight, QPointF &offset, double &angle ) const;
 
};
 
 
 
#define POINT2MM(x) ( (x) * 25.4 / 72 ) // point is 1/72 of inch
#define MM2POINT(x) ( (x) * 72 / 25.4 )
 
#define DEFAULT_FONTMARKER_FONT   "Dingbats"
#define DEFAULT_FONTMARKER_CHR    QChar('A')
#define DEFAULT_FONTMARKER_SIZE   POINT2MM(12)
#define DEFAULT_FONTMARKER_COLOR  QColor( 35, 35, 35 )
#define DEFAULT_FONTMARKER_BORDERCOLOR  QColor(Qt::white)
#define DEFAULT_FONTMARKER_JOINSTYLE    Qt::MiterJoin
#define DEFAULT_FONTMARKER_ANGLE  0
 
class CORE_EXPORT QgsFontMarkerSymbolLayer : public QgsMarkerSymbolLayer
{
  public:
 
    QgsFontMarkerSymbolLayer( const QString &fontFamily = DEFAULT_FONTMARKER_FONT,
                              QString chr = DEFAULT_FONTMARKER_CHR,
                              double pointSize = DEFAULT_FONTMARKER_SIZE,
                              const QColor &color = DEFAULT_FONTMARKER_COLOR,
                              double angle = DEFAULT_FONTMARKER_ANGLE );
 
    ~QgsFontMarkerSymbolLayer() override;
 
    // static stuff
 
    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
 
    static QgsSymbolLayer *createFromSld( QDomElement &element ) SIP_FACTORY;
 
    static void resolveFonts( const QVariantMap &properties, const QgsReadWriteContext &context );
 
    // implemented from base classes
 
    QString layerType() const override;
 
    void startRender( QgsSymbolRenderContext &context ) override;
 
    void stopRender( QgsSymbolRenderContext &context ) override;
 
    void renderPoint( QPointF point, QgsSymbolRenderContext &context ) override;
 
    QVariantMap properties() const override;
 
    QgsFontMarkerSymbolLayer *clone() const override SIP_FACTORY;
 
    void writeSldMarker( QDomDocument &doc, QDomElement &element, const QVariantMap &props ) const override;
    bool usesMapUnits() const override;
    void setOutputUnit( QgsUnitTypes::RenderUnit unit ) override;
 
    // new methods
 
    QString fontFamily() const { return mFontFamily; }
 
    void setFontFamily( const QString &family ) { mFontFamily = family; }
 
    QString fontStyle() const { return mFontStyle; }
 
    void setFontStyle( const QString &style ) { mFontStyle = style; }
 
    QString character() const { return mString; }
 
    void setCharacter( QString chr ) { mString = chr; }
 
    QColor strokeColor() const override { return mStrokeColor; }
    void setStrokeColor( const QColor &color ) override { mStrokeColor = color; }
 
    double strokeWidth() const { return mStrokeWidth; }
 
    void setStrokeWidth( double width ) { mStrokeWidth = width; }
 
    QgsUnitTypes::RenderUnit strokeWidthUnit() const { return mStrokeWidthUnit; }
 
    void setStrokeWidthUnit( QgsUnitTypes::RenderUnit unit ) { mStrokeWidthUnit = unit; }
 
    const QgsMapUnitScale &strokeWidthMapUnitScale() const { return mStrokeWidthMapUnitScale; }
 
    void setStrokeWidthMapUnitScale( const QgsMapUnitScale &scale ) { mStrokeWidthMapUnitScale = scale; }
 
    Qt::PenJoinStyle penJoinStyle() const { return mPenJoinStyle; }
 
    void setPenJoinStyle( Qt::PenJoinStyle style ) { mPenJoinStyle = style; }
 
    QRectF bounds( QPointF point, QgsSymbolRenderContext &context ) override;
 
  private:
 
    QString mFontFamily;
    QString mFontStyle;
    QFont mFont;
    std::unique_ptr< QFontMetrics >mFontMetrics;
 
    QString mString;
 
    double mChrWidth = 0;
    QPointF mChrOffset;
    double mFontSizeScale = 1.0;
    double mOrigSize;
 
    QColor mStrokeColor;
    double mStrokeWidth;
    QgsUnitTypes::RenderUnit mStrokeWidthUnit;
    QgsMapUnitScale mStrokeWidthMapUnitScale;
    Qt::PenJoinStyle mPenJoinStyle;
 
    QPen mPen;
    QBrush mBrush;
 
    bool mUseCachedPath = false;
    QPainterPath mCachedPath;
 
    // If font has a zero (or nearly zero) size, we skip rendering altogether..
    bool mNonZeroFontSize = true;
 
    QString characterToRender( QgsSymbolRenderContext &context, QPointF &charOffset, double &charWidth );
    void calculateOffsetAndRotation( QgsSymbolRenderContext &context, double scaledSize, bool &hasDataDefinedRotation, QPointF &offset, double &angle ) const;
    double calculateSize( QgsSymbolRenderContext &context );
};
 
 
class CORE_EXPORT QgsAnimatedMarkerSymbolLayer : public QgsRasterMarkerSymbolLayer
{
  public:
 
    QgsAnimatedMarkerSymbolLayer( const QString &path = QString(),
                                  double size = DEFAULT_RASTERMARKER_SIZE,
                                  double angle = DEFAULT_RASTERMARKER_ANGLE );
 
    ~QgsAnimatedMarkerSymbolLayer() override;
 
    // static stuff
 
    static QgsSymbolLayer *create( const QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
 
    // implemented from base classes
 
    QString layerType() const override;
    QVariantMap properties() const override;
    QgsAnimatedMarkerSymbolLayer *clone() const override SIP_FACTORY;
 
    void setFrameRate( double rate ) { mFrameRateFps = rate; }
 
    double frameRate() const { return mFrameRateFps; }
 
    void startRender( QgsSymbolRenderContext &context ) override;
 
  protected:
    QImage fetchImage( QgsRenderContext &context, const QString &path, QSize size, bool preserveAspectRatio, double opacity ) const override SIP_SKIP;
 
  private:
    double mFrameRateFps = 10;
    bool mStaticPath = false;
    mutable QSet< QString > mPreparedPaths;
 
};
 
// clazy:excludeall=qstring-allocations
 
#endif