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 "qgslabelsink.h"
#include "qgsmapsettings.h"
#include "qgsmaskidprovider.h"
#include "qgsrange.h"
#include "qgsrendercontext.h"
 
#include <QElapsedTimer>
#include <QFutureWatcher>
#include <QImage>
#include <QObject>
#include <QPainter>
#include <QPicture>
#include <QTime>
 
class QPicture;
 
class QgsLabelingEngine;
class QgsLabelingResults;
class QgsMapLayerRenderer;
class QgsMapRendererCache;
class QgsFeatureFilterProvider;
class QgsRenderedItemResults;
class QgsElevationMap;
class QgsSettingsEntryBool;
class QgsSettingsEntryString;
 
#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(); }

    std::unique_ptr< QImage > destinationImage;
 
    std::unique_ptr< QPainter > destinationPainter;

    std::unique_ptr< QgsElevationMap > elevationMap;

    std::unique_ptr< QImage > previewRenderImage;
 
    std::unique_ptr< QPainter > previewRenderPainter;

    bool imageInitialized = false;

    bool previewRenderImageInitialized = false;
 
    bool imageCanBeComposed() const;

    std::unique_ptr< QgsMapLayerRenderer > renderer;
 
    QPainter::CompositionMode blendMode = QPainter::CompositionMode_SourceOver;
 
    double opacity = 1.0;

    bool cached = false;

    bool renderAboveLabels = false;
 
    QgsWeakMapLayerPointer layer;

    bool completed = false;

    int renderingTime = -1;

    int estimatedRenderingTime = 0;
 
    QStringList errors; 

    QString layerId;


    std::unique_ptr<QPaintDevice> maskPaintDevice;

    std::unique_ptr<QPainter> maskPainter;

    bool maskRequiresLayerRasterization = false;

    LayerRenderJob *firstPassJob = nullptr;

    std::unique_ptr<QPicture> picture;
 
    struct MaskJob
    {
        LayerRenderJob *layerRenderJob = nullptr;

        int maskPaintDeviceId = -1;
    };

    std::vector<MaskJob> maskJobs;
 
  private:
    std::unique_ptr< QgsRenderContext > mContext;
};

struct LabelRenderJob
{
    QgsRenderContext context;

    std::unique_ptr< QImage > img;

    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; }

    void setPerLayerTemporalRange( QHash<QgsMapLayer *, QgsDateTimeRange> perLayerTemporalRange ) SIP_SKIP { mPerLayerTemporalRange = perLayerTemporalRange; }
 
    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 SIP_SKIP { return mLabelSink; }

    void setLabelSink( QgsLabelSink *sink ) SIP_SKIP { mLabelSink = sink; }

    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;

    static const QString ELEVATION_MAP_CACHE_PREFIX SIP_SKIP;
 
#ifndef SIP_RUN
    static const QgsSettingsEntryBool *settingsLogCanvasRefreshEvent;

    static const QgsSettingsEntryString *settingsMaskBackend;
#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;

    QList< QPointer< QgsMapLayer > > mAdditionalLabelLayers;

    bool mRecordRenderingTime = true;
 
#ifndef SIP_RUN
    std::unique_ptr< QgsRenderedItemResults > mRenderedItemResults;
#endif
 
    QStringList mLayersRedrawnFromCache;

    bool prepareLabelCache() const SIP_SKIP;

    bool labelingHasNonDefaultCompositionModes() const;

    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;

    QList< QPointer< QgsMapLayer > > participatingLabelLayers( QgsLabelingEngine *engine ) 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 QgsElevationMap layerElevationToBeComposed( 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;
 
    QHash<QgsMapLayer *, QgsDateTimeRange> mPerLayerTemporalRange;

    std::unique_ptr< QImage > allocateImage( const QString &layerId );

    std::unique_ptr< QgsElevationMap > allocateElevationMap( const QString &layerId );

    std::tuple< std::unique_ptr< QImage >, std::unique_ptr< QPainter > > allocateImageAndPainter( const QString &layerId, const QgsRenderContext &context );

    virtual void startPrivate() = 0;
 
    QgsLabelSink *mLabelSink = nullptr;
    QgsLabelingEngineFeedback *mLabelingEngineFeedback = nullptr;

    std::tuple<std::unique_ptr<QPicture>, std::unique_ptr< QPainter > > 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