QGIS API Documentation  2.99.0-Master (19b062c)
qgsrasterlayerrenderer.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsrasterlayerrenderer.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 "qgsrasterlayerrenderer.h"
17 
18 #include "qgsmessagelog.h"
19 #include "qgsrasterdataprovider.h"
20 #include "qgsrasterdrawer.h"
21 #include "qgsrasteriterator.h"
22 #include "qgsrasterlayer.h"
23 #include "qgsrasterprojector.h"
24 #include "qgsrendercontext.h"
25 #include "qgsproject.h"
26 #include "qgsexception.h"
27 
28 
30 
31 QgsRasterLayerRendererFeedback::QgsRasterLayerRendererFeedback( QgsRasterLayerRenderer *r )
32  : mR( r )
33  , mMinimalPreviewInterval( 250 )
34 {
35  setRenderPartialOutput( r->mContext.testFlag( QgsRenderContext::RenderPartialOutput ) );
36 }
37 
38 void QgsRasterLayerRendererFeedback::onNewData()
39 {
40  if ( !renderPartialOutput() )
41  return; // we were not asked for partial renders and we may not have a temporary image for overwriting...
42 
43  // update only once upon a time
44  // (preview itself takes some time)
45  if ( mLastPreview.isValid() && mLastPreview.msecsTo( QTime::currentTime() ) < mMinimalPreviewInterval )
46  return;
47 
48  // TODO: update only the area that got new data
49 
50  QgsDebugMsg( QString( "new raster preview! %1" ).arg( mLastPreview.msecsTo( QTime::currentTime() ) ) );
51  QTime t;
52  t.start();
53  QgsRasterBlockFeedback feedback;
54  feedback.setPreviewOnly( true );
55  feedback.setRenderPartialOutput( true );
56  QgsRasterIterator iterator( mR->mPipe->last() );
57  QgsRasterDrawer drawer( &iterator );
58  drawer.draw( mR->mPainter, mR->mRasterViewPort, mR->mMapToPixel, &feedback );
59  QgsDebugMsg( QString( "total raster preview time: %1 ms" ).arg( t.elapsed() ) );
60  mLastPreview = QTime::currentTime();
61 }
62 
66  : QgsMapLayerRenderer( layer->id() )
67  , mContext( rendererContext )
68  , mFeedback( new QgsRasterLayerRendererFeedback( this ) )
69 {
70  mPainter = rendererContext.painter();
71  const QgsMapToPixel &qgsMapToPixel = rendererContext.mapToPixel();
72  mMapToPixel = &qgsMapToPixel;
73 
74  QgsMapToPixel mapToPixel = qgsMapToPixel;
75  if ( mapToPixel.mapRotation() )
76  {
77  // unset rotation for the sake of local computations.
78  // Rotation will be handled by QPainter later
79  // TODO: provide a method of QgsMapToPixel to fetch map center
80  // in geographical units
81  QgsPointXY center = mapToPixel.toMapCoordinates(
82  mapToPixel.mapWidth() / 2.0,
83  mapToPixel.mapHeight() / 2.0
84  );
85  mapToPixel.setMapRotation( 0, center.x(), center.y() );
86  }
87 
88  QgsRectangle myProjectedViewExtent;
89  QgsRectangle myProjectedLayerExtent;
90 
91  if ( rendererContext.coordinateTransform().isValid() )
92  {
93  QgsDebugMsgLevel( "coordinateTransform set -> project extents.", 4 );
94  if ( rendererContext.extent().xMinimum() == -DBL_MAX &&
95  rendererContext.extent().yMinimum() == -DBL_MAX &&
96  rendererContext.extent().xMaximum() == DBL_MAX &&
97  rendererContext.extent().yMaximum() == DBL_MAX )
98  {
99  // We get in this situation if the view CRS is geographical and the
100  // extent goes beyond -180,-90,180,90. To avoid reprojection issues to the
101  // layer CRS, then this dummy extent is returned by QgsMapRendererJob::reprojectToLayerExtent()
102  // Don't try to reproject it now to view extent as this would return
103  // a null rectangle.
104  myProjectedViewExtent = rendererContext.extent();
105  }
106  else
107  {
108  try
109  {
110  myProjectedViewExtent = rendererContext.coordinateTransform().transformBoundingBox( rendererContext.extent() );
111  }
112  catch ( QgsCsException &cs )
113  {
114  QgsMessageLog::logMessage( QObject::tr( "Could not reproject view extent: %1" ).arg( cs.what() ), QObject::tr( "Raster" ) );
115  myProjectedViewExtent.setMinimal();
116  }
117  }
118 
119  try
120  {
121  myProjectedLayerExtent = rendererContext.coordinateTransform().transformBoundingBox( layer->extent() );
122  }
123  catch ( QgsCsException &cs )
124  {
125  QgsMessageLog::logMessage( QObject::tr( "Could not reproject layer extent: %1" ).arg( cs.what() ), QObject::tr( "Raster" ) );
126  myProjectedLayerExtent.setMinimal();
127  }
128  }
129  else
130  {
131  QgsDebugMsgLevel( "coordinateTransform not set", 4 );
132  myProjectedViewExtent = rendererContext.extent();
133  myProjectedLayerExtent = layer->extent();
134  }
135 
136  // clip raster extent to view extent
137  QgsRectangle myRasterExtent = myProjectedViewExtent.intersect( &myProjectedLayerExtent );
138  if ( myRasterExtent.isEmpty() )
139  {
140  QgsDebugMsg( "draw request outside view extent." );
141  // nothing to do
142  return;
143  }
144 
145  QgsDebugMsgLevel( "theViewExtent is " + rendererContext.extent().toString(), 4 );
146  QgsDebugMsgLevel( "myProjectedViewExtent is " + myProjectedViewExtent.toString(), 4 );
147  QgsDebugMsgLevel( "myProjectedLayerExtent is " + myProjectedLayerExtent.toString(), 4 );
148  QgsDebugMsgLevel( "myRasterExtent is " + myRasterExtent.toString(), 4 );
149 
150  //
151  // The first thing we do is set up the QgsRasterViewPort. This struct stores all the settings
152  // relating to the size (in pixels and coordinate system units) of the raster part that is
153  // in view in the map window. It also stores the origin.
154  //
155  //this is not a class level member because every time the user pans or zooms
156  //the contents of the rasterViewPort will change
157  mRasterViewPort = new QgsRasterViewPort();
158 
159  mRasterViewPort->mDrawnExtent = myRasterExtent;
160  if ( rendererContext.coordinateTransform().isValid() )
161  {
162  mRasterViewPort->mSrcCRS = layer->crs();
163  mRasterViewPort->mDestCRS = rendererContext.coordinateTransform().destinationCrs();
164  mRasterViewPort->mSrcDatumTransform = rendererContext.coordinateTransform().sourceDatumTransform();
165  mRasterViewPort->mDestDatumTransform = rendererContext.coordinateTransform().destinationDatumTransform();
166  }
167  else
168  {
169  mRasterViewPort->mSrcCRS = QgsCoordinateReferenceSystem(); // will be invalid
170  mRasterViewPort->mDestCRS = QgsCoordinateReferenceSystem(); // will be invalid
171  mRasterViewPort->mSrcDatumTransform = -1;
172  mRasterViewPort->mDestDatumTransform = -1;
173  }
174 
175  // get dimensions of clipped raster image in device coordinate space (this is the size of the viewport)
176  mRasterViewPort->mTopLeftPoint = mapToPixel.transform( myRasterExtent.xMinimum(), myRasterExtent.yMaximum() );
177  mRasterViewPort->mBottomRightPoint = mapToPixel.transform( myRasterExtent.xMaximum(), myRasterExtent.yMinimum() );
178 
179  // align to output device grid, i.e. std::floor/ceil to integers
180  // TODO: this should only be done if paint device is raster - screen, image
181  // for other devices (pdf) it can have floating point origin
182  // we could use floating point for raster devices as well, but respecting the
183  // output device grid should make it more effective as the resampling is done in
184  // the provider anyway
185  mRasterViewPort->mTopLeftPoint.setX( std::floor( mRasterViewPort->mTopLeftPoint.x() ) );
186  mRasterViewPort->mTopLeftPoint.setY( std::floor( mRasterViewPort->mTopLeftPoint.y() ) );
187  mRasterViewPort->mBottomRightPoint.setX( std::ceil( mRasterViewPort->mBottomRightPoint.x() ) );
188  mRasterViewPort->mBottomRightPoint.setY( std::ceil( mRasterViewPort->mBottomRightPoint.y() ) );
189  // recalc myRasterExtent to aligned values
190  myRasterExtent.set(
191  mapToPixel.toMapCoordinatesF( mRasterViewPort->mTopLeftPoint.x(),
192  mRasterViewPort->mBottomRightPoint.y() ),
193  mapToPixel.toMapCoordinatesF( mRasterViewPort->mBottomRightPoint.x(),
194  mRasterViewPort->mTopLeftPoint.y() )
195  );
196 
197  //raster viewport top left / bottom right are already rounded to int
198  mRasterViewPort->mWidth = static_cast<int>( mRasterViewPort->mBottomRightPoint.x() - mRasterViewPort->mTopLeftPoint.x() );
199  mRasterViewPort->mHeight = static_cast<int>( mRasterViewPort->mBottomRightPoint.y() - mRasterViewPort->mTopLeftPoint.y() );
200 
201  //the drawable area can start to get very very large when you get down displaying 2x2 or smaller, this is because
202  //mapToPixel.mapUnitsPerPixel() is less then 1,
203  //so we will just get the pixel data and then render these special cases differently in paintImageToCanvas()
204 
205  QgsDebugMsgLevel( QString( "mapUnitsPerPixel = %1" ).arg( mapToPixel.mapUnitsPerPixel() ), 3 );
206  QgsDebugMsgLevel( QString( "mWidth = %1" ).arg( layer->width() ), 3 );
207  QgsDebugMsgLevel( QString( "mHeight = %1" ).arg( layer->height() ), 3 );
208  QgsDebugMsgLevel( QString( "myRasterExtent.xMinimum() = %1" ).arg( myRasterExtent.xMinimum() ), 3 );
209  QgsDebugMsgLevel( QString( "myRasterExtent.xMaximum() = %1" ).arg( myRasterExtent.xMaximum() ), 3 );
210  QgsDebugMsgLevel( QString( "myRasterExtent.yMinimum() = %1" ).arg( myRasterExtent.yMinimum() ), 3 );
211  QgsDebugMsgLevel( QString( "myRasterExtent.yMaximum() = %1" ).arg( myRasterExtent.yMaximum() ), 3 );
212 
213  QgsDebugMsgLevel( QString( "mTopLeftPoint.x() = %1" ).arg( mRasterViewPort->mTopLeftPoint.x() ), 3 );
214  QgsDebugMsgLevel( QString( "mBottomRightPoint.x() = %1" ).arg( mRasterViewPort->mBottomRightPoint.x() ), 3 );
215  QgsDebugMsgLevel( QString( "mTopLeftPoint.y() = %1" ).arg( mRasterViewPort->mTopLeftPoint.y() ), 3 );
216  QgsDebugMsgLevel( QString( "mBottomRightPoint.y() = %1" ).arg( mRasterViewPort->mBottomRightPoint.y() ), 3 );
217 
218  QgsDebugMsgLevel( QString( "mWidth = %1" ).arg( mRasterViewPort->mWidth ), 3 );
219  QgsDebugMsgLevel( QString( "mHeight = %1" ).arg( mRasterViewPort->mHeight ), 3 );
220 
221  // /\/\/\ - added to handle zoomed-in rasters
222 
223  // TODO R->mLastViewPort = *mRasterViewPort;
224 
225  // TODO: is it necessary? Probably WMS only?
226  layer->dataProvider()->setDpi( 25.4 * rendererContext.scaleFactor() );
227 
228 
229  // copy the whole raster pipe!
230  mPipe = new QgsRasterPipe( *layer->pipe() );
231  QgsRasterRenderer *rasterRenderer = mPipe->renderer();
232  if ( rasterRenderer && !( rendererContext.flags() & QgsRenderContext::RenderPreviewJob ) )
233  layer->refreshRendererIfNeeded( rasterRenderer, rendererContext.extent() );
234 }
235 
237 {
238  delete mFeedback;
239 
240  delete mRasterViewPort;
241  delete mPipe;
242 }
243 
245 {
246  if ( !mRasterViewPort )
247  return true; // outside of layer extent - nothing to do
248 
249  //R->draw( mPainter, mRasterViewPort, &mMapToPixel );
250 
251  QTime time;
252  time.start();
253  //
254  //
255  // The goal here is to make as many decisions as possible early on (outside of the rendering loop)
256  // so that we can maximise performance of the rendering process. So now we check which drawing
257  // procedure to use :
258  //
259 
260  QgsRasterProjector *projector = mPipe->projector();
261 
262  // TODO add a method to interface to get provider and get provider
263  // params in QgsRasterProjector
264  if ( projector )
265  {
266  projector->setCrs( mRasterViewPort->mSrcCRS, mRasterViewPort->mDestCRS, mRasterViewPort->mSrcDatumTransform, mRasterViewPort->mDestDatumTransform );
267  }
268 
269  // Drawer to pipe?
270  QgsRasterIterator iterator( mPipe->last() );
271  QgsRasterDrawer drawer( &iterator );
272  drawer.draw( mPainter, mRasterViewPort, mMapToPixel, mFeedback );
273 
274  QgsDebugMsgLevel( QString( "total raster draw time (ms): %1" ).arg( time.elapsed(), 5 ), 4 );
275 
276  return true;
277 }
278 
280 {
281  return mFeedback;
282 }
283 
int width() const
Accessor that returns the width of the (unclipped) raster.
virtual QgsFeedback * feedback() const override
Access to feedback object of the layer renderer (may be null)
A rectangle specified with double values.
Definition: qgsrectangle.h:39
void setMapRotation(double degrees, double cx, double cy)
Set map rotation in degrees (clockwise)
void setMinimal()
Set a rectangle so that min corner is at max and max corner is at min.
Base class for processing modules.
Definition: qgsrasterpipe.h:46
Iterator for sequentially processing raster cells.
QgsRasterRenderer * renderer() const
#define QgsDebugMsg(str)
Definition: qgslogger.h:37
This class provides qgis with the ability to render raster datasets onto the mapcanvas.
double y
Definition: qgspointxy.h:48
QgsRasterPipe * pipe()
Get raster pipe.
A class to represent a 2D point.
Definition: qgspointxy.h:43
QgsRasterProjector * projector() const
QgsRasterInterface * last() const
QgsRectangle transformBoundingBox(const QgsRectangle &rectangle, TransformDirection direction=ForwardTransform, const bool handle180Crossover=false) const
Transforms a rectangle from the source CRS to the destination CRS.
QgsCoordinateReferenceSystem destinationCrs() const
Returns the destination coordinate reference system, which the transform will transform coordinates t...
QgsRectangle intersect(const QgsRectangle *rect) const
Return the intersection with the given rectangle.
void setRenderPartialOutput(bool enable)
Set whether our painter is drawing to a temporary image used just by this layer.
Flags flags() const
Return combination of flags used for rendering.
int height() const
Accessor that returns the height of the (unclipped) raster.
Implementation of threaded rendering for raster layers.
virtual bool render() override
Do the rendering (based on data stored in the class)
bool isValid() const
Returns true if the coordinate transform is valid, ie both the source and destination CRS have been s...
virtual QgsRectangle extent() const
Returns the extent of the layer.
double mapRotation() const
Return current map rotation in degrees.
QgsCoordinateReferenceSystem mDestCRS
Target coordinate system.
QString what() const
Definition: qgsexception.h:48
void setCrs(const QgsCoordinateReferenceSystem &srcCRS, const QgsCoordinateReferenceSystem &destCRS, int srcDatumTransform=-1, int destDatumTransform=-1)
set source and destination CRS
Base class for feedback objects to be used for cancelation of something running in a worker thread...
Definition: qgsfeedback.h:44
Perform transforms between map coordinates and device coordinates.
Definition: qgsmaptopixel.h:36
The drawing pipe for raster layers.
QgsPointXY transform(const QgsPointXY &p) const
Transform the point from map (world) coordinates to device coordinates.
QgsRasterDataProvider * dataProvider() override
int mapWidth() const
Return current map width in pixels The information is only known if setRotation was used...
QString id() const
Returns the layer&#39;s unique ID, which is used to access this layer from QgsProject.
int mapHeight() const
Return current map height in pixels.
void setPreviewOnly(bool preview)
set flag whether the block request is for preview purposes only
#define QgsDebugMsgLevel(str, level)
Definition: qgslogger.h:38
bool isEmpty() const
Returns true if the rectangle is empty.
const QgsRectangle & extent() const
QgsRasterLayerRenderer(QgsRasterLayer *layer, QgsRenderContext &rendererContext)
QString toString(int precision=16) const
Returns a string representation of form xmin,ymin : xmax,ymax Coordinates will be truncated to the sp...
QgsCoordinateReferenceSystem crs() const
Returns the layer&#39;s spatial reference system.
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context, or an invalid transform is no coordinate tr...
double mapUnitsPerPixel() const
Return current map units per pixel.
void setX(double x)
Sets the x value of the point.
Definition: qgspointxy.h:104
double x
Definition: qgspointxy.h:47
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
Definition: qgsrectangle.h:126
QgsCoordinateReferenceSystem mSrcCRS
Source coordinate system.
double xMaximum() const
Returns the x maximum value (right side of rectangle).
Definition: qgsrectangle.h:111
QgsRasterProjector implements approximate projection support for it calculates grid of points in sour...
Render is a &#39;canvas preview&#39; render, and shortcuts should be taken to ensure fast rendering...
static void logMessage(const QString &message, const QString &tag=QString(), MessageLevel level=QgsMessageLog::WARNING)
add a message to the instance (and create it if necessary)
Contains information about the context of a rendering operation.
QPainter * painter()
Returns the destination QPainter for the render operation.
const QgsMapToPixel & mapToPixel() const
Whether to make extra effort to update map image with partially rendered layers (better for interacti...
This class represents a coordinate reference system (CRS).
double xMinimum() const
Returns the x minimum value (left side of rectangle).
Definition: qgsrectangle.h:116
Base class for utility classes that encapsulate information necessary for rendering of map layers...
double yMaximum() const
Returns the y maximum value (top side of rectangle).
Definition: qgsrectangle.h:121
void refreshRendererIfNeeded(QgsRasterRenderer *rasterRenderer, const QgsRectangle &extent)
Refresh renderer with new extent, if needed.
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:65
This class provides details of the viewable area that a raster will be rendered into.
bool testFlag(Flag flag) const
Check whether a particular flag is enabled.
double scaleFactor() const
Returns the scaling factor for the render to convert painter units to physical sizes.
Feedback object tailored for raster block reading.
QgsPointXY toMapCoordinatesF(double x, double y) const
Transform device coordinates to map (world) coordinates.
QgsPointXY toMapCoordinates(int x, int y) const
Raster renderer pipe that applies colors to a raster.
void setDpi(int dpi)
Sets the output device resolution.
void set(const QgsPointXY &p1, const QgsPointXY &p2)
Sets the rectangle from two QgsPoints.