qgsinterpolatedlinerenderer.h

Go to the documentation of this file.

/***************************************************************************
  qgsinterpolatedlinerenderer.h
  --------------------------------------
  Date                 : April 2020
  Copyright            : (C) 2020 by Vincent Cloarec
  Email                : vcloarec 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 QGSINTERPOLATEDLINERENDERER_H
#define QGSINTERPOLATEDLINERENDERER_H
 
#include <QDebug>
 
#include "qgis.h"
#include "qgscolorrampshader.h"
#include "qgsreadwritecontext.h"
#include "qgsrendercontext.h"
#include "qgsrenderer.h"
#include "qgsunittypes.h"
#include "qgssymbollayer.h"
 
class QgsLayerTreeLayer;
 
class CORE_EXPORT QgsInterpolatedLineColor
{
  public:
 
    enum ColoringMethod
    {
      SingleColor = 0,
      ColorRamp
    };
 
    QgsInterpolatedLineColor();
    QgsInterpolatedLineColor( const QgsColorRampShader &colorRampShader );
    QgsInterpolatedLineColor( const QColor &color );
 
    void setColor( const QgsColorRampShader &colorRampShader );
 
    void setColor( const QColor &color );
 
    QColor color( double magnitude ) const;
 
    void setColoringMethod( const QgsInterpolatedLineColor::ColoringMethod &coloringMethod );
 
    QgsInterpolatedLineColor::ColoringMethod coloringMethod() const;
 
    QgsColorRampShader colorRampShader() const;
 
    QColor singleColor() const;
 
    QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const;
    void readXml( const QDomElement &elem, const QgsReadWriteContext &context );
 
    void graduatedColors( double value1, double value2, QList<double> &breakValues, QList<QColor> &breakColors, QList<QLinearGradient> &gradients ) const;
 
  private:
    QgsColorRampShader mColorRampShader;
    QColor mSingleColor = Qt::black;
 
    QgsInterpolatedLineColor::ColoringMethod mColoringMethod = SingleColor;
 
    QLinearGradient makeSimpleLinearGradient( const QColor &color1, const QColor &color2 ) const;
 
    int itemColorIndexInf( double value ) const;
 
    void graduatedColorsExact( double value1, double value2, QList<double> &breakValues, QList<QColor> &breakColors, QList<QLinearGradient> &gradients ) const;
    void graduatedColorsInterpolated( double value1, double value2, QList<double> &breakValues, QList<QColor> &breakColors, QList<QLinearGradient> &gradients ) const;
    void graduatedColorsDiscrete( double value1, double value2, QList<double> &breakValues, QList<QColor> &breakColors, QList<QLinearGradient> &gradients ) const;
};
 
class CORE_EXPORT QgsInterpolatedLineWidth
{
  public:
    double minimumValue() const;
    void setMinimumValue( double minimumValue );
 
    double maximumValue() const;
    void setMaximumValue( double maximumValue );
 
    double minimumWidth() const;
    void setMinimumWidth( double minimumWidth );
 
    double maximumWidth() const;
    void setMaximumWidth( double maximumWidth );
 
    bool ignoreOutOfRange() const;
    void setIgnoreOutOfRange( bool ignoreOutOfRange );
 
    bool useAbsoluteValue() const;
    void setUseAbsoluteValue( bool useAbsoluteValue );
 
    bool isVariableWidth() const;
    void setIsVariableWidth( bool isVariableWidth );
 
    double fixedStrokeWidth() const;
    void setFixedStrokeWidth( double fixedWidth );
 
    double strokeWidth( double value ) const;
 
    QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const;
    void readXml( const QDomElement &elem, const QgsReadWriteContext &context );
 
  private:
    bool mIsWidthVariable = false;
 
    double mFixedWidth = DEFAULT_LINE_WIDTH;
 
    double mMinimumValue = 0;
    double mMaximumValue = 10;
    double mMinimumWidth = DEFAULT_LINE_WIDTH;
    double mMaximumWidth = 3;
    bool mIgnoreOutOfRange = false;
    bool mUseAbsoluteValue = false;
 
    mutable double mLinearCoef = 1;
    mutable bool mNeedUpdateFormula = true;
    void updateLinearFormula() const;
};
 
class CORE_EXPORT QgsInterpolatedLineRenderer
{
  public:
 
    void setInterpolatedWidth( const QgsInterpolatedLineWidth &strokeWidth );
 
    QgsInterpolatedLineWidth interpolatedLineWidth() const;
 
    void setWidthUnit( const QgsUnitTypes::RenderUnit &strokeWidthUnit );
 
    QgsUnitTypes::RenderUnit widthUnit() const;
 
    void setInterpolatedColor( const QgsInterpolatedLineColor &strokeColoring );
 
    QgsInterpolatedLineColor interpolatedColor() const;
 
    void render( double value1, double value2, const QgsPointXY &point1, const QgsPointXY &point2, QgsRenderContext &context ) const;
 
    void render( double valueColor1, double valueColor2, double valueWidth1, double valueWidth2, const QgsPointXY &point1, const QgsPointXY &point2, QgsRenderContext &context ) const;
 
    void setSelected( bool selected );
 
  private:
 
    QgsInterpolatedLineWidth mStrokeWidth;
    QgsInterpolatedLineColor mStrokeColoring;
    QgsUnitTypes::RenderUnit mStrokeWidthUnit = QgsUnitTypes::RenderMillimeters;
    void adjustLine( const double &value, const double &value1, const double &value2, double &width, double &adjusting ) const;
    bool mSelected = false;
 
    void renderInDeviceCoordinate( double valueColor1, double valueColor2, double valueWidth1, double valueWidth2, const QPointF &p1, const QPointF &p2, QgsRenderContext &context ) const;
 
    friend class QgsInterpolatedLineSymbolLayer;
};
 
class CORE_EXPORT QgsInterpolatedLineSymbolLayer : public QgsLineSymbolLayer
{
  public:
 
    QgsInterpolatedLineSymbolLayer();
 
    static QgsSymbolLayer *create( const QVariantMap &properties ) SIP_FACTORY;
 
    QString layerType() const override;
    void startRender( QgsSymbolRenderContext &context ) override;
    void stopRender( QgsSymbolRenderContext &context ) override;
    QgsInterpolatedLineSymbolLayer *clone() const override SIP_FACTORY;
    QVariantMap properties() const override;
    void drawPreviewIcon( QgsSymbolRenderContext &context, QSize size ) override;
 
    void startFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
    void stopFeatureRender( const QgsFeature &feature, QgsRenderContext &context ) override;
    void renderPolyline( const QPolygonF &points, QgsSymbolRenderContext &context ) override;
    bool isCompatibleWithSymbol( QgsSymbol *symbol ) const override;
    QSet<QString> usedAttributes( const QgsRenderContext &context ) const override;
    bool canCauseArtifactsBetweenAdjacentTiles() const override;
 
    void setExpressionsStringForWidth( QString start, QString end );
 
    QString startValueExpressionForWidth() const;
 
    QString endValueExpressionForWidth() const;
 
    void setWidthUnit( const QgsUnitTypes::RenderUnit &strokeWidthUnit );
 
    QgsUnitTypes::RenderUnit widthUnit() const;
 
    void setInterpolatedWidth( const QgsInterpolatedLineWidth &interpolatedLineWidth );
 
    QgsInterpolatedLineWidth interpolatedWidth() const;
 
    void setExpressionsStringForColor( QString start, QString end );
 
    QString startValueExpressionForColor() const;
 
    QString endValueExpressionForColor() const;
 
    void setInterpolatedColor( const QgsInterpolatedLineColor &interpolatedLineColor );
 
    QgsInterpolatedLineColor interpolatedColor() const;
 
  private:
#ifdef SIP_RUN
    QgsInterpolatedLineSymbolLayer( const QgsInterpolatedLineSymbolLayer &copy );
#endif
 
    QgsInterpolatedLineRenderer mLineRender;
    QString mStartWidthExpressionString;
    QString mEndWidthExpressionString;
    QString mStartColorExpressionString;
    QString mEndColorExpressionString;
 
    int mStartWidthAttributeIndex = -1;
    int mEndWidthAttributeIndex = -1;
    int mStartColorAttributeIndex = -1;
    int mEndColorAttributeIndex = -1;
 
    std::unique_ptr<QgsExpression> mStartWidthExpression;
    std::unique_ptr<QgsExpression> mEndWithExpression;
    std::unique_ptr<QgsExpression> mStartColorExpression;
    std::unique_ptr<QgsExpression> mEndColorExpression;
    QgsFeature mFeature;
 
    QVariant colorRampShaderProperties() const;
    static QgsColorRampShader createColorRampShaderFromProperties( const QVariant &properties );
};
 
 
#endif // QGSINTERPOLATEDLINERENDERER_H