qgsclassificationmethod.h

Go to the documentation of this file.

/***************************************************************************
    qgsclassificationmethod.h
    ---------------------
    begin                : September 2019
    copyright            : (C) 2019 by Denis Rouzaud
    email                : [email protected]
 ***************************************************************************
 *                                                                         *
 *   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 QGSCLASSIFICATIONMETHOD_H
#define QGSCLASSIFICATIONMETHOD_H

#include <QIcon>

#include "qgis_sip.h"
#include "qgis_core.h"
#include "qgsprocessingparameters.h"

class QgsVectorLayer;
class QgsRendererRange;


#ifdef SIP_RUN
// This is required for the ConvertToSubClassCode to work properly
// so RTTI for casting is available in the whole module.
% ModuleCode
#include "qgsclassificationequalinterval.h"
#include "qgsclassificationjenks.h"
#include "qgsclassificationprettybreaks.h"
#include "qgsclassificationquantile.h"
#include "qgsclassificationstandarddeviation.h"
% End
#endif



class CORE_EXPORT QgsClassificationRange
{
  public:
    QgsClassificationRange( const QString &label, double lowerBound, double upperBound )
      : mLabel( label )
      , mLowerBound( lowerBound )
      , mUpperBound( upperBound )
    {}
    double lowerBound() const {return mLowerBound;}
    double upperBound() const {return mUpperBound;}

    QString label() const {return mLabel;}

#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsClassificationRange: '%1'>" ).arg( sipCpp->label() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif

  private:
    QString mLabel;
    double mLowerBound;
    double mUpperBound;
};



class CORE_EXPORT QgsClassificationMethod SIP_ABSTRACT
{

#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
    if ( dynamic_cast<QgsClassificationEqualInterval *>( sipCpp ) )
      sipType = sipType_QgsClassificationEqualInterval;
    else if ( dynamic_cast<QgsClassificationJenks *>( sipCpp ) )
      sipType = sipType_QgsClassificationJenks;
    else if ( dynamic_cast<QgsClassificationPrettyBreaks *>( sipCpp ) )
      sipType = sipType_QgsClassificationPrettyBreaks;
    else if ( dynamic_cast<QgsClassificationQuantile *>( sipCpp ) )
      sipType = sipType_QgsClassificationQuantile;
    else if ( dynamic_cast<QgsClassificationStandardDeviation *>( sipCpp ) )
      sipType = sipType_QgsClassificationStandardDeviation;
    else
      sipType = 0;
    SIP_END
#endif

  public:

    enum MethodProperty
    {
      NoFlag                 = 0,       
      ValuesNotRequired      = 1 << 1,  
      SymmetricModeAvailable = 1 << 2,  
    };
    Q_DECLARE_FLAGS( MethodProperties, MethodProperty )


    
    enum ClassPosition
    {
      LowerBound, 
      Inner,      
      UpperBound  
    };

    explicit QgsClassificationMethod( MethodProperties properties = NoFlag, int codeComplexity = 1 );

    virtual ~QgsClassificationMethod() = default;

    virtual QgsClassificationMethod *clone() const = 0 SIP_FACTORY;

    virtual QString name() const = 0;

    virtual QString id() const = 0;

    virtual QIcon icon() const {return QIcon();}

    virtual QString labelForRange( double lowerValue, double upperValue, ClassPosition position = Inner ) const;


    virtual void writeXml( QDomElement &element, const QgsReadWriteContext &context ) const {Q_UNUSED( element ); Q_UNUSED( context )}
    virtual void readXml( const QDomElement &element, const QgsReadWriteContext &context ) {Q_UNUSED( element ); Q_UNUSED( context )}

    // *******************
    // non-virtual methods

    bool valuesRequired() const {return !mFlags.testFlag( ValuesNotRequired );}

    int codeComplexity() const {return mCodeComplexity;}

    bool symmetricModeAvailable() const {return mFlags.testFlag( SymmetricModeAvailable );}

    bool symmetricModeEnabled() const {return symmetricModeAvailable() && mSymmetricEnabled;}

    double symmetryPoint() const {return mSymmetryPoint;}

    bool symmetryAstride() const {return mSymmetryAstride;}

    void setSymmetricMode( bool enabled, double symmetryPoint = 0, bool symmetryAstride = false );

    // Label properties
    QString labelFormat() const { return mLabelFormat; }
    void setLabelFormat( const QString &format ) { mLabelFormat = format; }
    int labelPrecision() const { return mLabelPrecision; }
    void setLabelPrecision( int labelPrecision );
    bool labelTrimTrailingZeroes() const { return mLabelTrimTrailingZeroes; }
    void setLabelTrimTrailingZeroes( bool trimTrailingZeroes ) { mLabelTrimTrailingZeroes = trimTrailingZeroes; }

    static QList<double> rangesToBreaks( const QList<QgsClassificationRange> &classes );

    QList<QgsClassificationRange> classes( const QgsVectorLayer *layer, const QString &expression, int nclasses );

    QList<QgsClassificationRange> classes( const QList<double> &values, int nclasses );

    QList<QgsClassificationRange> classes( double minimum, double maximum, int nclasses );

    QDomElement save( QDomDocument &doc, const QgsReadWriteContext &context ) const;

    static QgsClassificationMethod *create( const QDomElement &element, const QgsReadWriteContext &context ) SIP_FACTORY;

    static void makeBreaksSymmetric( QList<double> &breaks SIP_INOUT, double symmetryPoint, bool astride );

    QString labelForRange( const QgsRendererRange &range, ClassPosition position = Inner ) const;



    static const int MAX_PRECISION;
    static const int MIN_PRECISION;

  protected:

    void copyBase( QgsClassificationMethod *c ) const;

    QString formatNumber( double value ) const;

  private:

    virtual QList<double> calculateBreaks( double minimum, double maximum,
                                           const QList<double> &values, int nclasses ) = 0;

    virtual QString valueToLabel( double value ) const {return formatNumber( value );}


    QList<QgsClassificationRange> breaksToClasses( const QList<double> &breaks ) const;

    // implementation properties (set by initialization)
    MethodProperties mFlags = nullptr;
    int mCodeComplexity = 1;

    // parameters (set by setters)
    // if some are added here, they should be handled in the clone method
    bool mSymmetricEnabled = false;
    double mSymmetryPoint = 0;
    bool mSymmetryAstride = false;
    int mLabelPrecision = 4;
    bool mLabelTrimTrailingZeroes = true;
    QString mLabelFormat;


    // values used to manage number formatting - precision and trailing zeroes
    double mLabelNumberScale = 1.0;
    QString mLabelNumberSuffix;
};

Q_DECLARE_OPERATORS_FOR_FLAGS( QgsClassificationMethod::MethodProperties )

#endif // QGSCLASSIFICATIONMETHOD_H