qgsmaprendererjob.h

Go to the documentation of this file.

/***************************************************************************
  qgsmaprendererjob.h
  --------------------------------------
  Date                 : December 2013
  Copyright            : (C) 2013 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 QGSMAPRENDERERJOB_H
#define QGSMAPRENDERERJOB_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include <QFutureWatcher>
#include <QImage>
#include <QPainter>
#include <QObject>
#include <QTime>
#include <QElapsedTimer>
#include <QPicture>
 
#include "qgsrendercontext.h"
#include "qgslabelsink.h"
#include "qgsmapsettings.h"
#include "qgsmaskidprovider.h"
#include "qgssettingsentryimpl.h"
 
class QPicture;
 
class QgsLabelingEngine;
class QgsLabelingResults;
class QgsMapLayerRenderer;
class QgsMapRendererCache;
class QgsFeatureFilterProvider;
class QgsRenderedItemResults;
 
#ifndef SIP_RUN
 
class LayerRenderJob
{
  public:
 
    LayerRenderJob() = default;
 
    LayerRenderJob( const LayerRenderJob & ) = delete;
 
    LayerRenderJob &operator=( const LayerRenderJob & ) = delete;
 
    LayerRenderJob( LayerRenderJob && );
    LayerRenderJob &operator=( LayerRenderJob && );
 
    void setContext( std::unique_ptr< QgsRenderContext > context ) { mContext = std::move( context ); }
 
    QgsRenderContext *context() { return mContext.get(); }
 
    QImage *img = nullptr;
 
    bool imageInitialized = false;
 
    bool imageCanBeComposed() const;
 
    QgsMapLayerRenderer *renderer = nullptr; // must be deleted
 
    QPainter::CompositionMode blendMode = QPainter::CompositionMode_SourceOver;
 
    double opacity = 1.0;
 
    bool cached = false;
 
    QgsWeakMapLayerPointer layer;
 
    bool completed = false;
 
    int renderingTime = -1;
 
    int estimatedRenderingTime = 0;
 
    QStringList errors; 
 
    QString layerId;
 
    std::unique_ptr<QPainter> maskPainter;
 
 
    std::unique_ptr<QPaintDevice> maskPaintDevice;
 
    bool maskRequiresLayerRasterization = false;
 
    LayerRenderJob *firstPassJob = nullptr;
 
    std::unique_ptr<QPicture> picture;
 
    QList<QPair<LayerRenderJob *, int>> maskJobs;
 
  private:
    std::unique_ptr< QgsRenderContext > mContext;
 
};
 
struct LabelRenderJob
{
  QgsRenderContext context;
 
  QImage *img = nullptr;
 
  std::unique_ptr<QPicture> picture;
 
  std::vector< std::unique_ptr<QPainter> > maskPainters;
 
  std::vector< std::unique_ptr<QPaintDevice> > maskPaintDevices;
 
  QgsMaskIdProvider maskIdProvider;
 
  bool cached = false;
  bool canUseCache = false;
  bool complete = false;
  int renderingTime = -1;
  QList< QPointer< QgsMapLayer > > participatingLayers;
};
 
#endif
 
class CORE_EXPORT QgsMapRendererJob : public QObject SIP_ABSTRACT
{
    Q_OBJECT
  public:
 
    QgsMapRendererJob( const QgsMapSettings &settings );
 
    ~QgsMapRendererJob() override;
 
    void start();
 
    virtual void cancel() = 0;
 
    virtual void cancelWithoutBlocking() = 0;
 
    virtual void waitForFinished() = 0;
 
    virtual bool isActive() const = 0;
 
    virtual bool usedCachedLabels() const = 0;
 
    QStringList layersRedrawnFromCache() const;
 
    virtual QgsLabelingResults *takeLabelingResults() = 0 SIP_TRANSFER;
 
    QgsRenderedItemResults *takeRenderedItemResults() SIP_TRANSFER;
 
    void setFeatureFilterProvider( const QgsFeatureFilterProvider *f ) { mFeatureFilterProvider = f; }
 
    const QgsFeatureFilterProvider *featureFilterProvider() const { return mFeatureFilterProvider; }
 
    struct Error
    {
      Error( const QString &lid, const QString &msg )
        : layerID( lid )
        , message( msg )
      {}
 
      QString layerID;
      QString message;
    };
 
    typedef QList<QgsMapRendererJob::Error> Errors;
 
    Errors errors() const;
 
 
    void setCache( QgsMapRendererCache *cache );
 
    QgsLabelSink *labelSink() const { return mLabelSink; } SIP_SKIP
 
    void setLabelSink( QgsLabelSink *sink ) { mLabelSink = sink; } SIP_SKIP
 
    QgsLabelingEngineFeedback *labelingEngineFeedback() SIP_SKIP;
 
    int renderingTime() const { return mRenderingTime; }
 
    QHash< QgsMapLayer *, int > perLayerRenderingTime() const SIP_SKIP;
 
    void setLayerRenderingTimeHints( const QHash< QString, int > &hints ) SIP_SKIP;
 
    const QgsMapSettings &mapSettings() const;
 
    static const QString LABEL_CACHE_ID SIP_SKIP;
 
    static const QString LABEL_PREVIEW_CACHE_ID SIP_SKIP;
 
#ifndef SIP_RUN
    static const inline QgsSettingsEntryBool settingsLogCanvasRefreshEvent = QgsSettingsEntryBool( QStringLiteral( "logCanvasRefreshEvent" ), QgsSettings::Prefix::MAP, false );
#endif
 
  signals:
 
    void renderingLayersFinished();
 
 
    void layerRenderingStarted( const QString &layerId );
 
    void layerRendered( const QString &layerId );
 
    void finished();
 
  protected:
 
    QgsMapSettings mSettings;
    QElapsedTimer mRenderingStart;
    Errors mErrors;
 
    QgsMapRendererCache *mCache = nullptr;
 
    int mRenderingTime = 0;
 
    QHash< QgsWeakMapLayerPointer, int > mPerLayerRenderingTime;
 
    QHash< QString, int > mLayerRenderingTimeHints;
 
    bool mRecordRenderingTime = true;
 
#ifndef SIP_RUN
    std::unique_ptr< QgsRenderedItemResults > mRenderedItemResults;
#endif
 
    QStringList mLayersRedrawnFromCache;
 
    bool prepareLabelCache() const SIP_SKIP;
 
    std::vector< LayerRenderJob > prepareJobs( QPainter *painter, QgsLabelingEngine *labelingEngine2, bool deferredPainterSet = false ) SIP_SKIP;
 
    LabelRenderJob prepareLabelingJob( QPainter *painter, QgsLabelingEngine *labelingEngine2, bool canUseLabelCache = true ) SIP_SKIP;
 
    std::vector< LayerRenderJob > prepareSecondPassJobs( std::vector< LayerRenderJob > &firstPassJobs, LabelRenderJob &labelJob ) SIP_SKIP;
 
    void initSecondPassJobs( std::vector< LayerRenderJob > &secondPassJobs, LabelRenderJob &labelJob ) const SIP_SKIP;
 
    static QImage composeImage( const QgsMapSettings &settings,
                                const std::vector< LayerRenderJob > &jobs,
                                const LabelRenderJob &labelJob,
                                const QgsMapRendererCache *cache = nullptr ) SIP_SKIP;
 
    static QImage layerImageToBeComposed( const QgsMapSettings &settings, const LayerRenderJob &job, const QgsMapRendererCache *cache ) SIP_SKIP;
 
    static void composeSecondPass( std::vector< LayerRenderJob > &secondPassJobs, LabelRenderJob &labelJob, bool forceVector = false ) SIP_SKIP;
 
    void logRenderingTime( const std::vector< LayerRenderJob > &jobs, const std::vector< LayerRenderJob > &secondPassJobs, const LabelRenderJob &labelJob ) SIP_SKIP;
 
    void cleanupJobs( std::vector< LayerRenderJob > &jobs ) SIP_SKIP;
 
    void cleanupSecondPassJobs( std::vector< LayerRenderJob > &jobs ) SIP_SKIP;
 
    void cleanupLabelJob( LabelRenderJob &job ) SIP_SKIP;
 
    Q_DECL_DEPRECATED static void drawLabeling( const QgsMapSettings &settings, QgsRenderContext &renderContext, QgsLabelingEngine *labelingEngine2, QPainter *painter ) SIP_SKIP;
 
    static void drawLabeling( QgsRenderContext &renderContext, QgsLabelingEngine *labelingEngine2, QPainter *painter ) SIP_SKIP;
 
  private:
 
    static bool reprojectToLayerExtent( const QgsMapLayer *ml, const QgsCoordinateTransform &ct, QgsRectangle &extent, QgsRectangle &r2 );
 
    const QgsFeatureFilterProvider *mFeatureFilterProvider = nullptr;
 
    QImage *allocateImage( QString layerId );
 
    QPainter *allocateImageAndPainter( QString layerId, QImage *&image, const QgsRenderContext *context );
 
    virtual void startPrivate() = 0;
 
    QgsLabelSink *mLabelSink = nullptr;
    QgsLabelingEngineFeedback *mLabelingEngineFeedback = nullptr;
 
    typedef std::pair<std::unique_ptr<QPicture>, QPainter * > PictureAndPainter;
 
    PictureAndPainter allocatePictureAndPainter( const QgsRenderContext *context );
};
 
 
class CORE_EXPORT QgsMapRendererQImageJob : public QgsMapRendererJob SIP_ABSTRACT
{
    Q_OBJECT
 
  public:
    QgsMapRendererQImageJob( const QgsMapSettings &settings );
 
    virtual QImage renderedImage() = 0;
 
};
 
 
#endif // QGSMAPRENDERERJOB_H