qgscolorrampshader.h

Go to the documentation of this file.

/* **************************************************************************
                qgscolorrampshader.h -  description
                       -------------------
begin                : Fri Dec 28 2007
copyright            : (C) 2007 by Peter J. Ersts
email                : [email protected]
 
This class is based off of code that was originally written by Marco Hugentobler and
originally part of the larger QgsRasterLayer class
****************************************************************************/
 
/* **************************************************************************
 *                                                                         *
 *   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 QGSCOLORRAMPSHADER_H
#define QGSCOLORRAMPSHADER_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include <QColor>
#include <QVector>
#include <memory>
 
#include "qgsrastershaderfunction.h"
#include "qgsrectangle.h"
#include "qgsreadwritecontext.h"
#include "qgscolorramplegendnodesettings.h"
 
class QgsColorRamp;
class QgsRasterInterface;
 
class CORE_EXPORT QgsColorRampShader : public QgsRasterShaderFunction
{
 
  public:
 
    enum Type
    {
      Interpolated, 
      Discrete,     
      Exact         
    };
 
    enum ClassificationMode
    {
      Continuous = 1, 
      EqualInterval = 2, 
      Quantile = 3 
    };
 
    QgsColorRampShader( double minimumValue = 0.0, double maximumValue = 255.0, QgsColorRamp *colorRamp SIP_TRANSFER = nullptr, Type type = Interpolated, ClassificationMode classificationMode = Continuous );
 
    ~QgsColorRampShader() override;
 
    QgsColorRampShader( const QgsColorRampShader &other );
 
    QgsColorRampShader &operator=( const QgsColorRampShader &other );
 
    bool operator==( const QgsColorRampShader &other ) const
    {
      if ( mColorRampItemList.count() != other.mColorRampItemList.count() ||
           mClassificationMode != other.mClassificationMode ||
           mColorRampType != other.mColorRampType )
      {
        return false;
      }
      for ( int i = 0; i < mColorRampItemList.count(); ++i )
      {
        if ( mColorRampItemList.at( i ) != other.mColorRampItemList.at( i ) ) return false;
      }
      return true;
    }
 
    //An entry for classification based upon value.
    //Such a classification is typically used for
    //single band layers where a pixel value represents
    //not a color but a quantity, e.g. temperature or elevation
    struct ColorRampItem
    {
      ColorRampItem() = default;
      ColorRampItem( double val, const QColor &col, const QString &lbl = QString() )
        : label( lbl )
        , value( val )
        , color( col )
      {}
 
      QString label;
      double value = 0;
      QColor color;
 
      // compare operator for sorting
      bool operator<( const QgsColorRampShader::ColorRampItem &other ) const { return value < other.value; }
 
      bool operator!=( const QgsColorRampShader::ColorRampItem &other ) const
      {
        return ( color != other.color ) ||
               ( !std::isnan( value ) && !std::isnan( other.value ) && value != other.value ) ||
               ( std::isnan( value ) != std::isnan( other.value ) );
      }
    };
 
    QList<QgsColorRampShader::ColorRampItem> colorRampItemList() const { return mColorRampItemList.toList(); }
 
    Type colorRampType() const { return mColorRampType; }
 
    QString colorRampTypeAsQString() const;
 
    void setColorRampItemList( const QList<QgsColorRampShader::ColorRampItem> &list ); //TODO: sort on set
 
    void setColorRampType( QgsColorRampShader::Type colorRampType );
 
    bool isEmpty() const;
 
    QgsColorRamp *sourceColorRamp() const;
 
    QgsColorRamp *createColorRamp() const SIP_FACTORY;
 
    void setSourceColorRamp( QgsColorRamp *colorramp SIP_TRANSFER );
 
    void setColorRampType( const QString &type );
 
    void classifyColorRamp( int classes = 0, int band = -1, const QgsRectangle &extent = QgsRectangle(), QgsRasterInterface *input = nullptr );
 
    void classifyColorRamp( int band = -1, const QgsRectangle &extent = QgsRectangle(), QgsRasterInterface *input = nullptr ) SIP_PYNAME( classifyColorRampV2 );
 
    bool shade( double value, int *returnRedValue SIP_OUT, int *returnGreenValue SIP_OUT, int *returnBlueValue SIP_OUT, int *returnAlphaValue SIP_OUT ) const override;
 
    bool shade( double redValue, double greenValue,
                double blueValue, double alphaValue,
                int *returnRedValue SIP_OUT, int *returnGreenValue SIP_OUT,
                int *returnBlueValue SIP_OUT, int *returnAlphaValue SIP_OUT ) const override;
 
    void legendSymbologyItems( QList< QPair< QString, QColor > > &symbolItems SIP_OUT ) const override;
 
    QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context = QgsReadWriteContext() ) const;
 
    void readXml( const QDomElement &elem, const QgsReadWriteContext &context = QgsReadWriteContext() );
 
    void setClassificationMode( ClassificationMode classificationMode ) { mClassificationMode = classificationMode; }
 
    ClassificationMode classificationMode() const { return mClassificationMode; }
 
    void setClip( bool clip ) { mClip = clip; }
 
    bool clip() const { return mClip; }
 
    const QgsColorRampLegendNodeSettings *legendSettings() const;
 
    void setLegendSettings( QgsColorRampLegendNodeSettings *settings SIP_TRANSFER );
 
  protected:
 
    std::unique_ptr<QgsColorRamp> mSourceColorRamp;
 
  private:
 
    QVector<QgsColorRampShader::ColorRampItem> mColorRampItemList;
 
    Type mColorRampType;
    ClassificationMode mClassificationMode;
 
    mutable std::vector<int> mLUT;
    mutable double mLUTOffset = 0.0;
    mutable double mLUTFactor = 1.0;
    mutable bool mLUTInitialized = false;
 
    bool mClip = false;
 
    std::unique_ptr< QgsColorRampLegendNodeSettings > mLegendSettings;
 
};
 
#endif