QGIS API Documentation  2.11.0-Master
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
qgsmaprendererjob.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsmaprendererjob.cpp
3  --------------------------------------
4  Date : December 2013
5  Copyright : (C) 2013 by Martin Dobias
6  Email : wonder dot sk at gmail dot com
7  ***************************************************************************
8  * *
9  * This program is free software; you can redistribute it and/or modify *
10  * it under the terms of the GNU General Public License as published by *
11  * the Free Software Foundation; either version 2 of the License, or *
12  * (at your option) any later version. *
13  * *
14  ***************************************************************************/
15 
16 #include "qgsmaprendererjob.h"
17 
18 #include <QPainter>
19 #include <QTime>
20 #include <QTimer>
21 #include <QtConcurrentMap>
22 #include <QSettings>
23 
24 #include "qgscrscache.h"
25 #include "qgslogger.h"
26 #include "qgsrendercontext.h"
27 #include "qgsmaplayer.h"
28 #include "qgsmaplayerregistry.h"
29 #include "qgsmaplayerrenderer.h"
31 #include "qgsmaprenderercache.h"
32 #include "qgspallabeling.h"
33 #include "qgsvectorlayerrenderer.h"
34 #include "qgsvectorlayer.h"
35 
37  : mSettings( settings )
38  , mCache( 0 )
39  , mRenderingTime( 0 )
40 {
41 }
42 
43 
45  : QgsMapRendererJob( settings )
46 {
47 }
48 
49 
51 {
52  return mErrors;
53 }
54 
56 {
57  mCache = cache;
58 }
59 
61 {
62  return mSettings;
63 }
64 
65 
66 bool QgsMapRendererJob::reprojectToLayerExtent( const QgsCoordinateTransform* ct, bool layerCrsGeographic, QgsRectangle& extent, QgsRectangle& r2 )
67 {
68  bool split = false;
69 
70  try
71  {
72 #ifdef QGISDEBUG
73  // QgsLogger::debug<QgsRectangle>("Getting extent of canvas in layers CS. Canvas is ", extent, __FILE__, __FUNCTION__, __LINE__);
74 #endif
75  // Split the extent into two if the source CRS is
76  // geographic and the extent crosses the split in
77  // geographic coordinates (usually +/- 180 degrees,
78  // and is assumed to be so here), and draw each
79  // extent separately.
80  static const double splitCoord = 180.0;
81 
82  if ( layerCrsGeographic )
83  {
84  // Note: ll = lower left point
85  // and ur = upper right point
86  QgsPoint ll = ct->transform( extent.xMinimum(), extent.yMinimum(),
88 
89  QgsPoint ur = ct->transform( extent.xMaximum(), extent.yMaximum(),
91 
93 
94  if ( ll.x() > ur.x() )
95  {
96  // the coordinates projected in reverse order than what one would expect.
97  // we are probably looking at an area that includes longitude of 180 degrees.
98  // we need to take into account coordinates from two intervals: (-180,x1) and (x2,180)
99  // so let's use (-180,180). This hopefully does not add too much overhead. It is
100  // more straightforward than rendering with two separate extents and more consistent
101  // for rendering, labeling and caching as everything is rendered just in one go
102  extent.setXMinimum( -splitCoord );
103  extent.setXMaximum( splitCoord );
104  }
105 
106  // TODO: the above rule still does not help if using a projection that covers the whole
107  // world. E.g. with EPSG:3857 the longitude spectrum -180 to +180 is mapped to approx.
108  // -2e7 to +2e7. Converting extent from -5e7 to +5e7 is transformed as -90 to +90,
109  // but in fact the extent should cover the whole world.
110  }
111  else // can't cross 180
112  {
113  if ( ct->destCRS().geographicFlag() &&
114  ( extent.xMinimum() <= -180 || extent.xMaximum() >= 180 ||
115  extent.yMinimum() <= -90 || extent.yMaximum() >= 90 ) )
116  // Use unlimited rectangle because otherwise we may end up transforming wrong coordinates.
117  // E.g. longitude -200 to +160 would be understood as +40 to +160 due to periodicity.
118  // We could try to clamp coords to (-180,180) for lon resp. (-90,90) for lat,
119  // but this seems like a safer choice.
120  extent = QgsRectangle( -DBL_MAX, -DBL_MAX, DBL_MAX, DBL_MAX );
121  else
123  }
124  }
125  catch ( QgsCsException &cse )
126  {
127  Q_UNUSED( cse );
128  QgsDebugMsg( "Transform error caught" );
129  extent = QgsRectangle( -DBL_MAX, -DBL_MAX, DBL_MAX, DBL_MAX );
130  r2 = QgsRectangle( -DBL_MAX, -DBL_MAX, DBL_MAX, DBL_MAX );
131  }
132 
133  return split;
134 }
135 
136 
137 
139 {
140  LayerRenderJobs layerJobs;
141 
142  // render all layers in the stack, starting at the base
144  li.toBack();
145 
146  if ( mCache )
147  {
148  bool cacheValid = mCache->init( mSettings.visibleExtent(), mSettings.scale() );
149  QgsDebugMsg( QString( "CACHE VALID: %1" ).arg( cacheValid ) );
150  Q_UNUSED( cacheValid );
151  }
152 
154 
155  while ( li.hasPrevious() )
156  {
157  QString layerId = li.previous();
158 
159  QgsDebugMsg( "Rendering at layer item " + layerId );
160 
162 
163  if ( !ml )
164  {
165  mErrors.append( Error( layerId, tr( "Layer not found in registry." ) ) );
166  continue;
167  }
168 
169  QgsDebugMsg( QString( "layer %1: minscale:%2 maxscale:%3 scaledepvis:%4 blendmode:%5" )
170  .arg( ml->name() )
171  .arg( ml->minimumScale() )
172  .arg( ml->maximumScale() )
173  .arg( ml->hasScaleBasedVisibility() )
174  .arg( ml->blendMode() )
175  );
176 
177  if ( ml->hasScaleBasedVisibility() && ( mSettings.scale() < ml->minimumScale() || mSettings.scale() > ml->maximumScale() ) ) //|| mOverview )
178  {
179  QgsDebugMsg( "Layer not rendered because it is not within the defined visibility scale range" );
180  continue;
181  }
182 
184  const QgsCoordinateTransform* ct = 0;
185 
187  {
188  ct = mSettings.layerTransform( ml );
189  if ( ct )
190  {
191  reprojectToLayerExtent( ct, ml->crs().geographicFlag(), r1, r2 );
192  }
193  QgsDebugMsg( "extent: " + r1.toString() );
194  if ( !r1.isFinite() || !r2.isFinite() )
195  {
196  mErrors.append( Error( layerId, tr( "There was a problem transforming the layer's extent. Layer skipped." ) ) );
197  continue;
198  }
199  }
200 
201  // Force render of layers that are being edited
202  // or if there's a labeling engine that needs the layer to register features
203  if ( mCache && ml->type() == QgsMapLayer::VectorLayer )
204  {
205  QgsVectorLayer* vl = qobject_cast<QgsVectorLayer *>( ml );
206  if ( vl->isEditable() || ( labelingEngine && labelingEngine->willUseLayer( vl ) ) )
207  mCache->clearCacheImage( ml->id() );
208  }
209 
210  layerJobs.append( LayerRenderJob() );
211  LayerRenderJob& job = layerJobs.last();
212  job.cached = false;
213  job.img = 0;
214  job.blendMode = ml->blendMode();
215  job.layerId = ml->id();
216 
218  job.context.setPainter( painter );
219  job.context.setLabelingEngine( labelingEngine );
221  job.context.setExtent( r1 );
222 
223  // if we can use the cache, let's do it and avoid rendering!
224  if ( mCache && !mCache->cacheImage( ml->id() ).isNull() )
225  {
226  job.cached = true;
227  job.img = new QImage( mCache->cacheImage( ml->id() ) );
228  job.renderer = 0;
229  job.context.setPainter( 0 );
230  continue;
231  }
232 
233  // If we are drawing with an alternative blending mode then we need to render to a separate image
234  // before compositing this on the map. This effectively flattens the layer and prevents
235  // blending occuring between objects on the layer
236  if ( mCache || !painter || needTemporaryImage( ml ) )
237  {
238  // Flattened image for drawing when a blending mode is set
239  QImage * mypFlattenedImage = 0;
240  mypFlattenedImage = new QImage( mSettings.outputSize().width(),
243  if ( mypFlattenedImage->isNull() )
244  {
245  mErrors.append( Error( layerId, tr( "Insufficient memory for image %1x%2" ).arg( mSettings.outputSize().width() ).arg( mSettings.outputSize().height() ) ) );
246  delete mypFlattenedImage;
247  layerJobs.removeLast();
248  continue;
249  }
250  mypFlattenedImage->fill( 0 );
251 
252  job.img = mypFlattenedImage;
253  QPainter* mypPainter = new QPainter( job.img );
254  mypPainter->setRenderHint( QPainter::Antialiasing, mSettings.testFlag( QgsMapSettings::Antialiasing ) );
255  job.context.setPainter( mypPainter );
256  }
257 
258  bool hasStyleOverride = mSettings.layerStyleOverrides().contains( ml->id() );
259  if ( hasStyleOverride )
261 
262  job.renderer = ml->createMapRenderer( job.context );
263 
264  if ( hasStyleOverride )
266 
268  {
269  if ( QgsVectorLayerRenderer* vlr = dynamic_cast<QgsVectorLayerRenderer*>( job.renderer ) )
270  {
271  vlr->setGeometryCachePointer( &mGeometryCaches[ ml->id()] );
272  }
273  }
274 
275  } // while (li.hasPrevious())
276 
277  return layerJobs;
278 }
279 
280 
282 {
283  for ( LayerRenderJobs::iterator it = jobs.begin(); it != jobs.end(); ++it )
284  {
285  LayerRenderJob& job = *it;
286  if ( job.img )
287  {
288  delete job.context.painter();
289  job.context.setPainter( 0 );
290 
291  if ( mCache && !job.cached && !job.context.renderingStopped() )
292  {
293  QgsDebugMsg( "caching image for " + job.layerId );
294  mCache->setCacheImage( job.layerId, *job.img );
295  }
296 
297  delete job.img;
298  job.img = 0;
299  }
300 
301  if ( job.renderer )
302  {
303  foreach ( QString message, job.renderer->errors() )
304  mErrors.append( Error( job.renderer->layerID(), message ) );
305 
306  delete job.renderer;
307  job.renderer = 0;
308  }
309  }
310 
311  jobs.clear();
312 
314 }
315 
316 
318 {
319  QImage image( settings.outputSize(), settings.outputImageFormat() );
320  image.fill( settings.backgroundColor().rgb() );
321 
322  QPainter painter( &image );
323 
324  for ( LayerRenderJobs::const_iterator it = jobs.constBegin(); it != jobs.constEnd(); ++it )
325  {
326  const LayerRenderJob& job = *it;
327 
328  painter.setCompositionMode( job.blendMode );
329 
330  Q_ASSERT( job.img != 0 );
331  painter.drawImage( 0, 0, *job.img );
332  }
333 
334  painter.end();
335  return image;
336 }
bool restoreOverrideStyle()
Restore the original store after a call to setOverrideStyle()
void clear()
A rectangle specified with double values.
Definition: qgsrectangle.h:35
Base class for all map layer types.
Definition: qgsmaplayer.h:49
QgsMapLayer::LayerType type() const
Get the type of the layer.
Definition: qgsmaplayer.cpp:93
int width() const
Abstract base class for map rendering implementations.
bool end()
bool contains(const Key &key) const
double scale() const
Return the calculated scale of the map.
void setCompositionMode(CompositionMode mode)
virtual bool willUseLayer(QgsVectorLayer *layer) override
called to find out whether the layer is used for labeling
void setRenderHint(RenderHint hint, bool on)
void setXMaximum(double x)
Set the maximum x value.
Definition: qgsrectangle.h:167
void cleanupJobs(LayerRenderJobs &jobs)
const QgsCoordinateTransform * layerTransform(QgsMapLayer *layer) const
Return coordinate transform from layer's CRS to destination CRS.
void updateLayerGeometryCaches()
called when rendering has finished to update all layers' geometry caches
static QImage composeImage(const QgsMapSettings &settings, const LayerRenderJobs &jobs)
bool isFinite() const
Returns true if the rectangle has finite boundaries.
double yMaximum() const
Get the y maximum value (top side of rectangle)
Definition: qgsrectangle.h:192
#define QgsDebugMsg(str)
Definition: qgslogger.h:33
QStringList mRequestedGeomCacheForLayers
list of layer IDs for which the geometry cache should be updated
QgsMapLayerStyleManager * styleManager() const
Get access to the layer's style manager.
QMap< QString, QgsGeometryCache > mGeometryCaches
map of geometry caches
float minimumScale() const
Returns the minimum scale denominator at which the layer is visible.
bool contains(const QString &str, Qt::CaseSensitivity cs) const
QgsRectangle visibleExtent() const
Return the actual extent derived from requested extent that takes takes output image size into accoun...
QMap< QString, QString > layerStyleOverrides() const
Get map of map layer style overrides (key: layer ID, value: style name) where a different style shoul...
bool hasCrsTransformEnabled() const
returns true if projections are enabled for this layer set
QgsPoint transform(const QgsPoint &p, TransformDirection direction=ForwardTransform) const
bool isNull() const
virtual QgsMapLayerRenderer * createMapRenderer(QgsRenderContext &rendererContext)
Return new instance of QgsMapLayerRenderer that will be used for rendering of given context...
Definition: qgsmaplayer.h:134
void setCacheImage(QString layerId, const QImage &img)
set cached image for the specified layer ID
void clear()
virtual bool isEditable() const override
Returns true if the provider is in editing mode.
QString tr(const char *sourceText, const char *disambiguation, int n)
void setExtent(const QgsRectangle &extent)
LayerRenderJobs prepareJobs(QPainter *painter, QgsPalLabeling *labelingEngine)
double x() const
Definition: qgspoint.h:126
void setCache(QgsMapRendererCache *cache)
Assign a cache to be used for reading and storing rendered images of individual layers.
The QgsMapSettings class contains configuration for rendering of the map.
QString layerID() const
Get access to the ID of the layer rendered by this class.
void setCoordinateTransform(const QgsCoordinateTransform *t)
Sets coordinate transformation.
const QString & name() const
Get the display name of the layer.
QPainter::CompositionMode blendMode() const
Returns the current blending mode for a layer.
void append(const T &value)
bool hasScaleBasedVisibility() const
Returns whether scale based visibility is enabled for the layer.
double yMinimum() const
Get the y minimum value (bottom side of rectangle)
Definition: qgsrectangle.h:197
void fill(uint pixelValue)
QSize outputSize() const
Return the size of the resulting map image.
double xMaximum() const
Get the x maximum value (right side of rectangle)
Definition: qgsrectangle.h:182
QRgb rgb() const
void clearCacheImage(QString layerId)
remove layer from the cache
bool renderingStopped() const
float maximumScale() const
Returns the maximum scale denominator at which the layer is visible.
QStringList errors() const
Return list of errors (problems) that happened during the rendering.
Enable anti-aliasin for map rendering.
const QgsMapSettings & mapSettings() const
Return map settings with which this job was started.
QImage cacheImage(QString layerId)
get cached image for the specified layer ID. Returns null image if it is not cached.
void setPainter(QPainter *p)
QString id() const
Get this layer's unique ID, this ID is used to access this layer from map layer registry.
Definition: qgsmaplayer.cpp:99
A class to represent a point.
Definition: qgspoint.h:63
QgsMapSettings mSettings
iterator end()
QColor backgroundColor() const
Get the background color of the map.
Implementation of threaded rendering for vector layers.
bool testFlag(Flag flag) const
Check whether a particular flag is enabled.
static QgsMapLayerRegistry * instance()
Returns the instance pointer, creating the object on the first call.
void drawImage(const QRectF &target, const QImage &image, const QRectF &source, QFlags< Qt::ImageConversionFlag > flags)
QPainter * painter()
static QgsRenderContext fromMapSettings(const QgsMapSettings &mapSettings)
create initialized QgsRenderContext instance from given QgsMapSettings
void setLabelingEngine(QgsLabelingEngineInterface *iface)
QImage::Format outputImageFormat() const
format of internal QImage, default QImage::Format_ARGB32_Premultiplied
T & last()
int height() const
QgsMapLayerRenderer * renderer
void removeLast()
Class for doing transforms between two map coordinate systems.
QgsRenderContext context
const QgsCoordinateReferenceSystem & crs() const
Returns layer's spatial reference system.
QgsMapRendererQImageJob(const QgsMapSettings &settings)
QStringList layers() const
Get list of layer IDs for map rendering The layers are stored in the reverse order of how they are re...
QgsMapLayer * mapLayer(QString theLayerId)
Retrieve a pointer to a loaded layer by id.
This class is responsible for keeping cache of rendered images of individual layers.
bool setOverrideStyle(const QString &styleDef)
Temporarily apply a different style to the layer.
static bool reprojectToLayerExtent(const QgsCoordinateTransform *ct, bool layerCrsGeographic, QgsRectangle &extent, QgsRectangle &r2)
Convenience function to project an extent into the layer source CRS, but also split it into two exten...
Custom exception class for Coordinate Reference System related exceptions.
const_iterator constEnd() const
const_iterator constBegin() const
Errors errors() const
List of errors that happened during the rendering job - available when the rendering has been finishe...
QPainter::CompositionMode blendMode
bool init(QgsRectangle extent, double scale)
initialize cache: set new parameters and erase cache if parameters have changed
const QgsCoordinateReferenceSystem & destCRS() const
Represents a vector layer which manages a vector based data sets.
QString toString(bool automaticPrecision=false) const
returns string representation of form xmin,ymin xmax,ymax
QgsMapRendererCache * mCache
double xMinimum() const
Get the x minimum value (left side of rectangle)
Definition: qgsrectangle.h:187
bool needTemporaryImage(QgsMapLayer *ml)
iterator begin()
bool isNull(const QVariant &v)
QgsMapRendererJob(const QgsMapSettings &settings)
void setXMinimum(double x)
Set the minimum x value.
Definition: qgsrectangle.h:162
QgsRectangle transformBoundingBox(const QgsRectangle &theRect, TransformDirection direction=ForwardTransform, const bool handle180Crossover=false) const
Structure keeping low-level rendering job information.
const T value(const Key &key) const