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>
#include <QString>
 
using namespace Qt::StringLiterals;
 
#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 u"gradient"_s; }
 
    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 u"random"_s; }
 
    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 u"randomcolors"_s; }
 
    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 u"preset"_s; }
 
    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 u"preset"_s; }
    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 u"colorbrewer"_s; }
 
    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 u"cpt-city"_s; } // 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