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
// clang-format off
// 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
// clang-format on
#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; }
 
    // clang-format off
#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:
    // clang-format on
 
    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