qgscolorramp.h

Go to the documentation of this file.

/***************************************************************************
    qgscolorramp.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 QGSCOLORRAMP_H
#define QGSCOLORRAMP_H

#include "qgis_core.h"
#include <QColor>
#include <QGradient>
#include "qgis.h"
#include "qgscolorscheme.h"

class CORE_EXPORT QgsColorRamp
{

#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( sipCpp->type() == "gradient" )
      sipType = sipType_QgsGradientColorRamp;
    else if ( sipCpp->type() == "random" )
      sipType = sipType_QgsLimitedRandomColorRamp;
    else if ( sipCpp->type() == "randomcolors" )
      sipType = sipType_QgsRandomColorRamp;
    else if ( sipCpp->type() == "preset" )
      sipType = sipType_QgsPresetSchemeColorRamp;
    else if ( sipCpp->type() == "colorbrewer" )
      sipType = sipType_QgsColorBrewerColorRamp;
    else if ( sipCpp->type() == "cpt-city" )
      sipType = sipType_QgsCptCityColorRamp;
    else
      sipType = 0;
    SIP_END
#endif
  public:

    virtual ~QgsColorRamp() = default;

    virtual int count() const = 0;

    virtual double value( int index ) const = 0;

    virtual QColor color( double value ) const = 0;

    virtual QString type() const = 0;


    virtual void invert() {}

    virtual QgsColorRamp *clone() const = 0 SIP_FACTORY;

    virtual QgsStringMap properties() const = 0;
};

class CORE_EXPORT QgsGradientStop
{
  public:

    QgsGradientStop( double offset, const QColor &color )
      : offset( offset )
      , color( color )
    { }

    double offset;
    QColor color;

    bool operator==( const QgsGradientStop &other ) const
    {
      return other.color == color && qgsDoubleNear( other.offset, offset );
    }
};

typedef QList<QgsGradientStop> QgsGradientStopsList;

#define DEFAULT_GRADIENT_COLOR1 QColor(0,0,255)
#define DEFAULT_GRADIENT_COLOR2 QColor(0,255,0)

class CORE_EXPORT QgsGradientColorRamp : public QgsColorRamp
{
  public:

    QgsGradientColorRamp( const QColor &color1 = DEFAULT_GRADIENT_COLOR1,
                          const QColor &color2 = DEFAULT_GRADIENT_COLOR2,
                          bool discrete = false,
                          const QgsGradientStopsList &stops = QgsGradientStopsList() );

    static QgsColorRamp *create( const QgsStringMap &properties = QgsStringMap() ) SIP_FACTORY;

    int count() const override { return mStops.count() + 2; }
    double value( int index ) const override;
    QColor color( double value ) const override;
    QString type() const override { return QStringLiteral( "gradient" ); }
    void invert() override;
    QgsGradientColorRamp *clone() const override SIP_FACTORY;
    QgsStringMap properties() const override;

    QColor color1() const { return mColor1; }

    QColor color2() const { return mColor2; }

    void setColor1( const QColor &color ) { mColor1 = color; }

    void setColor2( const QColor &color ) { mColor2 = color; }

    bool isDiscrete() const { return mDiscrete; }

    void setDiscrete( bool discrete ) { mDiscrete = discrete; }

    void convertToDiscrete( bool discrete );

    void setStops( const QgsGradientStopsList &stops );

    QgsGradientStopsList stops() const { return mStops; }

    QgsStringMap info() const { return mInfo; }

    void setInfo( const QgsStringMap &info ) { mInfo = info; }

    void addStopsToGradient( QGradient *gradient, double opacity = 1 );

  protected:
    QColor mColor1;
    QColor mColor2;
    bool mDiscrete;
    QgsGradientStopsList mStops;
    QgsStringMap mInfo;
};

Q_DECLARE_METATYPE( QgsGradientColorRamp )

#define DEFAULT_RANDOM_COUNT   10
#define DEFAULT_RANDOM_HUE_MIN 0
#define DEFAULT_RANDOM_HUE_MAX 359
#define DEFAULT_RANDOM_VAL_MIN 200
#define DEFAULT_RANDOM_VAL_MAX 240
#define DEFAULT_RANDOM_SAT_MIN 100
#define DEFAULT_RANDOM_SAT_MAX 240

class CORE_EXPORT QgsLimitedRandomColorRamp : public QgsColorRamp
{
  public:

    QgsLimitedRandomColorRamp( int count = DEFAULT_RANDOM_COUNT,
                               int hueMin = DEFAULT_RANDOM_HUE_MIN, int hueMax = DEFAULT_RANDOM_HUE_MAX,
                               int satMin = DEFAULT_RANDOM_SAT_MIN, int satMax = DEFAULT_RANDOM_SAT_MAX,
                               int valMin = DEFAULT_RANDOM_VAL_MIN, int valMax = DEFAULT_RANDOM_VAL_MAX );

    static QgsColorRamp *create( const QgsStringMap &properties = QgsStringMap() ) SIP_FACTORY;

    double value( int index ) const override;
    QColor color( double value ) const override;
    QString type() const override { return QStringLiteral( "random" ); }
    QgsLimitedRandomColorRamp *clone() const override SIP_FACTORY;
    QgsStringMap properties() const override;
    int count() const override { return mCount; }

    static QList<QColor> randomColors( int count,
                                       int hueMax = DEFAULT_RANDOM_HUE_MAX, int hueMin = DEFAULT_RANDOM_HUE_MIN,
                                       int satMax = DEFAULT_RANDOM_SAT_MAX, int satMin = DEFAULT_RANDOM_SAT_MIN,
                                       int valMax = DEFAULT_RANDOM_VAL_MAX, int valMin = DEFAULT_RANDOM_VAL_MIN );

    void updateColors();

    int hueMin() const { return mHueMin; }

    int hueMax() const { return mHueMax; }

    int satMin() const { return mSatMin; }

    int satMax() const { return mSatMax; }

    int valMin() const { return mValMin; }

    int valMax() const { return mValMax; }

    void setCount( int val ) { mCount = val; }

    void setHueMin( int val ) { mHueMin = val; }

    void setHueMax( int val ) { mHueMax = val; }

    void setSatMin( int val ) { mSatMin = val; }

    void setSatMax( int val ) { mSatMax = val; }

    void setValMin( int val ) { mValMin = val; }

    void setValMax( int val ) { mValMax = val; }

  protected:
    int mCount;
    int mHueMin;
    int mHueMax;
    int mSatMin;
    int mSatMax;
    int mValMin;
    int mValMax;
    QList<QColor> mColors;
};

class CORE_EXPORT QgsRandomColorRamp: public QgsColorRamp
{
  public:

    QgsRandomColorRamp() = default;

    int count() const override;

    double value( int index ) const override;

    QColor color( double value ) const override;

    virtual void setTotalColorCount( int colorCount );

    QString type() const override;

    QgsRandomColorRamp *clone() const override SIP_FACTORY;

    QgsStringMap properties() const override;

  protected:

    int mTotalColorCount = 0;
    QList<QColor> mPrecalculatedColors;

};


class CORE_EXPORT QgsPresetSchemeColorRamp : public QgsColorRamp, public QgsColorScheme
{
  public:

    QgsPresetSchemeColorRamp( const QList< QColor > &colors = QList< QColor >() );

    QgsPresetSchemeColorRamp( const QgsNamedColorList &colors );

    static QgsColorRamp *create( const QgsStringMap &properties = QgsStringMap() ) SIP_FACTORY;

    bool setColors( const QgsNamedColorList &colors, const QString & = QString(), const QColor & = QColor() ) override { mColors = colors; return true; }

    QList< QColor > colors() const;

    double value( int index ) const override;
    QColor color( double value ) const override;
    QString type() const override { return QStringLiteral( "preset" ); }
    void invert() override;
    QgsPresetSchemeColorRamp *clone() const override SIP_FACTORY;
    QgsStringMap properties() const override;
    int count() const override;

    QString schemeName() const override { return QStringLiteral( "preset" ); }
    QgsNamedColorList fetchColors( const QString &context = QString(), const QColor &baseColor = QColor() ) override;
    bool isEditable() const override { return true; }

  private:

    QgsNamedColorList mColors;
};


#define DEFAULT_COLORBREWER_SCHEMENAME "Spectral"
#define DEFAULT_COLORBREWER_COLORS     5

class CORE_EXPORT QgsColorBrewerColorRamp : public QgsColorRamp
{
  public:

    QgsColorBrewerColorRamp( const QString &schemeName = DEFAULT_COLORBREWER_SCHEMENAME,
                             int colors = DEFAULT_COLORBREWER_COLORS,
                             bool inverted = false );

    static QgsColorRamp *create( const QgsStringMap &properties = QgsStringMap() ) SIP_FACTORY;

    double value( int index ) const override;
    QColor color( double value ) const override;
    QString type() const override { return QStringLiteral( "colorbrewer" ); }
    void invert() override;
    QgsColorBrewerColorRamp *clone() const override SIP_FACTORY;
    QgsStringMap properties() const override;
    int count() const override { return mColors; }

    QString schemeName() const { return mSchemeName; }

    int colors() const { return mColors; }

    void setSchemeName( const QString &schemeName ) { mSchemeName = schemeName; loadPalette(); }

    void setColors( int colors ) { mColors = colors; loadPalette(); }

    static QStringList listSchemeNames();

    static QList<int> listSchemeVariants( const QString &schemeName );

  protected:

    void loadPalette();

    QString mSchemeName;
    int mColors;
    QList<QColor> mPalette;
    bool mInverted;
};


#define DEFAULT_CPTCITY_SCHEMENAME "cb/div/BrBG_" //change this
#define DEFAULT_CPTCITY_VARIANTNAME "05"

class CORE_EXPORT QgsCptCityColorRamp : public QgsGradientColorRamp
{
  public:

    QgsCptCityColorRamp( const QString &schemeName = DEFAULT_CPTCITY_SCHEMENAME,
                         const QString &variantName = DEFAULT_CPTCITY_VARIANTNAME,
                         bool inverted = false,
                         bool doLoadFile = true );

    QgsCptCityColorRamp( const QString &schemeName, const QStringList &variantList,
                         const QString &variantName = QString(), bool inverted = false,
                         bool doLoadFile = true );

    static QgsColorRamp *create( const QgsStringMap &properties = QgsStringMap() ) SIP_FACTORY;

    QString type() const override { return QStringLiteral( "cpt-city" ); }

    void invert() override;

    QgsCptCityColorRamp *clone() const override SIP_FACTORY;
    void copy( const QgsCptCityColorRamp *other );
    QgsGradientColorRamp *cloneGradientRamp() const SIP_FACTORY;

    QgsStringMap properties() const override;

    QString schemeName() const { return mSchemeName; }
    QString variantName() const { return mVariantName; }
    QStringList variantList() const { return mVariantList; }

    // lazy loading - have to call loadPalette() explicitly
    void setSchemeName( const QString &schemeName ) { mSchemeName = schemeName; mFileLoaded = false; }
    void setVariantName( const QString &variantName ) { mVariantName = variantName; mFileLoaded = false; }
    void setVariantList( const QStringList &variantList ) { mVariantList = variantList; }
    void setName( const QString &schemeName, const QString &variantName = QString(), const QStringList &variantList = QStringList() )
    { mSchemeName = schemeName; mVariantName = variantName; mVariantList = variantList; mFileLoaded = false; }

    void loadPalette() { loadFile(); }
    bool hasMultiStops() const { return mMultiStops; }

    QString fileName() const;
    bool loadFile();
    bool fileLoaded() const { return mFileLoaded; }

    QString copyingFileName() const;
    QString descFileName() const;
    QgsStringMap copyingInfo() const;

  protected:
    QString mSchemeName;
    QString mVariantName;
    QStringList mVariantList;
    bool mFileLoaded = false;
    bool mMultiStops = false;
    bool mInverted;

};

// clazy:excludeall=qstring-allocations

#endif