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() = default;

    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;

    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;

    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 ) );

    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