QGIS API Documentation  3.24.2-Tisler (13c1a02865)
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"
28 #include "qgsmapclippingutils.h"
29 #include "qgsrasterpipe.h"
30 
31 #include <QElapsedTimer>
32 #include <QPointer>
33 
35 
36 QgsRasterLayerRendererFeedback::QgsRasterLayerRendererFeedback( QgsRasterLayerRenderer *r )
37  : mR( r )
38  , mMinimalPreviewInterval( 250 )
39 {
40  setRenderPartialOutput( r->renderContext()->testFlag( Qgis::RenderContextFlag::RenderPartialOutput ) );
41 }
42 
43 void QgsRasterLayerRendererFeedback::onNewData()
44 {
45  if ( !renderPartialOutput() )
46  return; // we were not asked for partial renders and we may not have a temporary image for overwriting...
47 
48  // update only once upon a time
49  // (preview itself takes some time)
50  if ( mLastPreview.isValid() && mLastPreview.msecsTo( QTime::currentTime() ) < mMinimalPreviewInterval )
51  return;
52 
53  // TODO: update only the area that got new data
54 
55  QgsDebugMsgLevel( QStringLiteral( "new raster preview! %1" ).arg( mLastPreview.msecsTo( QTime::currentTime() ) ), 3 );
56  QElapsedTimer t;
57  t.start();
58  QgsRasterBlockFeedback feedback;
59  feedback.setPreviewOnly( true );
60  feedback.setRenderPartialOutput( true );
61  QgsRasterIterator iterator( mR->mPipe->last() );
62  QgsRasterDrawer drawer( &iterator, mR->renderContext()->dpiTarget() );
63  drawer.draw( mR->renderContext()->painter(), mR->mRasterViewPort, &mR->renderContext()->mapToPixel(), &feedback );
64  mR->mReadyToCompose = true;
65  QgsDebugMsgLevel( QStringLiteral( "total raster preview time: %1 ms" ).arg( t.elapsed() ), 3 );
66  mLastPreview = QTime::currentTime();
67 }
68 
72  : QgsMapLayerRenderer( layer->id(), &rendererContext )
73  , mProviderCapabilities( static_cast<QgsRasterDataProvider::Capability>( layer->dataProvider()->capabilities() ) )
74  , mFeedback( new QgsRasterLayerRendererFeedback( this ) )
75 {
76  mReadyToCompose = false;
77  QgsMapToPixel mapToPixel = rendererContext.mapToPixel();
78  if ( rendererContext.mapToPixel().mapRotation() )
79  {
80  // unset rotation for the sake of local computations.
81  // Rotation will be handled by QPainter later
82  // TODO: provide a method of QgsMapToPixel to fetch map center
83  // in geographical units
84  const QgsPointXY center = mapToPixel.toMapCoordinates(
85  static_cast<int>( mapToPixel.mapWidth() / 2.0 ),
86  static_cast<int>( mapToPixel.mapHeight() / 2.0 )
87  );
88  mapToPixel.setMapRotation( 0, center.x(), center.y() );
89  }
90 
91  QgsRectangle myProjectedViewExtent;
92  QgsRectangle myProjectedLayerExtent;
93 
94  if ( rendererContext.coordinateTransform().isValid() )
95  {
96  QgsDebugMsgLevel( QStringLiteral( "coordinateTransform set -> project extents." ), 4 );
97  if ( rendererContext.extent().xMinimum() == std::numeric_limits<double>::lowest() &&
98  rendererContext.extent().yMinimum() == std::numeric_limits<double>::lowest() &&
99  rendererContext.extent().xMaximum() == std::numeric_limits<double>::max() &&
100  rendererContext.extent().yMaximum() == std::numeric_limits<double>::max() )
101  {
102  // We get in this situation if the view CRS is geographical and the
103  // extent goes beyond -180,-90,180,90. To avoid reprojection issues to the
104  // layer CRS, then this dummy extent is returned by QgsMapRendererJob::reprojectToLayerExtent()
105  // Don't try to reproject it now to view extent as this would return
106  // a null rectangle.
107  myProjectedViewExtent = rendererContext.extent();
108  }
109  else
110  {
111  try
112  {
113  QgsCoordinateTransform ct = rendererContext.coordinateTransform();
115  myProjectedViewExtent = ct.transformBoundingBox( rendererContext.extent() );
116  }
117  catch ( QgsCsException &cs )
118  {
119  QgsMessageLog::logMessage( QObject::tr( "Could not reproject view extent: %1" ).arg( cs.what() ), QObject::tr( "Raster" ) );
120  myProjectedViewExtent.setMinimal();
121  }
122  }
123 
124  try
125  {
126  QgsCoordinateTransform ct = rendererContext.coordinateTransform();
128  myProjectedLayerExtent = ct.transformBoundingBox( layer->extent() );
129  }
130  catch ( QgsCsException &cs )
131  {
132  QgsMessageLog::logMessage( QObject::tr( "Could not reproject layer extent: %1" ).arg( cs.what() ), QObject::tr( "Raster" ) );
133  myProjectedLayerExtent.setMinimal();
134  }
135  }
136  else
137  {
138  QgsDebugMsgLevel( QStringLiteral( "coordinateTransform not set" ), 4 );
139  myProjectedViewExtent = rendererContext.extent();
140  myProjectedLayerExtent = layer->extent();
141  }
142 
143  // clip raster extent to view extent
144  QgsRectangle myRasterExtent = layer->ignoreExtents() ? myProjectedViewExtent : myProjectedViewExtent.intersect( myProjectedLayerExtent );
145  if ( myRasterExtent.isEmpty() )
146  {
147  QgsDebugMsgLevel( QStringLiteral( "draw request outside view extent." ), 2 );
148  // nothing to do
149  return;
150  }
151 
152  QgsDebugMsgLevel( "theViewExtent is " + rendererContext.extent().toString(), 4 );
153  QgsDebugMsgLevel( "myProjectedViewExtent is " + myProjectedViewExtent.toString(), 4 );
154  QgsDebugMsgLevel( "myProjectedLayerExtent is " + myProjectedLayerExtent.toString(), 4 );
155  QgsDebugMsgLevel( "myRasterExtent is " + myRasterExtent.toString(), 4 );
156 
157  //
158  // The first thing we do is set up the QgsRasterViewPort. This struct stores all the settings
159  // relating to the size (in pixels and coordinate system units) of the raster part that is
160  // in view in the map window. It also stores the origin.
161  //
162  //this is not a class level member because every time the user pans or zooms
163  //the contents of the rasterViewPort will change
164  mRasterViewPort = new QgsRasterViewPort();
165 
166  mRasterViewPort->mDrawnExtent = myRasterExtent;
167  if ( rendererContext.coordinateTransform().isValid() )
168  {
169  mRasterViewPort->mSrcCRS = layer->crs();
170  mRasterViewPort->mDestCRS = rendererContext.coordinateTransform().destinationCrs();
171  mRasterViewPort->mTransformContext = rendererContext.transformContext();
172  }
173  else
174  {
175  mRasterViewPort->mSrcCRS = QgsCoordinateReferenceSystem(); // will be invalid
176  mRasterViewPort->mDestCRS = QgsCoordinateReferenceSystem(); // will be invalid
177  }
178 
179  // get dimensions of clipped raster image in device coordinate space (this is the size of the viewport)
180  mRasterViewPort->mTopLeftPoint = mapToPixel.transform( myRasterExtent.xMinimum(), myRasterExtent.yMaximum() );
181  mRasterViewPort->mBottomRightPoint = mapToPixel.transform( myRasterExtent.xMaximum(), myRasterExtent.yMinimum() );
182 
183  // align to output device grid, i.e. std::floor/ceil to integers
184  // TODO: this should only be done if paint device is raster - screen, image
185  // for other devices (pdf) it can have floating point origin
186  // we could use floating point for raster devices as well, but respecting the
187  // output device grid should make it more effective as the resampling is done in
188  // the provider anyway
189  mRasterViewPort->mTopLeftPoint.setX( std::floor( mRasterViewPort->mTopLeftPoint.x() ) );
190  mRasterViewPort->mTopLeftPoint.setY( std::floor( mRasterViewPort->mTopLeftPoint.y() ) );
191  mRasterViewPort->mBottomRightPoint.setX( std::ceil( mRasterViewPort->mBottomRightPoint.x() ) );
192  mRasterViewPort->mBottomRightPoint.setY( std::ceil( mRasterViewPort->mBottomRightPoint.y() ) );
193  // recalc myRasterExtent to aligned values
194  myRasterExtent.set(
195  mapToPixel.toMapCoordinates( mRasterViewPort->mTopLeftPoint.x(),
196  mRasterViewPort->mBottomRightPoint.y() ),
197  mapToPixel.toMapCoordinates( mRasterViewPort->mBottomRightPoint.x(),
198  mRasterViewPort->mTopLeftPoint.y() )
199  );
200 
201  //raster viewport top left / bottom right are already rounded to int
202  mRasterViewPort->mWidth = static_cast<qgssize>( std::abs( mRasterViewPort->mBottomRightPoint.x() - mRasterViewPort->mTopLeftPoint.x() ) );
203  mRasterViewPort->mHeight = static_cast<qgssize>( std::abs( mRasterViewPort->mBottomRightPoint.y() - mRasterViewPort->mTopLeftPoint.y() ) );
204 
205 
206  const double dpi = 25.4 * rendererContext.scaleFactor();
207  if ( mProviderCapabilities & QgsRasterDataProvider::DpiDependentData
208  && rendererContext.dpiTarget() >= 0.0 )
209  {
210  const double dpiScaleFactor = rendererContext.dpiTarget() / dpi;
211  mRasterViewPort->mWidth *= dpiScaleFactor;
212  mRasterViewPort->mHeight *= dpiScaleFactor;
213  }
214  else
215  {
216  rendererContext.setDpiTarget( -1.0 );
217  }
218 
219  //the drawable area can start to get very very large when you get down displaying 2x2 or smaller, this is because
220  //mapToPixel.mapUnitsPerPixel() is less then 1,
221  //so we will just get the pixel data and then render these special cases differently in paintImageToCanvas()
222 
223  QgsDebugMsgLevel( QStringLiteral( "mapUnitsPerPixel = %1" ).arg( mapToPixel.mapUnitsPerPixel() ), 3 );
224  QgsDebugMsgLevel( QStringLiteral( "mWidth = %1" ).arg( layer->width() ), 3 );
225  QgsDebugMsgLevel( QStringLiteral( "mHeight = %1" ).arg( layer->height() ), 3 );
226  QgsDebugMsgLevel( QStringLiteral( "myRasterExtent.xMinimum() = %1" ).arg( myRasterExtent.xMinimum() ), 3 );
227  QgsDebugMsgLevel( QStringLiteral( "myRasterExtent.xMaximum() = %1" ).arg( myRasterExtent.xMaximum() ), 3 );
228  QgsDebugMsgLevel( QStringLiteral( "myRasterExtent.yMinimum() = %1" ).arg( myRasterExtent.yMinimum() ), 3 );
229  QgsDebugMsgLevel( QStringLiteral( "myRasterExtent.yMaximum() = %1" ).arg( myRasterExtent.yMaximum() ), 3 );
230 
231  QgsDebugMsgLevel( QStringLiteral( "mTopLeftPoint.x() = %1" ).arg( mRasterViewPort->mTopLeftPoint.x() ), 3 );
232  QgsDebugMsgLevel( QStringLiteral( "mBottomRightPoint.x() = %1" ).arg( mRasterViewPort->mBottomRightPoint.x() ), 3 );
233  QgsDebugMsgLevel( QStringLiteral( "mTopLeftPoint.y() = %1" ).arg( mRasterViewPort->mTopLeftPoint.y() ), 3 );
234  QgsDebugMsgLevel( QStringLiteral( "mBottomRightPoint.y() = %1" ).arg( mRasterViewPort->mBottomRightPoint.y() ), 3 );
235 
236  QgsDebugMsgLevel( QStringLiteral( "mWidth = %1" ).arg( mRasterViewPort->mWidth ), 3 );
237  QgsDebugMsgLevel( QStringLiteral( "mHeight = %1" ).arg( mRasterViewPort->mHeight ), 3 );
238 
239  // /\/\/\ - added to handle zoomed-in rasters
240 
241  // TODO R->mLastViewPort = *mRasterViewPort;
242 
243  // TODO: is it necessary? Probably WMS only?
244  layer->dataProvider()->setDpi( dpi );
245 
246  // copy the whole raster pipe!
247  mPipe = new QgsRasterPipe( *layer->pipe() );
248  QObject::connect( mPipe->provider(), &QgsRasterDataProvider::statusChanged, layer, &QgsRasterLayer::statusChanged );
249  QgsRasterRenderer *rasterRenderer = mPipe->renderer();
250  if ( rasterRenderer
251  && !( rendererContext.flags() & Qgis::RenderContextFlag::RenderPreviewJob )
252  && !( rendererContext.flags() & Qgis::RenderContextFlag::Render3DMap ) )
253  {
254  layer->refreshRendererIfNeeded( rasterRenderer, rendererContext.extent() );
255  }
256 
257  mPipe->evaluateDataDefinedProperties( rendererContext.expressionContext() );
258 
259  const QgsRasterLayerTemporalProperties *temporalProperties = qobject_cast< const QgsRasterLayerTemporalProperties * >( layer->temporalProperties() );
260  if ( temporalProperties->isActive() && renderContext()->isTemporal() )
261  {
262  switch ( temporalProperties->mode() )
263  {
264  case Qgis::RasterTemporalMode::FixedTemporalRange:
265  case Qgis::RasterTemporalMode::RedrawLayerOnly:
266  break;
267 
268  case Qgis::RasterTemporalMode::TemporalRangeFromDataProvider:
269  // in this mode we need to pass on the desired render temporal range to the data provider
270  if ( mPipe->provider()->temporalCapabilities() )
271  {
272  mPipe->provider()->temporalCapabilities()->setRequestedTemporalRange( rendererContext.temporalRange() );
274  }
275  break;
276  }
277  }
278  else if ( mPipe->provider()->temporalCapabilities() )
279  {
280  mPipe->provider()->temporalCapabilities()->setRequestedTemporalRange( QgsDateTimeRange() );
282  }
283 
285 
286  mFeedback->setRenderContext( rendererContext );
287 }
288 
290 {
291  delete mFeedback;
292 
293  delete mRasterViewPort;
294  delete mPipe;
295 }
296 
298 {
299  // Skip rendering of out of view tiles (xyz)
300  if ( !mRasterViewPort || ( renderContext()->testFlag( Qgis::RenderContextFlag::RenderPreviewJob ) &&
301  !( mProviderCapabilities &
302  QgsRasterInterface::Capability::Prefetch ) ) )
303  return true;
304 
305  QElapsedTimer time;
306  time.start();
307  //
308  //
309  // The goal here is to make as many decisions as possible early on (outside of the rendering loop)
310  // so that we can maximise performance of the rendering process. So now we check which drawing
311  // procedure to use :
312  //
313 
314  const QgsScopedQPainterState painterSate( renderContext()->painter() );
315  if ( !mClippingRegions.empty() )
316  {
317  bool needsPainterClipPath = false;
318  const QPainterPath path = QgsMapClippingUtils::calculatePainterClipRegion( mClippingRegions, *renderContext(), QgsMapLayerType::RasterLayer, needsPainterClipPath );
319  if ( needsPainterClipPath )
320  renderContext()->painter()->setClipPath( path, Qt::IntersectClip );
321  }
322 
323  QgsRasterProjector *projector = mPipe->projector();
324  bool restoreOldResamplingStage = false;
325  const Qgis::RasterResamplingStage oldResamplingState = mPipe->resamplingStage();
326 
327  // TODO add a method to interface to get provider and get provider
328  // params in QgsRasterProjector
329  if ( projector )
330  {
331  // Force provider resampling if reprojection is needed
333  mRasterViewPort->mSrcCRS != mRasterViewPort->mDestCRS &&
334  oldResamplingState != Qgis::RasterResamplingStage::Provider )
335  {
336  restoreOldResamplingStage = true;
338  }
339  projector->setCrs( mRasterViewPort->mSrcCRS, mRasterViewPort->mDestCRS, mRasterViewPort->mTransformContext );
340  }
341 
342  // important -- disable SmoothPixmapTransform for raster layer renders. We want individual pixels to be clearly defined!
343  renderContext()->painter()->setRenderHint( QPainter::SmoothPixmapTransform, false );
344 
345  // Drawer to pipe?
346  QgsRasterIterator iterator( mPipe->last() );
347  QgsRasterDrawer drawer( &iterator, renderContext()->dpiTarget() );
348  drawer.draw( renderContext()->painter(), mRasterViewPort, &renderContext()->mapToPixel(), mFeedback );
349 
350  if ( restoreOldResamplingStage )
351  {
352  mPipe->setResamplingStage( oldResamplingState );
353  }
354 
355  const QStringList errors = mFeedback->errors();
356  for ( const QString &error : errors )
357  {
358  mErrors.append( error );
359  }
360 
361  QgsDebugMsgLevel( QStringLiteral( "total raster draw time (ms): %1" ).arg( time.elapsed(), 5 ), 4 );
362  mReadyToCompose = true;
363 
364  return !mFeedback->isCanceled();
365 }
366 
368 {
369  return mFeedback;
370 }
371 
373 {
374  // preview of intermediate raster rendering results requires a temporary output image
376 }
RasterResamplingStage
Stage at which raster resampling occurs.
Definition: qgis.h:502
@ Provider
Resampling occurs in Provider.
@ RenderPreviewJob
Render is a 'canvas preview' render, and shortcuts should be taken to ensure fast rendering.
@ RenderPartialOutput
Whether to make extra effort to update map image with partially rendered layers (better for interacti...
@ Render3DMap
Render is for a 3D map.
This class represents a coordinate reference system (CRS).
Class for doing transforms between two map coordinate systems.
void setBallparkTransformsAreAppropriate(bool appropriate)
Sets whether approximate "ballpark" results are appropriate for this coordinate transform.
bool isValid() const
Returns true if the coordinate transform is valid, ie both the source and destination CRS have been s...
QgsCoordinateReferenceSystem destinationCrs() const
Returns the destination coordinate reference system, which the transform will transform coordinates t...
QgsRectangle transformBoundingBox(const QgsRectangle &rectangle, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward, bool handle180Crossover=false) const SIP_THROW(QgsCsException)
Transforms a rectangle from the source CRS to the destination CRS.
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:66
QString what() const
Definition: qgsexception.h:48
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition: qgsfeedback.h:45
static QList< QgsMapClippingRegion > collectClippingRegionsForLayer(const QgsRenderContext &context, const QgsMapLayer *layer)
Collects the list of map clipping regions from a context which apply to a map layer.
static QPainterPath calculatePainterClipRegion(const QList< QgsMapClippingRegion > &regions, const QgsRenderContext &context, QgsMapLayerType layerType, bool &shouldClip)
Returns a QPainterPath representing the intersection of clipping regions from context which should be...
Base class for utility classes that encapsulate information necessary for rendering of map layers.
bool mReadyToCompose
The flag must be set to false in renderer's constructor if wants to use the smarter map redraws funct...
QStringList errors() const
Returns list of errors (problems) that happened during the rendering.
QgsRenderContext * renderContext()
Returns the render context associated with the renderer.
virtual QgsRectangle extent() const
Returns the extent of the layer.
QgsCoordinateReferenceSystem crs
Definition: qgsmaplayer.h:79
void statusChanged(const QString &status)
Emit a signal with status (e.g. to be caught by QgisApp and display a msg on status bar)
Perform transforms between map coordinates and device coordinates.
Definition: qgsmaptopixel.h:39
int mapHeight() const
Returns current map height in pixels.
void setMapRotation(double degrees, double cx, double cy)
Sets map rotation in degrees (clockwise).
double mapUnitsPerPixel() const
Returns the current map units per pixel.
QgsPointXY toMapCoordinates(int x, int y) const
Transforms device coordinates to map (world) coordinates.
int mapWidth() const
Returns the current map width in pixels.
QgsPointXY transform(const QgsPointXY &p) const
Transforms a point p from map (world) coordinates to device coordinates.
Definition: qgsmaptopixel.h:90
double mapRotation() const
Returns the current map rotation in degrees (clockwise).
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::MessageLevel::Warning, bool notifyUser=true)
Adds a message to the log instance (and creates it if necessary).
A class to represent a 2D point.
Definition: qgspointxy.h:59
void setX(double x) SIP_HOLDGIL
Sets the x value of the point.
Definition: qgspointxy.h:122
double y
Definition: qgspointxy.h:63
Q_GADGET double x
Definition: qgspointxy.h:62
void setY(double y) SIP_HOLDGIL
Sets the y value of the point.
Definition: qgspointxy.h:132
Feedback object tailored for raster block reading.
void setPreviewOnly(bool preview)
set flag whether the block request is for preview purposes only
void setRenderPartialOutput(bool enable)
Set whether our painter is drawing to a temporary image used just by this layer.
void setIntervalHandlingMethod(Qgis::TemporalIntervalMatchMethod method)
Sets the desired method to use when resolving a temporal interval to matching layers or bands in the ...
void setRequestedTemporalRange(const QgsDateTimeRange &range)
Sets the requested temporal range to retrieve when returning data from the associated data provider.
Base class for raster data providers.
virtual QgsRasterDataProvider::ProviderCapabilities providerCapabilities() const
Returns flags containing the supported capabilities of the data provider.
void setDpi(int dpi)
Sets the output device resolution.
@ ProviderHintCanPerformProviderResampling
Provider can perform resampling (to be opposed to post rendering resampling) (since QGIS 3....
void statusChanged(const QString &) const
Emit a message to be displayed on status bar, usually used by network providers (WMS,...
QgsRasterDataProviderTemporalCapabilities * temporalCapabilities() override
Returns the provider's temporal capabilities.
The drawing pipe for raster layers.
void draw(QPainter *p, QgsRasterViewPort *viewPort, const QgsMapToPixel *qgsMapToPixel, QgsRasterBlockFeedback *feedback=nullptr)
Draws raster data.
Iterator for sequentially processing raster cells.
Implementation of threaded rendering for raster layers.
bool render() override
Do the rendering (based on data stored in the class).
QgsRasterLayerRenderer(QgsRasterLayer *layer, QgsRenderContext &rendererContext)
bool forceRasterRender() const override
Returns true if the renderer must be rendered to a raster paint device (e.g.
QgsFeedback * feedback() const override
Access to feedback object of the layer renderer (may be nullptr)
Implementation of map layer temporal properties for raster layers.
Qgis::TemporalIntervalMatchMethod intervalHandlingMethod() const
Returns the desired method to use when resolving a temporal interval to matching layers or bands in t...
Qgis::RasterTemporalMode mode() const
Returns the temporal properties mode.
Represents a raster layer.
int height() const
Returns the height of the (unclipped) raster.
QgsRasterPipe * pipe()
Returns the raster pipe.
void refreshRendererIfNeeded(QgsRasterRenderer *rasterRenderer, const QgsRectangle &extent)
Refresh renderer with new extent, if needed.
QgsMapLayerTemporalProperties * temporalProperties() override
Returns the layer's temporal properties.
bool ignoreExtents() const
If the ignoreExtent flag is set, the layer will also render outside the bounding box reported by the ...
QgsRasterDataProvider * dataProvider() override
Returns the source data provider.
int width() const
Returns the width of the (unclipped) raster.
Contains a pipeline of raster interfaces for sequential raster processing.
Definition: qgsrasterpipe.h:50
QgsRasterDataProvider * provider() const
Returns the data provider interface, or nullptr if no data provider is present in the pipe.
void setResamplingStage(Qgis::RasterResamplingStage stage)
Sets which stage of the pipe should apply resampling.
void evaluateDataDefinedProperties(QgsExpressionContext &context)
Evaluates any data defined properties set on the pipe, applying their results to the corresponding in...
QgsRasterProjector * projector() const
Returns the projector interface, or nullptr if no projector is present in the pipe.
QgsRasterInterface * last() const
Returns last interface in the pipe.
QgsRasterRenderer * renderer() const
Returns the raster renderer interface, or nullptr if no raster renderer is present in the pipe.
Qgis::RasterResamplingStage resamplingStage() const
Returns which stage of the pipe should apply resampling.
QgsRasterProjector implements approximate projection support for it calculates grid of points in sour...
Q_DECL_DEPRECATED void setCrs(const QgsCoordinateReferenceSystem &srcCRS, const QgsCoordinateReferenceSystem &destCRS, int srcDatumTransform=-1, int destDatumTransform=-1)
Sets the source and destination CRS.
Raster renderer pipe that applies colors to a raster.
A rectangle specified with double values.
Definition: qgsrectangle.h:42
QString toString(int precision=16) const
Returns a string representation of form xmin,ymin : xmax,ymax Coordinates will be truncated to the sp...
double yMaximum() const SIP_HOLDGIL
Returns the y maximum value (top side of rectangle).
Definition: qgsrectangle.h:193
double xMaximum() const SIP_HOLDGIL
Returns the x maximum value (right side of rectangle).
Definition: qgsrectangle.h:183
double xMinimum() const SIP_HOLDGIL
Returns the x minimum value (left side of rectangle).
Definition: qgsrectangle.h:188
double yMinimum() const SIP_HOLDGIL
Returns the y minimum value (bottom side of rectangle).
Definition: qgsrectangle.h:198
void set(const QgsPointXY &p1, const QgsPointXY &p2, bool normalize=true)
Sets the rectangle from two QgsPoints.
Definition: qgsrectangle.h:122
void setMinimal() SIP_HOLDGIL
Set a rectangle so that min corner is at max and max corner is at min.
Definition: qgsrectangle.h:172
bool isEmpty() const
Returns true if the rectangle is empty.
Definition: qgsrectangle.h:469
QgsRectangle intersect(const QgsRectangle &rect) const
Returns the intersection with the given rectangle.
Definition: qgsrectangle.h:333
Contains information about the context of a rendering operation.
double scaleFactor() const
Returns the scaling factor for the render to convert painter units to physical sizes.
QPainter * painter()
Returns the destination QPainter for the render operation.
QgsExpressionContext & expressionContext()
Gets the expression context.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
QgsCoordinateTransformContext transformContext() const
Returns the context's coordinate transform context, which stores various information regarding which ...
bool testFlag(Qgis::RenderContextFlag flag) const
Check whether a particular flag is enabled.
void setDpiTarget(double dpi)
Sets the targeted dpi for rendering.
double dpiTarget() const
Returns the targeted DPI for rendering.
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context.
Qgis::RenderContextFlags flags() const
Returns combination of flags used for rendering.
const QgsRectangle & extent() const
When rendering a map layer, calling this method returns the "clipping" extent for the layer (in the l...
Scoped object for saving and restoring a QPainter object's state.
bool isActive() const
Returns true if the temporal property is active.
const QgsDateTimeRange & temporalRange() const
Returns the datetime range for the object.
@ RasterLayer
Raster layer.
unsigned long long qgssize
Qgssize is used instead of size_t, because size_t is stdlib type, unknown by SIP, and it would be har...
Definition: qgis.h:2036
#define QgsDebugMsgLevel(str, level)
Definition: qgslogger.h:39
This class provides details of the viewable area that a raster will be rendered into.
qgssize mHeight
Height, number of rows to be rendered.
QgsCoordinateReferenceSystem mDestCRS
Target coordinate system.
QgsPointXY mBottomRightPoint
Coordinate (in output device coordinate system) of bottom right corner of the part of the raster that...
QgsPointXY mTopLeftPoint
Coordinate (in output device coordinate system) of top left corner of the part of the raster that is ...
QgsCoordinateReferenceSystem mSrcCRS
Source coordinate system.
QgsRectangle mDrawnExtent
Intersection of current map extent and layer extent.
QgsCoordinateTransformContext mTransformContext
Coordinate transform context.
qgssize mWidth
Width, number of columns to be rendered.