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 "qgsrendercontext.h"
 
#include "qgsmapsettings.h"
#include "qgsmaskidprovider.h"
 
 
class QgsLabelingEngine;
class QgsLabelingResults;
class QgsMapLayerRenderer;
class QgsMapRendererCache;
class QgsFeatureFilterProvider;
 
#ifndef SIP_RUN
 
struct LayerRenderJob
{
  QgsRenderContext context;
 
  QImage *img;
  bool imageInitialized = false;
  QgsMapLayerRenderer *renderer; // must be deleted
  QPainter::CompositionMode blendMode;
  double opacity;
  bool cached;
  QgsWeakMapLayerPointer layer;
  int renderingTime; 
  QStringList errors; 
 
  QString layerId;
 
  QImage *maskImage = nullptr;
 
  LayerRenderJob *firstPassJob = nullptr;
 
  QList<QPair<LayerRenderJob *, int>> maskJobs;
};
 
typedef QList<LayerRenderJob> LayerRenderJobs;
 
struct LabelRenderJob
{
  QgsRenderContext context;
 
  QImage *img = nullptr;
 
  QVector<QImage *> maskImages;
 
  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
{
    Q_OBJECT
  public:
 
    QgsMapRendererJob( const QgsMapSettings &settings );
 
    virtual void start() = 0;
 
    virtual void cancel() = 0;
 
    virtual void cancelWithoutBlocking() = 0;
 
    virtual void waitForFinished() = 0;
 
    virtual bool isActive() const = 0;
 
    virtual bool usedCachedLabels() const = 0;
 
    virtual QgsLabelingResults *takeLabelingResults() = 0 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 );
 
    int renderingTime() const { return mRenderingTime; }
 
    QHash< QgsMapLayer *, int > perLayerRenderingTime() const SIP_SKIP;
 
    const QgsMapSettings &mapSettings() const;
 
    static const QString LABEL_CACHE_ID SIP_SKIP;
 
  signals:
 
    void renderingLayersFinished();
 
    void finished();
 
  protected:
 
    QgsMapSettings mSettings;
    QElapsedTimer mRenderingStart;
    Errors mErrors;
 
    QgsMapRendererCache *mCache = nullptr;
 
    int mRenderingTime = 0;
 
    QHash< QgsWeakMapLayerPointer, int > mPerLayerRenderingTime;
 
    bool mRecordRenderingTime = true;
 
    bool prepareLabelCache() const SIP_SKIP;
 
    LayerRenderJobs prepareJobs( QPainter *painter, QgsLabelingEngine *labelingEngine2, bool deferredPainterSet = false ) SIP_SKIP;
 
    LabelRenderJob prepareLabelingJob( QPainter *painter, QgsLabelingEngine *labelingEngine2, bool canUseLabelCache = true ) SIP_SKIP;
 
    LayerRenderJobs prepareSecondPassJobs( LayerRenderJobs &firstPassJobs, LabelRenderJob &labelJob ) SIP_SKIP;
 
    static QImage composeImage( const QgsMapSettings &settings, const LayerRenderJobs &jobs, const LabelRenderJob &labelJob ) SIP_SKIP;
 
    static void composeSecondPass( LayerRenderJobs &secondPassJobs, LabelRenderJob &labelJob ) SIP_SKIP;
 
    void logRenderingTime( const LayerRenderJobs &jobs, const LayerRenderJobs &secondPassJobs, const LabelRenderJob &labelJob ) SIP_SKIP;
 
    void cleanupJobs( LayerRenderJobs &jobs ) SIP_SKIP;
 
    void cleanupSecondPassJobs( LayerRenderJobs &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 );
 
    bool needTemporaryImage( QgsMapLayer *ml );
 
    const QgsFeatureFilterProvider *mFeatureFilterProvider = nullptr;
 
    QImage *allocateImage( QString layerId );
 
    QPainter *allocateImageAndPainter( QString layerId, QImage *&image );
};
 
 
class CORE_EXPORT QgsMapRendererQImageJob : public QgsMapRendererJob
{
    Q_OBJECT
 
  public:
    QgsMapRendererQImageJob( const QgsMapSettings &settings );
 
    virtual QImage renderedImage() = 0;
 
};
 
 
#endif // QGSMAPRENDERERJOB_H