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_core.h"
#include <QColor>
#include <QGradient>
#include "qgis.h"
#include "qgscolorscheme.h"
#include "qgscolorramp.h"
 
#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 {…}
 
    bool operator!=( const QgsGradientStop &other ) const
    {
      return !( *this == other );
    }
    bool operator!=( const QgsGradientStop &other ) 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; }
 
  private:
 
    QColor::Spec mColorSpec = QColor::Spec::Rgb;
    Qgis::AngularDirection mDirection = Qgis::AngularDirection::CounterClockwise;
    InterpolateColorFunc mFunc = nullptr;
 
    friend class QgsGradientColorRamp;
};
class CORE_EXPORT QgsGradientStop {…};
 
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;
};
class CORE_EXPORT QgsGradientColorRamp : public QgsColorRamp {…};
 
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 QgsLimitedRandomColorRamp : public QgsColorRamp {…};
 
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 QgsRandomColorRamp: public QgsColorRamp {…};
 
 
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;
};
class CORE_EXPORT QgsPresetSchemeColorRamp : public QgsColorRamp, public QgsColorScheme {…};
 
 
#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;
};
class CORE_EXPORT QgsColorBrewerColorRamp : public QgsColorRamp {…};
 
 
#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 setName( const QString &schemeName, const QString &variantName = QString(), const QStringList &variantList = QStringList() ) {…}
 
    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;
 
};
class CORE_EXPORT QgsCptCityColorRamp : public QgsGradientColorRamp {…};
 
// clazy:excludeall=qstring-allocations
 
#endif