qgslabelingengine.h

Go to the documentation of this file.

/***************************************************************************
  qgslabelingengine.h
  --------------------------------------
  Date                 : September 2015
  Copyright            : (C) 2015 by Martin Dobias
  Email                : wonder dot sk at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   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 QGSLABELINGENGINE_H
#define QGSLABELINGENGINE_H
 
#include "qgis_core.h"
#include "qgsmapsettings.h"
 
#include "qgsfeedback.h"
#include "qgslabelobstaclesettings.h"
 
class QgsLabelingEngine;
class QgsLabelingResults;
class QgsLabelFeature;
class QgsLabelingEngineSettings;
 
#ifndef SIP_RUN
namespace pal
{
  class Problem;
  class Pal;
  class LabelPosition;
}
#endif
 
class CORE_EXPORT QgsLabelCandidate
{
  public:
    QgsLabelCandidate( const QRectF &r, double c ): rect( r ), cost( c ) {}
 
    QRectF rect;
    double cost;
};
class CORE_EXPORT QgsLabelCandidate {…};
 
 
#ifndef SIP_RUN
 
class CORE_EXPORT QgsAbstractLabelProvider
{
 
  public:
    QgsAbstractLabelProvider( QgsMapLayer *layer, const QString &providerId = QString() );
 
    virtual ~QgsAbstractLabelProvider() = default;
 
    void setEngine( const QgsLabelingEngine *engine ) { mEngine = engine; }
 
    enum Flag
    {
      DrawLabels              = 1 << 1,  
      MergeConnectedLines     = 1 << 3,  
      CentroidMustBeInside    = 1 << 4,  
    };
    enum Flag {…};
    Q_DECLARE_FLAGS( Flags, Flag )
 
    
    virtual QList<QgsLabelFeature *> labelFeatures( QgsRenderContext &context ) = 0;
 
    virtual void drawLabel( QgsRenderContext &context, pal::LabelPosition *label ) const = 0;
 
    virtual void drawUnplacedLabel( QgsRenderContext &context, pal::LabelPosition *label ) const;
 
    virtual void drawLabelBackground( QgsRenderContext &context, pal::LabelPosition *label ) const;
 
    virtual void startRender( QgsRenderContext &context );
 
    virtual void stopRender( QgsRenderContext &context );
 
    virtual QList<QgsAbstractLabelProvider *> subProviders() { return QList<QgsAbstractLabelProvider *>(); }
 
    QString name() const { return mName; }
 
    QString layerId() const { return mLayerId; }
 
    QgsMapLayer *layer() const { return mLayer.data(); }
 
    QString providerId() const { return mProviderId; }
 
    Flags flags() const { return mFlags; }
 
    Qgis::LabelPlacement placement() const { return mPlacement; }
 
    double priority() const { return mPriority; }
 
    QgsLabelObstacleSettings::ObstacleType obstacleType() const { return mObstacleType; }
 
    Qgis::UpsideDownLabelHandling upsidedownLabels() const { return mUpsidedownLabels; }
 
    QgsExpressionContextScope *layerExpressionContextScope() const;
 
    double layerReferenceScale() const { return mLayerReferenceScale; }
 
  protected:
    const QgsLabelingEngine *mEngine = nullptr;
 
    QString mName;
    QString mLayerId;
    QgsWeakMapLayerPointer mLayer;
    QString mProviderId;
    Flags mFlags = DrawLabels;
    Qgis::LabelPlacement mPlacement = Qgis::LabelPlacement::AroundPoint;
    double mPriority = 0.5;
    QgsLabelObstacleSettings::ObstacleType mObstacleType = QgsLabelObstacleSettings::ObstacleType::PolygonBoundary;
    Qgis::UpsideDownLabelHandling mUpsidedownLabels = Qgis::UpsideDownLabelHandling::FlipUpsideDownLabels;
 
  private:
 
    std::unique_ptr< QgsExpressionContextScope > mLayerExpressionContextScope;
    double mLayerReferenceScale = -1;
};
class CORE_EXPORT QgsAbstractLabelProvider {…};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsAbstractLabelProvider::Flags )
 
 
 
class CORE_EXPORT QgsLabelingEngineFeedback : public QgsFeedback
{
    Q_OBJECT
 
  public:
 
    QgsLabelingEngineFeedback( QObject *parent SIP_TRANSFERTHIS = nullptr )
      : QgsFeedback( parent )
    {}
    QgsLabelingEngineFeedback( QObject *parent SIP_TRANSFERTHIS = nullptr ) {…}
 
  signals:
 
    void labelRegistrationAboutToBegin();
 
    void labelRegistrationFinished();
 
    void providerRegistrationAboutToBegin( QgsAbstractLabelProvider *provider );
 
    void providerRegistrationFinished( QgsAbstractLabelProvider *provider );
 
    void candidateCreationAboutToBegin( QgsAbstractLabelProvider *provider );
 
    void candidateCreationFinished( QgsAbstractLabelProvider *provider );
 
    void obstacleCostingAboutToBegin();
 
    void obstacleCostingFinished();
 
    void calculatingConflictsAboutToBegin();
 
    void calculatingConflictsFinished();
 
    void finalizingCandidatesAboutToBegin();
 
    void finalizingCandidatesFinished();
 
    void reductionAboutToBegin();
 
    void reductionFinished();
 
    void solvingPlacementAboutToBegin();
 
    void solvingPlacementFinished();
};
class CORE_EXPORT QgsLabelingEngineFeedback : public QgsFeedback {…};
 
class CORE_EXPORT QgsLabelingEngine
{
  public:
    QgsLabelingEngine();
    virtual ~QgsLabelingEngine();
 
    QgsLabelingEngine( const QgsLabelingEngine &rh ) = delete;
    QgsLabelingEngine &operator=( const QgsLabelingEngine &rh ) = delete;
 
    void setMapSettings( const QgsMapSettings &mapSettings );
    const QgsMapSettings &mapSettings() const { return mMapSettings; }
 
    const QgsLabelingEngineSettings &engineSettings() const { return mMapSettings.labelingEngineSettings(); }
 
    bool prepare( QgsRenderContext &context );
 
    QList< QgsMapLayer * > participatingLayers() const;
 
    QStringList participatingLayerIds() const;
 
    QString addProvider( QgsAbstractLabelProvider *provider );
 
    QgsAbstractLabelProvider *providerById( const QString &id );
 
    void removeProvider( QgsAbstractLabelProvider *provider );
 
    virtual void run( QgsRenderContext &context ) = 0;
 
    QgsLabelingResults *takeResults();
 
    QgsLabelingResults *results() const { return mResults.get(); }
 
    static void drawLabelCandidateRect( pal::LabelPosition *lp, QgsRenderContext &context, const QgsMapToPixel *xform, QList<QgsLabelCandidate> *candidates = nullptr );
 
    static void drawLabelMetrics( pal::LabelPosition *label, const QgsMapToPixel &xform, QgsRenderContext &context, const QPointF &renderPoint );
 
  protected:
    void processProvider( QgsAbstractLabelProvider *provider, QgsRenderContext &context, pal::Pal &p );
 
  protected:
 
    void registerLabels( QgsRenderContext &context );
 
    void solve( QgsRenderContext &context );
 
    void drawLabels( QgsRenderContext &context, const QString &layerId = QString() );
 
    void cleanup();
 
    QgsMapSettings mMapSettings;
 
    QList<QgsAbstractLabelProvider *> mProviders;
    QHash<QString, QgsAbstractLabelProvider *> mProvidersById;
    QList<QgsAbstractLabelProvider *> mSubProviders;
 
    std::vector< std::unique_ptr< QgsAbstractLabelingEngineRule > > mEngineRules;
 
    std::unique_ptr< QgsLabelingResults > mResults;
 
    std::unique_ptr< pal::Pal > mPal;
    std::unique_ptr< pal::Problem > mProblem;
    QList<pal::LabelPosition *> mUnlabeled;
    QList<pal::LabelPosition *> mLabels;
 
  private:
 
    QStringList mLayerRenderingOrderIds;
 
};
class CORE_EXPORT QgsLabelingEngine {…};
 
class CORE_EXPORT QgsDefaultLabelingEngine : public QgsLabelingEngine
{
  public:
    QgsDefaultLabelingEngine();
 
    QgsDefaultLabelingEngine( const QgsDefaultLabelingEngine &rh ) = delete;
    QgsDefaultLabelingEngine &operator=( const QgsDefaultLabelingEngine &rh ) = delete;
 
    void run( QgsRenderContext &context ) override;
 
};
class CORE_EXPORT QgsDefaultLabelingEngine : public QgsLabelingEngine {…};
 
class CORE_EXPORT QgsStagedRenderLabelingEngine : public QgsLabelingEngine
{
  public:
    QgsStagedRenderLabelingEngine();
 
    QgsStagedRenderLabelingEngine( const QgsStagedRenderLabelingEngine &rh ) = delete;
    QgsStagedRenderLabelingEngine &operator=( const QgsStagedRenderLabelingEngine &rh ) = delete;
 
    void run( QgsRenderContext &context ) override;
 
    void renderLabelsForLayer( QgsRenderContext &context, const QString &layerId );
 
    void finalize();
};
class CORE_EXPORT QgsStagedRenderLabelingEngine : public QgsLabelingEngine {…};
 
 
class CORE_EXPORT QgsLabelingUtils
{
  public:
 
    static QString encodePredefinedPositionOrder( const QVector< Qgis::LabelPredefinedPointPosition > &positions );
 
    static QVector< Qgis::LabelPredefinedPointPosition > decodePredefinedPositionOrder( const QString &positionString );
 
    static QString encodeLinePlacementFlags( Qgis::LabelLinePlacementFlags flags );
 
    static Qgis::LabelLinePlacementFlags decodeLinePlacementFlags( const QString &string );
 
};
class CORE_EXPORT QgsLabelingUtils {…};
 
#endif
 
#endif // QGSLABELINGENGINE_H