qgspropertytransformer.h

Go to the documentation of this file.

/***************************************************************************
     qgspropertytransformer.h
     ------------------------
    Date                 : January 2017
    Copyright            : (C) 2017 by Nyall Dawson
    Email                : nyall dot dawson 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 QGSPROPERTYTRANSFORMER_H
#define QGSPROPERTYTRANSFORMER_H
 
#include "qgis_core.h"
#include "qgsexpression.h"
#include "qgsexpressioncontext.h"
#include "qgspointxy.h"
#include <QVariant>
#include <QHash>
#include <QString>
#include <QStringList>
#include <QDomElement>
#include <QDomDocument>
#include <QColor>
#include <memory>
#include <algorithm>
 
class QgsColorRamp;
 
 
class CORE_EXPORT QgsCurveTransform
{
  public:
 
    QgsCurveTransform();
 
    QgsCurveTransform( const QList< QgsPointXY > &controlPoints );
 
    ~QgsCurveTransform();
 
    QgsCurveTransform( const QgsCurveTransform &other );
 
    QgsCurveTransform &operator=( const QgsCurveTransform &other );
 
    QList< QgsPointXY > controlPoints() const { return mControlPoints; }
 
    void setControlPoints( const QList< QgsPointXY > &points );
 
    void addControlPoint( double x, double y );
 
    void removeControlPoint( double x, double y );
 
    double y( double x ) const;
 
    QVector< double > y( const QVector< double > &x ) const;
 
    bool readXml( const QDomElement &elem, const QDomDocument &doc );
 
    bool writeXml( QDomElement &transformElem, QDomDocument &doc ) const;
 
    QVariant toVariant() const;
 
    bool loadVariant( const QVariant &transformer );
 
  private:
 
    void calcSecondDerivativeArray();
 
    QList< QgsPointXY > mControlPoints;
 
    double *mSecondDerivativeArray = nullptr;
};
 
 
class CORE_EXPORT QgsPropertyTransformer
{
 
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( sipCpp->transformerType() == QgsPropertyTransformer::GenericNumericTransformer )
      sipType = sipType_QgsGenericNumericTransformer;
    else if ( sipCpp->transformerType() == QgsPropertyTransformer::SizeScaleTransformer )
      sipType = sipType_QgsSizeScaleTransformer;
    else if ( sipCpp->transformerType() == QgsPropertyTransformer::ColorRampTransformer )
      sipType = sipType_QgsColorRampTransformer;
    else
      sipType = sipType_QgsPropertyTransformer;
    SIP_END
#endif
 
  public:
 
    enum Type
    {
      GenericNumericTransformer, 
      SizeScaleTransformer, 
      ColorRampTransformer, 
    };
 
    static QgsPropertyTransformer *create( Type type ) SIP_FACTORY;
 
    QgsPropertyTransformer( double minValue = 0.0, double maxValue = 1.0 );
 
    QgsPropertyTransformer( const QgsPropertyTransformer &other );
    QgsPropertyTransformer &operator=( const QgsPropertyTransformer &other );
 
    virtual ~QgsPropertyTransformer();
 
    virtual Type transformerType() const = 0;
 
    virtual QgsPropertyTransformer *clone() const = 0 SIP_FACTORY;
 
    virtual bool loadVariant( const QVariant &transformer );
 
    virtual QVariant toVariant() const;
 
    double minValue() const { return mMinValue; }
 
    void setMinValue( double min ) { mMinValue = min; }
 
    double maxValue() const { return mMaxValue; }
 
    void setMaxValue( double max ) { mMaxValue = max; }
 
    QgsCurveTransform *curveTransform() const { return mCurveTransform.get(); }
 
    void setCurveTransform( QgsCurveTransform *transform SIP_TRANSFER ) { mCurveTransform.reset( transform ); }
 
    virtual QVariant transform( const QgsExpressionContext &context, const QVariant &value ) const = 0;
 
    virtual QString toExpression( const QString &baseExpression ) const = 0;
 
    static QgsPropertyTransformer *fromExpression( const QString &expression, QString &baseExpression SIP_OUT, QString &fieldName SIP_OUT ) SIP_FACTORY;
 
  protected:
 
    double transformNumeric( double input ) const;
#ifndef SIP_RUN
    double mMinValue;
 
    double mMaxValue;
 
    std::unique_ptr< QgsCurveTransform > mCurveTransform;
#endif
};
 
class CORE_EXPORT QgsGenericNumericTransformer : public QgsPropertyTransformer
{
  public:
 
    QgsGenericNumericTransformer( double minValue = 0.0,
                                  double maxValue = 1.0,
                                  double minOutput = 0.0,
                                  double maxOutput = 1.0,
                                  double nullOutput = 0.0,
                                  double exponent = 1.0 );
 
    Type transformerType() const override { return GenericNumericTransformer; }
    QgsGenericNumericTransformer *clone() const override SIP_FACTORY;
    QVariant toVariant() const override;
    bool loadVariant( const QVariant &definition ) override;
    QVariant transform( const QgsExpressionContext &context, const QVariant &value ) const override;
    QString toExpression( const QString &baseExpression ) const override;
 
    static QgsGenericNumericTransformer *fromExpression( const QString &expression, QString &baseExpression SIP_OUT, QString &fieldName SIP_OUT ) SIP_FACTORY; // cppcheck-suppress duplInheritedMember
 
    double value( double input ) const;
 
    double minOutputValue() const { return mMinOutput; }
 
    void setMinOutputValue( double size ) { mMinOutput = size; }
 
    double maxOutputValue() const { return mMaxOutput; }
 
    void setMaxOutputValue( double size ) { mMaxOutput = size; }
 
    double nullOutputValue() const { return mNullOutput; }
 
    void setNullOutputValue( double size ) { mNullOutput = size; }
 
    double exponent() const { return mExponent; }
 
    void setExponent( double exponent ) { mExponent = exponent; }
 
  private:
    double mMinOutput;
    double mMaxOutput;
    double mNullOutput;
    double mExponent;
 
};
 
class CORE_EXPORT QgsSizeScaleTransformer : public QgsPropertyTransformer
{
  public:
 
    enum ScaleType
    {
      Linear, 
      Area, 
      Flannery, 
      Exponential, 
    };
 
    QgsSizeScaleTransformer( ScaleType type = Linear,
                             double minValue = 0.0,
                             double maxValue = 1.0,
                             double minSize = 0.0,
                             double maxSize = 1.0,
                             double nullSize = 0.0,
                             double exponent = 1.0 );
 
    Type transformerType() const override { return SizeScaleTransformer; }
    QgsSizeScaleTransformer *clone() const override SIP_FACTORY;
    QVariant toVariant() const override;
    bool loadVariant( const QVariant &definition ) override;
    QVariant transform( const QgsExpressionContext &context, const QVariant &value ) const override;
    QString toExpression( const QString &baseExpression ) const override;
 
    static QgsSizeScaleTransformer *fromExpression( const QString &expression, QString &baseExpression SIP_OUT, QString &fieldName SIP_OUT ) SIP_FACTORY; // cppcheck-suppress duplInheritedMember
 
    double size( double value ) const;
 
    double minSize() const { return mMinSize; }
 
    void setMinSize( double size ) { mMinSize = size; }
 
    double maxSize() const { return mMaxSize; }
 
    void setMaxSize( double size ) { mMaxSize = size; }
 
    double nullSize() const { return mNullSize; }
 
    void setNullSize( double size ) { mNullSize = size; }
 
    double exponent() const { return mExponent; }
 
    void setExponent( double exponent ) { mExponent = exponent; }
 
    ScaleType type() const { return mType; }
 
    void setType( ScaleType type );
 
  private:
    ScaleType mType = Linear;
    double mMinSize;
    double mMaxSize;
    double mNullSize;
    double mExponent;
 
};
 
class CORE_EXPORT QgsColorRampTransformer : public QgsPropertyTransformer
{
  public:
 
    QgsColorRampTransformer( double minValue = 0.0,
                             double maxValue = 1.0,
                             QgsColorRamp *ramp SIP_TRANSFER = nullptr,
                             const QColor &nullColor = QColor( 0, 0, 0, 0 ),
                             const QString &rampName = QString() );
 
    QgsColorRampTransformer( const QgsColorRampTransformer &other );
    QgsColorRampTransformer &operator=( const QgsColorRampTransformer &other );
 
    Type transformerType() const override { return ColorRampTransformer; }
    QgsColorRampTransformer *clone() const override SIP_FACTORY;
    QVariant toVariant() const override;
    bool loadVariant( const QVariant &definition ) override;
    QVariant transform( const QgsExpressionContext &context, const QVariant &value ) const override;
    QString toExpression( const QString &baseExpression ) const override;
 
    QColor color( double value ) const;
 
    QgsColorRamp *colorRamp() const;
 
    void setColorRamp( QgsColorRamp *ramp SIP_TRANSFER );
 
    QColor nullColor() const { return mNullColor; }
 
    void setNullColor( const QColor &color ) { mNullColor = color; }
 
    QString rampName() const { return mRampName; }
 
    void setRampName( const QString &name ) { mRampName = name; }
 
  private:
 
    std::unique_ptr< QgsColorRamp > mGradientRamp;
    QColor mNullColor;
    QString mRampName;
 
};
 
#endif // QGSPROPERTYTRANSFORMER_H