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 "qgis_core.h"
#include "qgis_sip.h"
#include "qgsprocessingparameters.h"
 
#include <QIcon>
#include <QString>
 
using namespace Qt::StringLiterals;
 
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"
#include "qgsclassificationfixedinterval.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 = u"<QgsClassificationRange: '%1'>"_s.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 if ( dynamic_cast<QgsClassificationFixedInterval *>( sipCpp ) )
      sipType = sipType_QgsClassificationFixedInterval;
    else
      sipType = 0;
    SIP_END
#endif
 
  public:

    enum MethodProperty SIP_ENUM_BASETYPE( IntFlag )
    {
      NoFlag                 = 0,       
      ValuesNotRequired      = 1 << 1,  
      SymmetricModeAvailable = 1 << 2,  
      IgnoresClassCount      = 1 << 3,  
    };
    Q_DECLARE_FLAGS( MethodProperties, MethodProperty )
 
 
    
    enum ClassPosition
    {
      LowerBound, 
      Inner,      
      UpperBound  
    };

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

    virtual std::unique_ptr< QgsClassificationMethod > clone() const = 0;

    virtual QString name() const = 0;

    virtual QString id() const = 0;

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

    QgsClassificationMethod::MethodProperties flags() const { return mFlags; }

    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 )}

    virtual bool valuesRequired() const {return true;}
 
 
    // *******************
    // non-virtual methods

    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 );

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

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

    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 std::unique_ptr< QgsClassificationMethod > create( const QDomElement &element, const QgsReadWriteContext &context );

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

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

    const QgsProcessingParameterDefinition *parameterDefinition( const QString &parameterName ) const;

    QgsProcessingParameterDefinitions parameterDefinitions() const {return mParameters;}

    void setParameterValues( const QVariantMap &values );

    QVariantMap parameterValues() const {return mParameterValues;}
 
    static const int MAX_PRECISION;
    static const int MIN_PRECISION;
 
  protected:

    void copyBase( QgsClassificationMethod *c ) const;

    QString formatNumber( double value ) const;

    void addParameter( QgsProcessingParameterDefinition *definition SIP_TRANSFER );
 
  private:

    virtual QList<double> calculateBreaks( double &minimum, double &maximum,
                                           const QList<double> &values, int nclasses, QString &error ) = 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 = MethodProperties();
    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;

    QgsProcessingParameterDefinitions mParameters;
    QVariantMap mParameterValues;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsClassificationMethod::MethodProperties )
 
#endif // QGSCLASSIFICATIONMETHOD_H