qgssymbollayerutils.h

Go to the documentation of this file.

/***************************************************************************
 qgssymbollayerutils.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 QGSSYMBOLLAYERUTILS_H
#define QGSSYMBOLLAYERUTILS_H
 
#include "qgis.h"
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsarrowsymbollayer.h"
#include "qgscolorramp.h"
#include "qgsmapunitscale.h"
#include "qgssymbol.h"
 
#include <QColor>
#include <QFile>
#include <QFont>
#include <QMap>
#include <QPainter>
#include <QString>
 
using namespace Qt::StringLiterals;
 
#define FONTMARKER_CHR_FIX "~!_#!#_!~"
 
class QgsExpression;
class QgsPathResolver;
class QgsReadWriteContext;
class QgsSymbolLayer;
 
typedef QMap<QString, QString> QgsStringMap;
typedef QMap<QString, QgsSymbol * > QgsSymbolMap;
typedef QList< QPair< QColor, QString > > QgsNamedColorList SIP_SKIP;
 
class QDomDocument;
class QDomElement;
class QIcon;
class QPixmap;
class QPointF;
class QSize;
class QMimeData;
class QgsFeatureRenderer;
class QgsSymbolLayerId;

class CORE_EXPORT QgsSymbolLayerUtils
{
  public:
    static QString encodeColor( const QColor &color );
    static QColor decodeColor( const QString &str );
 
    static QString encodeSldAlpha( int alpha );
    static int decodeSldAlpha( const QString &str );
 
    static QString encodeSldFontStyle( QFont::Style style );
    static QFont::Style decodeSldFontStyle( const QString &str );
 
    static QString encodeSldFontWeight( int weight );
    static int decodeSldFontWeight( const QString &str );
 
    static QString encodePenStyle( Qt::PenStyle style );
    static Qt::PenStyle decodePenStyle( const QString &str );
 
    static QString encodePenJoinStyle( Qt::PenJoinStyle style );
    static Qt::PenJoinStyle decodePenJoinStyle( const QString &str );
 
    static QString encodePenCapStyle( Qt::PenCapStyle style );
    static Qt::PenCapStyle decodePenCapStyle( const QString &str );
 
    static QString encodeSldLineJoinStyle( Qt::PenJoinStyle style );
    static Qt::PenJoinStyle decodeSldLineJoinStyle( const QString &str );
 
    static QString encodeSldLineCapStyle( Qt::PenCapStyle style );
    static Qt::PenCapStyle decodeSldLineCapStyle( const QString &str );
 
    static QString encodeBrushStyle( Qt::BrushStyle style );
    static Qt::BrushStyle decodeBrushStyle( const QString &str );
 
    static QString encodeSldBrushStyle( Qt::BrushStyle style );
    static Qt::BrushStyle decodeSldBrushStyle( const QString &str );

    static Qgis::EndCapStyle penCapStyleToEndCapStyle( Qt::PenCapStyle style );

    static Qgis::JoinStyle penJoinStyleToJoinStyle( Qt::PenJoinStyle style );

    static bool hasSldSymbolizer( const QDomElement &element );

    static Qgis::SymbolCoordinateReference decodeCoordinateReference( const QString &string, bool *ok SIP_OUT = nullptr );

    static QString encodeCoordinateReference( Qgis::SymbolCoordinateReference coordinateReference );

    static QgsArrowSymbolLayer::HeadType decodeArrowHeadType( const QVariant &value, bool *ok SIP_OUT = nullptr );

    static QgsArrowSymbolLayer::ArrowType decodeArrowType( const QVariant &value, bool *ok SIP_OUT = nullptr );

    static Qgis::MarkerClipMode decodeMarkerClipMode( const QString &string, bool *ok SIP_OUT = nullptr );

    static QString encodeMarkerClipMode( Qgis::MarkerClipMode mode );

    static Qgis::LineClipMode decodeLineClipMode( const QString &string, bool *ok SIP_OUT = nullptr );

    static QString encodeLineClipMode( Qgis::LineClipMode mode );

    static QString encodePoint( QPointF point );

    static QPointF decodePoint( const QString &string );

    static QPointF toPoint( const QVariant &value, bool *ok SIP_OUT = nullptr );

    static QString encodeSize( QSizeF size );

    static QSizeF decodeSize( const QString &string );

    static QSizeF toSize( const QVariant &value, bool *ok SIP_OUT = nullptr );
 
    static QString encodeMapUnitScale( const QgsMapUnitScale &mapUnitScale );
    static QgsMapUnitScale decodeMapUnitScale( const QString &str );
 
    static QString encodeRealVector( const QVector<qreal> &v );
    static QVector<qreal> decodeRealVector( const QString &s );
 
    static QString encodeSldRealVector( const QVector<qreal> &v );
    static QVector<qreal> decodeSldRealVector( const QString &s );

    static QString encodeSldUom( Qgis::RenderUnit unit, double *scaleFactor );

    static Qgis::RenderUnit decodeSldUom( const QString &str, double *scaleFactor = nullptr );

    static double sizeInPixelsFromSldUom( const QString &uom, double size );

    static QString encodeScaleMethod( Qgis::ScaleMethod scaleMethod );

    static Qgis::ScaleMethod decodeScaleMethod( const QString &str );
 
    static QPainter::CompositionMode decodeBlendMode( const QString &s );

    static QIcon symbolPreviewIcon( const QgsSymbol *symbol, QSize size, int padding = 0, QgsLegendPatchShape *shape = nullptr, const QgsScreenProperties &screen = QgsScreenProperties() );

    static QPixmap symbolPreviewPixmap(
      const QgsSymbol *symbol,
      QSize size,
      int padding = 0,
      QgsRenderContext *customContext = nullptr,
      bool selected = false,
      const QgsExpressionContext *expressionContext = nullptr,
      const QgsLegendPatchShape *shape = nullptr,
      const QgsScreenProperties &screen = QgsScreenProperties()
    );

    static QPicture symbolLayerPreviewPicture(
      const QgsSymbolLayer *layer, Qgis::RenderUnit units, QSize size, const QgsMapUnitScale &scale = QgsMapUnitScale(), Qgis::SymbolType parentSymbolType = Qgis::SymbolType::Hybrid
    );

    static QIcon symbolLayerPreviewIcon(
      const QgsSymbolLayer *layer,
      Qgis::RenderUnit u,
      QSize size,
      const QgsMapUnitScale &scale = QgsMapUnitScale(),
      Qgis::SymbolType parentSymbolType = Qgis::SymbolType::Hybrid,
      QgsMapLayer *mapLayer = nullptr,
      const QgsScreenProperties &screen = QgsScreenProperties()
    );

    static QIcon colorRampPreviewIcon( QgsColorRamp *ramp, QSize size, int padding = 0 );

    static QPixmap colorRampPreviewPixmap( QgsColorRamp *ramp, QSize size, int padding = 0, Qt::Orientation direction = Qt::Horizontal, bool flipDirection = false, bool drawTransparentBackground = true );
 
    static void drawStippledBackground( QPainter *painter, QRect rect );

    static void drawVertexMarker( double x, double y, QPainter &p, Qgis::VertexMarkerType type, int markerSize );

    static double estimateMaxSymbolBleed( QgsSymbol *symbol, const QgsRenderContext &context );

    static std::unique_ptr< QgsSymbol > loadSymbol( const QDomElement &element, const QgsReadWriteContext &context );

    template<class SymbolType> static std::unique_ptr< SymbolType > loadSymbol( const QDomElement &element, const QgsReadWriteContext &context ) SIP_SKIP
    {
      std::unique_ptr< QgsSymbol > tmpSymbol = QgsSymbolLayerUtils::loadSymbol( element, context );
      const bool canCast = dynamic_cast<SymbolType *>( tmpSymbol.get() );
 
      if ( canCast )
      {
        std::unique_ptr< SymbolType > castRes( static_cast<SymbolType *>( tmpSymbol.release() ) );
        return castRes;
      }
      else
      {
        //could not cast
        return nullptr;
      }
    }

    static std::unique_ptr< QgsSymbolLayer > loadSymbolLayer( QDomElement &element, const QgsReadWriteContext &context );

    static QDomElement saveSymbol( const QString &symbolName, const QgsSymbol *symbol, QDomDocument &doc, const QgsReadWriteContext &context );

    static QString symbolProperties( QgsSymbol *symbol );

    static bool createSymbolLayerListFromSld( QDomElement &element, Qgis::GeometryType geomType, QList<QgsSymbolLayer *> &layers );

    static std::unique_ptr< QgsSymbolLayer > createFillLayerFromSld( QDomElement &element );

    static std::unique_ptr< QgsSymbolLayer > createLineLayerFromSld( QDomElement &element );

    static std::unique_ptr< QgsSymbolLayer > createMarkerLayerFromSld( QDomElement &element );

    static bool convertPolygonSymbolizerToPointMarker( QDomElement &element, QList<QgsSymbolLayer *> &layerList );

    static bool hasExternalGraphic( QDomElement &element );

    static bool hasExternalGraphicV2( const QDomElement &element, const QString format = QString() );
 
    static bool hasWellKnownMark( QDomElement &element );
 
    static bool needFontMarker( QDomElement &element );

    static bool needSvgMarker( const QDomElement &element );

    static bool needRasterMarker( const QDomElement &element );
    static bool needEllipseMarker( QDomElement &element );
    static bool needMarkerLine( QDomElement &element );
    static bool needLinePatternFill( QDomElement &element );
    static bool needPointPatternFill( QDomElement &element );
    static bool needSvgFill( QDomElement &element );

    static bool needRasterImageFill( QDomElement &element );

    Q_DECL_DEPRECATED static void fillToSld( QDomDocument &doc, QDomElement &element, Qt::BrushStyle brushStyle, const QColor &color = QColor() ) SIP_DEPRECATED;

    static void fillToSld( QDomDocument &doc, QDomElement &element, QgsSldExportContext &context, Qt::BrushStyle brushStyle, const QColor &color = QColor() );
 
    static bool fillFromSld( QDomElement &element, Qt::BrushStyle &brushStyle, QColor &color );

    static void lineToSld(
      QDomDocument &doc,
      QDomElement &element,
      Qt::PenStyle penStyle,
      const QColor &color,
      QgsSldExportContext &context,
      double width = -1,
      const Qt::PenJoinStyle *penJoinStyle = nullptr,
      const Qt::PenCapStyle *penCapStyle = nullptr,
      const QVector<qreal> *customDashPattern = nullptr,
      double dashOffset = 0.0
    ) SIP_SKIP;
    static bool lineFromSld(
      QDomElement &element,
      Qt::PenStyle &penStyle,
      QColor &color,
      double &width,
      Qt::PenJoinStyle *penJoinStyle = nullptr,
      Qt::PenCapStyle *penCapStyle = nullptr,
      QVector<qreal> *customDashPattern = nullptr,
      double *dashOffset = nullptr
    );
 
    static void externalGraphicToSld( QDomDocument &doc, QDomElement &element, const QString &path, const QString &mime, const QColor &color, double size = -1 );
    static bool externalGraphicFromSld( QDomElement &element, QString &path, QString &mime, QColor &color, double &size );

    Q_DECL_DEPRECATED static void wellKnownMarkerToSld(
      QDomDocument &doc, QDomElement &element, const QString &name, const QColor &color, const QColor &strokeColor, Qt::PenStyle strokeStyle, double strokeWidth = -1, double size = -1
    ) SIP_DEPRECATED;

    static void wellKnownMarkerToSld(
      QDomDocument &doc,
      QDomElement &element,
      const QString &name,
      const QColor &color,
      const QColor &strokeColor,
      Qt::PenStyle strokeStyle,
      QgsSldExportContext &context,
      double strokeWidth = -1,
      double size = -1
    );

    static bool wellKnownMarkerFromSld( QDomElement &element, QString &name, QColor &color, QColor &strokeColor, Qt::PenStyle &strokeStyle, double &strokeWidth, double &size ) SIP_PYNAME(
      wellKnownMarkerFromSld2
    );

    Q_DECL_DEPRECATED static void externalMarkerToSld(
      QDomDocument &doc, QDomElement &element, const QString &path, const QString &format, int *markIndex = nullptr, const QColor &color = QColor(), double size = -1
    ) SIP_DEPRECATED;

    static void externalMarkerToSld(
      QDomDocument &doc, QDomElement &element, const QString &path, const QString &format, QgsSldExportContext &context, int *markIndex = nullptr, const QColor &color = QColor(), double size = -1
    );
 
    static bool externalMarkerFromSld( QDomElement &element, QString &path, QString &format, int &markIndex, QColor &color, double &size );

    Q_DECL_DEPRECATED static void labelTextToSld( QDomDocument &doc, QDomElement &element, const QString &label, const QFont &font, const QColor &color = QColor(), double size = -1 ) SIP_DEPRECATED;

    static void labelTextToSld( QDomDocument &doc, QDomElement &element, const QString &label, const QFont &font, QgsSldExportContext &context, const QColor &color = QColor(), double size = -1 );

    static QString ogrFeatureStylePen(
      double width,
      double mmScaleFactor,
      double mapUnitsScaleFactor,
      const QColor &c,
      Qt::PenJoinStyle joinStyle = Qt::MiterJoin,
      Qt::PenCapStyle capStyle = Qt::FlatCap,
      double offset = 0.0,
      const QVector<qreal> *dashPattern = nullptr
    );

    static QString ogrFeatureStyleBrush( const QColor &fillColr );

    Q_DECL_DEPRECATED static void createRotationElement( QDomDocument &doc, QDomElement &element, const QString &rotationFunc ) SIP_DEPRECATED;

    static void createRotationElement( QDomDocument &doc, QDomElement &element, const QString &rotationFunc, QgsSldExportContext &context );
 
    static bool rotationFromSldElement( QDomElement &element, QString &rotationFunc );

    Q_DECL_DEPRECATED static void createOpacityElement( QDomDocument &doc, QDomElement &element, const QString &alphaFunc ) SIP_DEPRECATED;

    static void createOpacityElement( QDomDocument &doc, QDomElement &element, const QString &alphaFunc, QgsSldExportContext &context );
 
    static bool opacityFromSldElement( QDomElement &element, QString &alphaFunc );
 
    static void createDisplacementElement( QDomDocument &doc, QDomElement &element, QPointF offset );
    static bool displacementFromSldElement( QDomElement &element, QPointF &offset );

    static void createAnchorPointElement( QDomDocument &doc, QDomElement &element, QPointF anchor );
 
    static void createOnlineResourceElement( QDomDocument &doc, QDomElement &element, const QString &path, const QString &format );
    static bool onlineResourceFromSldElement( QDomElement &element, QString &path, QString &format );

    Q_DECL_DEPRECATED static void createGeometryElement( QDomDocument &doc, QDomElement &element, const QString &geomFunc ) SIP_DEPRECATED;

    static void createGeometryElement( QDomDocument &doc, QDomElement &element, const QString &geomFunc, QgsSldExportContext &context );
 
    static bool geometryFromSldElement( QDomElement &element, QString &geomFunc );

    Q_DECL_DEPRECATED static bool createExpressionElement( QDomDocument &doc, QDomElement &element, const QString &function ) SIP_DEPRECATED;

    static bool createExpressionElement( QDomDocument &doc, QDomElement &element, const QString &function, QgsSldExportContext &context );

    Q_DECL_DEPRECATED static bool createFunctionElement( QDomDocument &doc, QDomElement &element, const QString &function ) SIP_DEPRECATED;

    static bool createFunctionElement( QDomDocument &doc, QDomElement &element, const QString &function, QgsSldExportContext &context );
 
    static bool functionFromSldElement( QDomElement &element, QString &function );
 
    static QDomElement createSvgParameterElement( QDomDocument &doc, const QString &name, const QString &value );
    static QgsStringMap getSvgParameterList( QDomElement &element );
 
    static QDomElement createVendorOptionElement( QDomDocument &doc, const QString &name, const QString &value );
    static QgsStringMap getVendorOptionList( QDomElement &element );

    static QVariantMap parseProperties( const QDomElement &element );
    static void saveProperties( QVariantMap props, QDomDocument &doc, QDomElement &element );

    static QgsSymbolMap loadSymbols( QDomElement &element, const QgsReadWriteContext &context ) SIP_FACTORY;
    static QDomElement saveSymbols( QgsSymbolMap &symbols, const QString &tagName, QDomDocument &doc, const QgsReadWriteContext &context );
 
    static void clearSymbolMap( QgsSymbolMap &symbols );

    static QMimeData *symbolToMimeData( const QgsSymbol *symbol ) SIP_FACTORY;

    static std::unique_ptr< QgsSymbol > symbolFromMimeData( const QMimeData *data );

    static std::unique_ptr< QgsColorRamp > loadColorRamp( QDomElement &element );

    static QDomElement saveColorRamp( const QString &name, const QgsColorRamp *ramp, QDomDocument &doc );

    static QVariant colorRampToVariant( const QString &name, QgsColorRamp *ramp );

    static std::unique_ptr< QgsColorRamp > loadColorRamp( const QVariant &value );

    static QString colorToName( const QColor &color );

    static QList< QColor > parseColorList( const QString &colorStr );

    static QMimeData *colorToMimeData( const QColor &color ) SIP_FACTORY;

    static QColor colorFromMimeData( const QMimeData *data, bool &hasAlpha SIP_OUT );

    static QgsNamedColorList colorListFromMimeData( const QMimeData *data );

    static QMimeData *colorListToMimeData( const QgsNamedColorList &colorList, bool allFormats = true ) SIP_FACTORY;

    static bool saveColorsToGpl( QFile &file, const QString &paletteName, const QgsNamedColorList &colors );

    static QgsNamedColorList importColorsFromGpl( QFile &file, bool &ok, QString &name );

    static QColor parseColor( const QString &colorStr, bool strictEval = false );

    static QColor parseColorWithAlpha( const QString &colorStr, bool &containsAlpha, bool strictEval = false );

    static void multiplyImageOpacity( QImage *image, qreal opacity );

    static void blurImageInPlace( QImage &image, QRect rect, int radius, bool alphaOnly );

    static void premultiplyColor( QColor &rgb, int alpha );

    static bool condenseFillAndOutline( QgsFillSymbolLayer *fill, QgsLineSymbolLayer *outline );

    static void sortVariantList( QList<QVariant> &list, Qt::SortOrder order );
    static QPointF pointOnLineWithDistance( QPointF startPoint, QPointF directionPoint, double distance );

    static QStringList listSvgFiles();

    static QStringList listSvgFilesAt( const QString &directory );

    static QString svgSymbolNameToPath( const QString &name, const QgsPathResolver &pathResolver );

    static QString svgSymbolPathToName( const QString &path, const QgsPathResolver &pathResolver );

    static QList< QList< QPolygonF > > toQPolygonF( const QgsGeometry &geometry, Qgis::SymbolType type );

    static QList< QList< QPolygonF > > toQPolygonF( const QgsAbstractGeometry *geometry, Qgis::SymbolType type );

    static QPointF polygonCentroid( const QPolygonF &points );

    static QPointF polygonPointOnSurface( const QPolygonF &points, const QVector<QPolygonF> *rings = nullptr );

    static bool pointInPolygon( const QPolygonF &points, QPointF point );

    static double polylineLength( const QPolygonF &polyline );

    static QPolygonF polylineSubstring( const QPolygonF &polyline, double startOffset, double endOffset );

    static bool isSharpCorner( QPointF p1, QPointF p2, QPointF p3 );

    static void appendPolyline( QPolygonF &target, const QPolygonF &line );

    static std::unique_ptr< QgsExpression > fieldOrExpressionToExpression( const QString &fieldOrExpression );

    static QString fieldOrExpressionFromExpression( QgsExpression *expression );

    static QList<double> prettyBreaks( double minimum, double maximum, int classes );

    static double rescaleUom( double size, Qgis::RenderUnit unit, const QVariantMap &props );

    static QPointF rescaleUom( QPointF point, Qgis::RenderUnit unit, const QVariantMap &props ) SIP_PYNAME( rescalePointUom );

    static QVector<qreal> rescaleUom( const QVector<qreal> &array, Qgis::RenderUnit unit, const QVariantMap &props ) SIP_PYNAME( rescaleArrayUom );

    static void applyScaleDependency( QDomDocument &doc, QDomElement &ruleElem, QVariantMap &props );

    static void mergeScaleDependencies( double mScaleMinDenom, double mScaleMaxDenom, QVariantMap &props );

    Q_DECL_DEPRECATED static void parametricSvgToSld( QDomDocument &doc, QDomElement &graphicElem, const QString &path, const QColor &fillColor, double size, const QColor &strokeColor, double strokeWidth )
      SIP_DEPRECATED;

    static void parametricSvgToSld(
      QDomDocument &doc, QDomElement &graphicElem, const QString &path, const QColor &fillColor, double size, const QColor &strokeColor, double strokeWidth, QgsSldExportContext &context
    );

    static QString getSvgParametricPath( const QString &basePath, const QColor &fillColor, const QColor &strokeColor, double strokeWidth );

    Q_DECL_DEPRECATED static QSet<const QgsSymbolLayer *> toSymbolLayerPointers( const QgsFeatureRenderer *renderer, const QSet<QgsSymbolLayerId> &symbolLayerIds );

    static double rendererFrameRate( const QgsFeatureRenderer *renderer );

    static std::unique_ptr< QgsSymbol > restrictedSizeSymbol( const QgsSymbol *s, double minSize, double maxSize, QgsRenderContext *context, double &width, double &height, bool *ok = nullptr );

    static QgsStringMap evaluatePropertiesMap( const QMap<QString, QgsProperty> &propertiesMap, const QgsExpressionContext &context );

    static QSize tileSize( int width, int height, double &angleRad SIP_INOUT );

    static void clearSymbolLayerIds( QgsSymbol *symbol );

    static void clearSymbolLayerIds( QgsSymbolLayer *symbolLayer );

    static void resetSymbolLayerIds( QgsSymbol *symbol );

    static void resetSymbolLayerIds( QgsSymbolLayer *symbolLayer );

    static void clearSymbolLayerMasks( QgsSymbol *symbol );

    static QVector< QgsGeometry > collectSymbolLayerClipGeometries( const QgsRenderContext &context, const QString &symbolLayerId, const QRectF &bounds );

#ifndef SIP_RUN
    static QgsProperty rotateWholeSymbol( double additionalRotation, const QgsProperty &property )
    {
      const QString exprString = property.asExpression();
      return QgsProperty::fromExpression( QString::number( additionalRotation ) + " + (" + exprString + ')' );
    }
 
    static QgsProperty scaleWholeSymbol( double scaleFactor, const QgsProperty &property )
    {
      const QString exprString = property.asExpression();
      return QgsProperty::fromExpression( QString::number( scaleFactor ) + "*(" + exprString + ')' );
    }
 
    static QgsProperty scaleWholeSymbol( double scaleFactorX, double scaleFactorY, const QgsProperty &property )
    {
      const QString exprString = property.asExpression();
      return QgsProperty::fromExpression(
        ( !qgsDoubleNear( scaleFactorX, 0.0 ) ? "tostring(" + QString::number( scaleFactorX ) + "*(" + exprString + "))" : u"'0'"_s )
        + "|| ',' || "
        + ( !qgsDoubleNear( scaleFactorY, 0.0 ) ? "tostring(" + QString::number( scaleFactorY ) + "*(" + exprString + "))" : u"'0'"_s )
      );
    }
#endif
};
 
class QPolygonF;

QList<QPolygonF> offsetLine( QPolygonF polyline, double dist, Qgis::GeometryType geometryType ) SIP_SKIP;
 
#endif