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"
#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 = 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 if ( dynamic_cast<QgsClassificationFixedInterval *>( sipCpp ) )
      sipType = sipType_QgsClassificationFixedInterval;
    else
      sipType = 0;
    SIP_END
#endif
 
  public:
 
    enum MethodProperty
    {
      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 QgsClassificationMethod *clone() const = 0 SIP_FACTORY;
 
    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 );
 
    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;
 
    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 ) = 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