qgscolorrampimpl.h

Go to the documentation of this file.

/***************************************************************************
    qgscolorrampimpl.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 QGSCOLORRAMPIMPL_H
#define QGSCOLORRAMPIMPL_H
 
#include "qgis.h"
#include "qgis_core.h"
#include "qgscolorramp.h"
#include "qgscolorscheme.h"
 
#include <QColor>
#include <QGradient>
 
#ifndef SIP_RUN
typedef QColor( *InterpolateColorFunc )( const QColor &c1, const QColor &c2, const double value, Qgis::AngularDirection direction );
#endif

class CORE_EXPORT QgsGradientStop
{
  public:

    QgsGradientStop( double offset, const QColor &color );

    double offset;
    QColor color;
 
    bool operator==( const QgsGradientStop &other ) const
    {
      return other.color == color && qgsDoubleNear( other.offset, offset ) && other.mColorSpec == mColorSpec && other.mDirection == mDirection;
    }
 
    bool operator!=( const QgsGradientStop &other ) const
    {
      return !( *this == other );
    }

    QColor::Spec colorSpec() const { return mColorSpec; }

    void setColorSpec( QColor::Spec spec );

    Qgis::AngularDirection direction() const { return mDirection; }

    void setDirection( Qgis::AngularDirection direction ) { mDirection = direction; }
 
  private:
 
    QColor::Spec mColorSpec = QColor::Spec::Rgb;
    Qgis::AngularDirection mDirection = Qgis::AngularDirection::CounterClockwise;
    InterpolateColorFunc mFunc = nullptr;
 
    friend class QgsGradientColorRamp;
};

typedef QList<QgsGradientStop> QgsGradientStopsList;
 
// these are the QGIS branding colors, exaggerated a bit to make a default ramp with greater color variation
// then the official QGIS color gradient!
#define DEFAULT_GRADIENT_COLOR1 QColor(69, 116, 40)
#define DEFAULT_GRADIENT_COLOR2 QColor(188, 220, 60)

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 QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
 
    int count() const override { return mStops.count() + 2; }
    double value( int index ) const override;
    QColor color( double value ) const override;

    static QString typeString() { return QStringLiteral( "gradient" ); }
 
    QString type() const override;
    void invert() override;
    QgsGradientColorRamp *clone() const override SIP_FACTORY;
    QVariantMap 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 ) const;

    QColor::Spec colorSpec() const { return mColorSpec; }

    void setColorSpec( QColor::Spec spec );

    Qgis::AngularDirection direction() const { return mDirection; }

    void setDirection( Qgis::AngularDirection direction ) { mDirection = direction; }
 
  protected:
    QColor mColor1;
    QColor mColor2;
    bool mDiscrete;
    QgsGradientStopsList mStops;
    QgsStringMap mInfo;
    QColor::Spec mColorSpec = QColor::Spec::Rgb;
    Qgis::AngularDirection mDirection = Qgis::AngularDirection::CounterClockwise;
 
    InterpolateColorFunc mFunc = nullptr;
};
 
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 QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
 
    double value( int index ) const override;
    QColor color( double value ) const override;

    static QString typeString() { return QStringLiteral( "random" ); }
 
    QString type() const override;
    QgsLimitedRandomColorRamp *clone() const override SIP_FACTORY;
    QVariantMap 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 );

    static QString typeString() { return QStringLiteral( "randomcolors" ); }
 
    QString type() const override;
 
    QgsRandomColorRamp *clone() const override SIP_FACTORY;
 
    QVariantMap 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 QVariantMap &properties = QVariantMap() ) 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;

    static QString typeString() { return QStringLiteral( "preset" ); }
 
    QString type() const override;
    void invert() override;
    QgsPresetSchemeColorRamp *clone() const override SIP_FACTORY;
    QVariantMap 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 QVariantMap &properties = QVariantMap() ) SIP_FACTORY;
 
    double value( int index ) const override;
    QColor color( double value ) const override;

    static QString typeString() { return QStringLiteral( "colorbrewer" ); }
 
    QString type() const override { return QgsColorBrewerColorRamp::typeString(); }
    void invert() override;
    QgsColorBrewerColorRamp *clone() const override SIP_FACTORY;
    QVariantMap 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 QVariantMap &properties = QVariantMap() ) SIP_FACTORY; // cppcheck-suppress duplInheritedMember

    static QString typeString() { return QStringLiteral( "cpt-city" ); } // cppcheck-suppress duplInheritedMember
 
    QString type() const override;
 
    void invert() override;
 
    QgsCptCityColorRamp *clone() const override SIP_FACTORY;
    void copy( const QgsCptCityColorRamp *other );
    QgsGradientColorRamp *cloneGradientRamp() const SIP_FACTORY;
 
    QVariantMap 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; }

    static QString fileNameForVariant( const QString &schema, const QString &variant ) SIP_SKIP;
 
    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