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 "qgsfeedback.h"
#include "qgslabelobstaclesettings.h"
#include "qgsmapsettings.h"
 
class QgsLabelingEngine;
class QgsLabelingResults;
class QgsLabelFeature;
class QgsLabelingEngineSettings;
 
#ifndef SIP_RUN
namespace pal
{
  class Problem;
  class Pal;
  class LabelPosition;
} //namespace pal
#endif

class CORE_EXPORT QgsLabelCandidate
{
  public:
    QgsLabelCandidate( const QRectF &r, double c )
      : rect( r )
      , cost( c )
    {}
 
    QRectF rect;
    double cost;
};
 
 
#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, 
    };
    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;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsAbstractLabelProvider::Flags )
 
 

class CORE_EXPORT QgsLabelingEngineFeedback : public QgsFeedback
{
    Q_OBJECT
 
  public:
    QgsLabelingEngineFeedback( QObject *parent SIP_TRANSFERTHIS = nullptr )
      : QgsFeedback( parent )
    {}
 
  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 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 QgsDefaultLabelingEngine : public QgsLabelingEngine
{
  public:
    QgsDefaultLabelingEngine();
 
    QgsDefaultLabelingEngine( const QgsDefaultLabelingEngine &rh ) = delete;
    QgsDefaultLabelingEngine &operator=( const QgsDefaultLabelingEngine &rh ) = delete;
 
    void run( QgsRenderContext &context ) override;
};

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 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 );
};
 
#endif
 
#endif // QGSLABELINGENGINE_H