Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgsprocessingcontext.h
3 : : ----------------------
4 : : begin : April 2017
5 : : copyright : (C) 2017 by Nyall Dawson
6 : : email : nyall dot dawson at gmail dot com
7 : : ***************************************************************************/
8 : :
9 : : /***************************************************************************
10 : : * *
11 : : * This program is free software; you can redistribute it and/or modify *
12 : : * it under the terms of the GNU General Public License as published by *
13 : : * the Free Software Foundation; either version 2 of the License, or *
14 : : * (at your option) any later version. *
15 : : * *
16 : : ***************************************************************************/
17 : :
18 : : #ifndef QGSPROCESSINGCONTEXT_H
19 : : #define QGSPROCESSINGCONTEXT_H
20 : :
21 : : #include "qgis_core.h"
22 : : #include "qgis.h"
23 : : #include "qgsproject.h"
24 : : #include "qgsexpressioncontext.h"
25 : : #include "qgsfeaturerequest.h"
26 : : #include "qgsmaplayerlistutils.h"
27 : : #include "qgsexception.h"
28 : : #include "qgsprocessingfeedback.h"
29 : : #include "qgsprocessingutils.h"
30 : :
31 : : #include <QThread>
32 : :
33 : : class QgsProcessingLayerPostProcessorInterface;
34 : :
35 : : /**
36 : : * \class QgsProcessingContext
37 : : * \ingroup core
38 : : * \brief Contains information about the context in which a processing algorithm is executed.
39 : : *
40 : : * Contextual information includes settings such as the associated project, and
41 : : * expression context.
42 : : * \since QGIS 3.0
43 : : */
44 : :
45 : : class CORE_EXPORT QgsProcessingContext
46 : : {
47 : : public:
48 : :
49 : : //! Flags that affect how processing algorithms are run
50 : : enum Flag
51 : : {
52 : : // UseSelectionIfPresent = 1 << 0,
53 : : };
54 : : Q_DECLARE_FLAGS( Flags, Flag )
55 : :
56 : : /**
57 : : * Logging level for algorithms to use when pushing feedback messages.
58 : : *
59 : : * \since QGIS 3.20
60 : : */
61 : : enum LogLevel
62 : : {
63 : : DefaultLevel = 0, //!< Default logging level
64 : : Verbose, //!< Verbose logging
65 : : };
66 : :
67 : : /**
68 : : * Constructor for QgsProcessingContext.
69 : : */
70 : : QgsProcessingContext();
71 : :
72 : : //! QgsProcessingContext cannot be copied
73 : : QgsProcessingContext( const QgsProcessingContext &other ) = delete;
74 : : //! QgsProcessingContext cannot be copied
75 : : QgsProcessingContext &operator=( const QgsProcessingContext &other ) = delete;
76 : :
77 : : ~QgsProcessingContext();
78 : :
79 : : /**
80 : : * Copies all settings which are safe for use across different threads from
81 : : * \a other to this context.
82 : : */
83 : 0 : void copyThreadSafeSettings( const QgsProcessingContext &other )
84 : : {
85 : 0 : mFlags = other.mFlags;
86 : 0 : mProject = other.mProject;
87 : 0 : mTransformContext = other.mTransformContext;
88 : 0 : mExpressionContext = other.mExpressionContext;
89 : 0 : mInvalidGeometryCallback = other.mInvalidGeometryCallback;
90 : 0 : mUseDefaultInvalidGeometryCallback = other.mUseDefaultInvalidGeometryCallback;
91 : 0 : mInvalidGeometryCheck = other.mInvalidGeometryCheck;
92 : 0 : mTransformErrorCallback = other.mTransformErrorCallback;
93 : 0 : mDefaultEncoding = other.mDefaultEncoding;
94 : 0 : mFeedback = other.mFeedback;
95 : 0 : mPreferredVectorFormat = other.mPreferredVectorFormat;
96 : 0 : mPreferredRasterFormat = other.mPreferredRasterFormat;
97 : 0 : mEllipsoid = other.mEllipsoid;
98 : 0 : mDistanceUnit = other.mDistanceUnit;
99 : 0 : mAreaUnit = other.mAreaUnit;
100 : 0 : mLogLevel = other.mLogLevel;
101 : 0 : }
102 : :
103 : : /**
104 : : * Returns any flags set in the context.
105 : : * \see setFlags()
106 : : */
107 : : QgsProcessingContext::Flags flags() const { return mFlags; }
108 : :
109 : : /**
110 : : * Sets \a flags for the context.
111 : : * \see flags()
112 : : */
113 : : void setFlags( QgsProcessingContext::Flags flags ) { mFlags = flags; }
114 : :
115 : : /**
116 : : * Returns the project in which the algorithm is being executed.
117 : : * \see setProject()
118 : : */
119 : 0 : QgsProject *project() const { return mProject; }
120 : :
121 : : /**
122 : : * Sets the \a project in which the algorithm will be executed.
123 : : *
124 : : * This also automatically sets the transformContext(), ellipsoid(), distanceUnit() and
125 : : * areaUnit() to match the project's settings.
126 : : *
127 : : * \see project()
128 : : */
129 : : void setProject( QgsProject *project )
130 : : {
131 : : mProject = project;
132 : : if ( mProject )
133 : : {
134 : : mTransformContext = mProject->transformContext();
135 : : if ( mEllipsoid.isEmpty() )
136 : : mEllipsoid = mProject->ellipsoid();
137 : : if ( mDistanceUnit == QgsUnitTypes::DistanceUnknownUnit )
138 : : mDistanceUnit = mProject->distanceUnits();
139 : : if ( mAreaUnit == QgsUnitTypes::AreaUnknownUnit )
140 : : mAreaUnit = mProject->areaUnits();
141 : : }
142 : : }
143 : :
144 : : /**
145 : : * Returns the expression context.
146 : : */
147 : 0 : QgsExpressionContext &expressionContext() { return mExpressionContext; }
148 : :
149 : : /**
150 : : * Returns the expression context.
151 : : */
152 : 0 : SIP_SKIP const QgsExpressionContext &expressionContext() const { return mExpressionContext; }
153 : :
154 : : /**
155 : : * Sets the expression \a context.
156 : : */
157 : 0 : void setExpressionContext( const QgsExpressionContext &context ) { mExpressionContext = context; }
158 : :
159 : : /**
160 : : * Returns the coordinate transform context.
161 : : * \see setTransformContext()
162 : : */
163 : 0 : QgsCoordinateTransformContext transformContext() const { return mTransformContext; }
164 : :
165 : : /**
166 : : * Sets the coordinate transform \a context.
167 : : *
168 : : * Note that setting a project for the context will automatically set the coordinate transform
169 : : * context.
170 : : *
171 : : * \see transformContext()
172 : : */
173 : : void setTransformContext( const QgsCoordinateTransformContext &context ) { mTransformContext = context; }
174 : :
175 : : /**
176 : : * Returns the ellipsoid to use for distance and area calculations.
177 : : *
178 : : * \see setEllipsoid()
179 : : * \since QGIS 3.16
180 : : */
181 : : QString ellipsoid() const;
182 : :
183 : : /**
184 : : * Sets a specified \a ellipsoid to use for distance and area calculations.
185 : : *
186 : : * If not explicitly set, the ellipsoid will default to the project()'s ellipsoid setting.
187 : : *
188 : : * \see ellipsoid()
189 : : * \since QGIS 3.16
190 : : */
191 : : void setEllipsoid( const QString &ellipsoid );
192 : :
193 : : /**
194 : : * Returns the distance unit to use for distance calculations.
195 : : *
196 : : * \see setDistanceUnit()
197 : : * \see areaUnit()
198 : : * \since QGIS 3.16
199 : : */
200 : : QgsUnitTypes::DistanceUnit distanceUnit() const;
201 : :
202 : : /**
203 : : * Sets the \a unit to use for distance calculations.
204 : : *
205 : : * If not explicitly set, the unit will default to the project()'s distance unit setting.
206 : : *
207 : : * \see distanceUnit()
208 : : * \see setAreaUnit()
209 : : * \since QGIS 3.16
210 : : */
211 : : void setDistanceUnit( QgsUnitTypes::DistanceUnit unit );
212 : :
213 : : /**
214 : : * Returns the area unit to use for area calculations.
215 : : *
216 : : * \see setAreaUnit()
217 : : * \see distanceUnit()
218 : : * \since QGIS 3.16
219 : : */
220 : : QgsUnitTypes::AreaUnit areaUnit() const;
221 : :
222 : : /**
223 : : * Sets the \a unit to use for area calculations.
224 : : *
225 : : * If not explicitly set, the unit will default to the project()'s area unit setting.
226 : : *
227 : : * \see areaUnit()
228 : : * \see setDistanceUnit()
229 : : * \since QGIS 3.16
230 : : */
231 : : void setAreaUnit( QgsUnitTypes::AreaUnit areaUnit );
232 : :
233 : : /**
234 : : * Returns the current time range to use for temporal operations.
235 : : *
236 : : * \see setCurrentTimeRange()
237 : : * \since QGIS 3.18
238 : : */
239 : : QgsDateTimeRange currentTimeRange() const;
240 : :
241 : : /**
242 : : * Sets the \a current time range to use for temporal operations.
243 : : *
244 : : * \see currentTimeRange()
245 : : * \since QGIS 3.18
246 : : */
247 : : void setCurrentTimeRange( const QgsDateTimeRange ¤tTimeRange );
248 : :
249 : : /**
250 : : * Returns a reference to the layer store used for storing temporary layers during
251 : : * algorithm execution.
252 : : */
253 : 0 : QgsMapLayerStore *temporaryLayerStore() { return &tempLayerStore; }
254 : :
255 : : /**
256 : : * \brief Details for layers to load into projects.
257 : : * \ingroup core
258 : : * \since QGIS 3.0
259 : : */
260 : 0 : class CORE_EXPORT LayerDetails
261 : : {
262 : : public:
263 : :
264 : : /**
265 : : * Constructor for LayerDetails.
266 : : */
267 : 0 : LayerDetails( const QString &name, QgsProject *project, const QString &outputName = QString(), QgsProcessingUtils::LayerHint layerTypeHint = QgsProcessingUtils::LayerHint::UnknownType )
268 : 0 : : name( name )
269 : 0 : , outputName( outputName )
270 : 0 : , layerTypeHint( layerTypeHint )
271 : 0 : , project( project )
272 : 0 : {}
273 : :
274 : : //! Default constructor
275 : 0 : LayerDetails() = default;
276 : :
277 : : /**
278 : : * Friendly name for layer, possibly for use when loading layer into project.
279 : : *
280 : : * \warning Instead of directly using this value, prefer to call setOutputLayerName() to
281 : : * generate a layer name which respects the user's local Processing settings.
282 : : */
283 : : QString name;
284 : :
285 : : /**
286 : : * Set to TRUE if LayerDetails::name should always be used as the loaded layer name, regardless
287 : : * of the user's local Processing settings.
288 : : * \since QGIS 3.16
289 : : */
290 : 0 : bool forceName = false;
291 : :
292 : : /**
293 : : * Associated output name from algorithm which generated the layer.
294 : : */
295 : : QString outputName;
296 : :
297 : : /**
298 : : * Layer type hint.
299 : : *
300 : : * \since QGIS 3.4
301 : : */
302 : 0 : QgsProcessingUtils::LayerHint layerTypeHint = QgsProcessingUtils::LayerHint::UnknownType;
303 : :
304 : : /**
305 : : * Layer post-processor. May be NULLPTR if no post-processing is required.
306 : : * \see setPostProcessor()
307 : : * \since QGIS 3.2
308 : : */
309 : : QgsProcessingLayerPostProcessorInterface *postProcessor() const;
310 : :
311 : : /**
312 : : * Sets the layer post-processor. May be NULLPTR if no post-processing is required.
313 : : *
314 : : * Ownership of \a processor is transferred.
315 : : *
316 : : * \see postProcessor()
317 : : * \since QGIS 3.2
318 : : */
319 : : void setPostProcessor( QgsProcessingLayerPostProcessorInterface *processor SIP_TRANSFER );
320 : :
321 : : /**
322 : : * Sets a \a layer name to match this output, respecting any local user settings which affect this name.
323 : : *
324 : : * \since QGIS 3.10.1
325 : : */
326 : : void setOutputLayerName( QgsMapLayer *layer ) const;
327 : :
328 : : //! Destination project
329 : 0 : QgsProject *project = nullptr;
330 : :
331 : : private:
332 : :
333 : : // Ideally a unique_ptr, but cannot be due to use within QMap. Is cleaned up by QgsProcessingContext.
334 : 0 : QgsProcessingLayerPostProcessorInterface *mPostProcessor = nullptr;
335 : :
336 : : };
337 : :
338 : : /**
339 : : * Returns a map of layers (by ID or datasource) to LayerDetails, to load into the canvas upon completion of the algorithm or model.
340 : : * \see setLayersToLoadOnCompletion()
341 : : * \see addLayerToLoadOnCompletion()
342 : : * \see willLoadLayerOnCompletion()
343 : : * \see layerToLoadOnCompletionDetails()
344 : : */
345 : : QMap< QString, QgsProcessingContext::LayerDetails > layersToLoadOnCompletion() const
346 : : {
347 : : return mLayersToLoadOnCompletion;
348 : : }
349 : :
350 : : /**
351 : : * Returns TRUE if the given \a layer (by ID or datasource) will be loaded into the current project
352 : : * upon completion of the algorithm or model.
353 : : * \see layersToLoadOnCompletion()
354 : : * \see setLayersToLoadOnCompletion()
355 : : * \see addLayerToLoadOnCompletion()
356 : : * \see layerToLoadOnCompletionDetails()
357 : : * \since QGIS 3.2
358 : : */
359 : 0 : bool willLoadLayerOnCompletion( const QString &layer ) const
360 : : {
361 : 0 : return mLayersToLoadOnCompletion.contains( layer );
362 : : }
363 : :
364 : : /**
365 : : * Sets the map of \a layers (by ID or datasource) to LayerDetails, to load into the canvas upon completion of the algorithm or model.
366 : : * \see addLayerToLoadOnCompletion()
367 : : * \see layersToLoadOnCompletion()
368 : : * \see willLoadLayerOnCompletion()
369 : : * \see layerToLoadOnCompletionDetails()
370 : : */
371 : : void setLayersToLoadOnCompletion( const QMap< QString, QgsProcessingContext::LayerDetails > &layers );
372 : :
373 : : /**
374 : : * Adds a \a layer to load (by ID or datasource) into the canvas upon completion of the algorithm or model.
375 : : * The \a details parameter dictates the LayerDetails.
376 : : * \see setLayersToLoadOnCompletion()
377 : : * \see layersToLoadOnCompletion()
378 : : * \see willLoadLayerOnCompletion()
379 : : * \see layerToLoadOnCompletionDetails()
380 : : */
381 : : void addLayerToLoadOnCompletion( const QString &layer, const QgsProcessingContext::LayerDetails &details );
382 : :
383 : : /**
384 : : * Returns a reference to the details for a given \a layer which is loaded on completion of the
385 : : * algorithm or model.
386 : : *
387 : : * \warning First check willLoadLayerOnCompletion(), or calling this method will incorrectly
388 : : * add \a layer as a layer to load on completion.
389 : : *
390 : : * \see willLoadLayerOnCompletion()
391 : : * \see addLayerToLoadOnCompletion()
392 : : * \see setLayersToLoadOnCompletion()
393 : : * \see layersToLoadOnCompletion()
394 : : * \since QGIS 3.2
395 : : */
396 : 0 : QgsProcessingContext::LayerDetails &layerToLoadOnCompletionDetails( const QString &layer )
397 : : {
398 : 0 : return mLayersToLoadOnCompletion[ layer ];
399 : : }
400 : :
401 : : /**
402 : : * Returns the behavior used for checking invalid geometries in input layers.
403 : : * \see setInvalidGeometryCheck()
404 : : */
405 : 0 : QgsFeatureRequest::InvalidGeometryCheck invalidGeometryCheck() const { return mInvalidGeometryCheck; }
406 : :
407 : : /**
408 : : * Sets the behavior used for checking invalid geometries in input layers.
409 : : * Settings this to anything but QgsFeatureRequest::GeometryNoCheck will also
410 : : * reset the invalidGeometryCallback() to a default implementation.
411 : : * \see invalidGeometryCheck()
412 : : */
413 : : void setInvalidGeometryCheck( QgsFeatureRequest::InvalidGeometryCheck check );
414 : :
415 : : /**
416 : : * Sets a callback function to use when encountering an invalid geometry and
417 : : * invalidGeometryCheck() is set to GeometryAbortOnInvalid. This function will be
418 : : * called using the feature with invalid geometry as a parameter.
419 : : * \see invalidGeometryCallback()
420 : : * \since QGIS 3.0
421 : : */
422 : : #ifndef SIP_RUN
423 : : void setInvalidGeometryCallback( const std::function< void( const QgsFeature & ) > &callback ) { mInvalidGeometryCallback = callback; mUseDefaultInvalidGeometryCallback = false; }
424 : : #else
425 : : void setInvalidGeometryCallback( SIP_PYCALLABLE / AllowNone / );
426 : : % MethodCode
427 : : Py_BEGIN_ALLOW_THREADS
428 : :
429 : : sipCpp->setInvalidGeometryCallback( [a0]( const QgsFeature &arg )
430 : : {
431 : : SIP_BLOCK_THREADS
432 : : Py_XDECREF( sipCallMethod( NULL, a0, "D", &arg, sipType_QgsFeature, NULL ) );
433 : : SIP_UNBLOCK_THREADS
434 : : } );
435 : :
436 : : Py_END_ALLOW_THREADS
437 : : % End
438 : : #endif
439 : :
440 : : /**
441 : : * Returns the callback function to use when encountering an invalid geometry and
442 : : * invalidGeometryCheck() is set to GeometryAbortOnInvalid.
443 : : * \note not available in Python bindings
444 : : * \see setInvalidGeometryCallback()
445 : : * \since QGIS 3.0
446 : : */
447 : : SIP_SKIP std::function< void( const QgsFeature & ) > invalidGeometryCallback( QgsFeatureSource *source = nullptr ) const;
448 : :
449 : : /**
450 : : * Returns the default callback function to use for a particular invalid geometry \a check
451 : : * \note not available in Python bindings
452 : : * \since QGIS 3.14
453 : : */
454 : : SIP_SKIP std::function< void( const QgsFeature & ) > defaultInvalidGeometryCallbackForCheck( QgsFeatureRequest::InvalidGeometryCheck check, QgsFeatureSource *source = nullptr ) const;
455 : :
456 : : /**
457 : : * Sets a callback function to use when encountering a transform error when iterating
458 : : * features. This function will be
459 : : * called using the feature which encountered the transform error as a parameter.
460 : : * \see transformErrorCallback()
461 : : * \since QGIS 3.0
462 : : */
463 : : #ifndef SIP_RUN
464 : : void setTransformErrorCallback( const std::function< void( const QgsFeature & ) > &callback ) { mTransformErrorCallback = callback; }
465 : : #else
466 : : void setTransformErrorCallback( SIP_PYCALLABLE / AllowNone / );
467 : : % MethodCode
468 : : Py_BEGIN_ALLOW_THREADS
469 : :
470 : : sipCpp->setTransformErrorCallback( [a0]( const QgsFeature &arg )
471 : : {
472 : : SIP_BLOCK_THREADS
473 : : Py_XDECREF( sipCallMethod( NULL, a0, "D", &arg, sipType_QgsFeature, NULL ) );
474 : : SIP_UNBLOCK_THREADS
475 : : } );
476 : :
477 : : Py_END_ALLOW_THREADS
478 : : % End
479 : : #endif
480 : :
481 : : /**
482 : : * Returns the callback function to use when encountering a transform error when iterating
483 : : * features.
484 : : * \note not available in Python bindings
485 : : * \see setTransformErrorCallback()
486 : : * \since QGIS 3.0
487 : : */
488 : 0 : std::function< void( const QgsFeature & ) > transformErrorCallback() const { return mTransformErrorCallback; } SIP_SKIP
489 : :
490 : : /**
491 : : * Returns the default encoding to use for newly created files.
492 : : * \see setDefaultEncoding()
493 : : */
494 : 0 : QString defaultEncoding() const { return mDefaultEncoding; }
495 : :
496 : : /**
497 : : * Sets the default \a encoding to use for newly created files.
498 : : * \see defaultEncoding()
499 : : */
500 : : void setDefaultEncoding( const QString &encoding ) { mDefaultEncoding = encoding; }
501 : :
502 : : /**
503 : : * Returns the associated feedback object.
504 : : * \see setFeedback()
505 : : */
506 : 0 : QgsProcessingFeedback *feedback() { return mFeedback; }
507 : :
508 : : /**
509 : : * Sets an associated \a feedback object. This allows context related functions
510 : : * to report feedback and errors to users and processing logs. While ideally this feedback
511 : : * object should outlive the context, only a weak pointer to \a feedback is stored
512 : : * and no errors will occur if feedback is deleted before the context.
513 : : * Ownership of \a feedback is not transferred.
514 : : * \see setFeedback()
515 : : */
516 : : void setFeedback( QgsProcessingFeedback *feedback ) { mFeedback = feedback; }
517 : :
518 : : /**
519 : : * Returns the thread in which the context lives.
520 : : * \see pushToThread()
521 : : */
522 : 0 : QThread *thread() { return tempLayerStore.thread(); }
523 : :
524 : : /**
525 : : * Pushes the thread affinity for the context (including all layers contained in the temporaryLayerStore()) into
526 : : * another \a thread. This method is only safe to call when the current thread matches the existing thread
527 : : * affinity for the context (see thread()).
528 : : * \see thread()
529 : : */
530 : 0 : void pushToThread( QThread *thread )
531 : : {
532 : : // cppcheck-suppress assertWithSideEffect
533 : : Q_ASSERT_X( QThread::currentThread() == QgsProcessingContext::thread(), "QgsProcessingContext::pushToThread", "Cannot push context to another thread unless the current thread matches the existing context thread affinity" );
534 : 0 : tempLayerStore.moveToThread( thread );
535 : 0 : }
536 : :
537 : : /**
538 : : * Takes the results from another \a context and merges them with the results currently
539 : : * stored in this context. This includes settings like any layers loaded in the temporaryLayerStore()
540 : : * and layersToLoadOnCompletion().
541 : : * This is only safe to call when both this context and the other \a context share the same
542 : : * thread() affinity, and that thread is the current thread.
543 : : */
544 : : void takeResultsFrom( QgsProcessingContext &context );
545 : :
546 : : /**
547 : : * Returns a map layer from the context with a matching \a identifier.
548 : : * This method considers layer IDs, names and sources when matching
549 : : * the \a identifier (see QgsProcessingUtils::mapLayerFromString()
550 : : * for details).
551 : : *
552 : : * Ownership is not transferred and remains with the context.
553 : : *
554 : : * \see takeResultLayer()
555 : : */
556 : : QgsMapLayer *getMapLayer( const QString &identifier );
557 : :
558 : : /**
559 : : * Takes the result map layer with matching \a id from the context and
560 : : * transfers ownership of it back to the caller. This method can be used
561 : : * to remove temporary layers which are not required for further processing
562 : : * from a context.
563 : : *
564 : : * \see getMapLayer()
565 : : */
566 : : QgsMapLayer *takeResultLayer( const QString &id ) SIP_TRANSFERBACK;
567 : :
568 : : /**
569 : : * Returns the preferred vector format to use for vector outputs.
570 : : *
571 : : * This method returns a file extension to use when creating vector outputs (e.g. "shp"). Generally,
572 : : * it is preferable to use the extension associated with a particular parameter, which can be retrieved through
573 : : * QgsProcessingDestinationParameter::defaultFileExtension(). However, in some cases, a specific parameter
574 : : * may not be available to call this method on (e.g. for an algorithm which has only an output folder parameter
575 : : * and which creates multiple output layers in that folder). In this case, the format returned by this
576 : : * function should be used when creating these outputs.
577 : : *
578 : : * It is the algorithm's responsibility to check whether the returned format is acceptable for the algorithm,
579 : : * and to provide an appropriate fallback when the returned format is not usable.
580 : : *
581 : : * \see setPreferredVectorFormat()
582 : : * \see preferredRasterFormat()
583 : : *
584 : : * \since QGIS 3.10
585 : : */
586 : 0 : QString preferredVectorFormat() const { return mPreferredVectorFormat; }
587 : :
588 : : /**
589 : : * Sets the preferred vector \a format to use for vector outputs.
590 : : *
591 : : * This method sets a file extension to use when creating vector outputs (e.g. "shp"). Generally,
592 : : * it is preferable to use the extension associated with a particular parameter, which can be retrieved through
593 : : * QgsProcessingDestinationParameter::defaultFileExtension(). However, in some cases, a specific parameter
594 : : * may not be available to call this method on (e.g. for an algorithm which has only an output folder parameter
595 : : * and which creates multiple output layers in that folder). In this case, the format set by this
596 : : * function will be used when creating these outputs.
597 : : *
598 : : * \see preferredVectorFormat()
599 : : * \see setPreferredRasterFormat()
600 : : *
601 : : * \since QGIS 3.10
602 : : */
603 : : void setPreferredVectorFormat( const QString &format ) { mPreferredVectorFormat = format; }
604 : :
605 : : /**
606 : : * Returns the preferred raster format to use for vector outputs.
607 : : *
608 : : * This method returns a file extension to use when creating raster outputs (e.g. "tif"). Generally,
609 : : * it is preferable to use the extension associated with a particular parameter, which can be retrieved through
610 : : * QgsProcessingDestinationParameter::defaultFileExtension(). However, in some cases, a specific parameter
611 : : * may not be available to call this method on (e.g. for an algorithm which has only an output folder parameter
612 : : * and which creates multiple output layers in that folder). In this case, the format returned by this
613 : : * function should be used when creating these outputs.
614 : : *
615 : : * It is the algorithm's responsibility to check whether the returned format is acceptable for the algorithm,
616 : : * and to provide an appropriate fallback when the returned format is not usable.
617 : : *
618 : : * \see setPreferredRasterFormat()
619 : : * \see preferredVectorFormat()
620 : : *
621 : : * \since QGIS 3.10
622 : : */
623 : : QString preferredRasterFormat() const { return mPreferredRasterFormat; }
624 : :
625 : : /**
626 : : * Sets the preferred raster \a format to use for vector outputs.
627 : : *
628 : : * This method sets a file extension to use when creating raster outputs (e.g. "tif"). Generally,
629 : : * it is preferable to use the extension associated with a particular parameter, which can be retrieved through
630 : : * QgsProcessingDestinationParameter::defaultFileExtension(). However, in some cases, a specific parameter
631 : : * may not be available to call this method on (e.g. for an algorithm which has only an output folder parameter
632 : : * and which creates multiple output layers in that folder). In this case, the format set by this
633 : : * function will be used when creating these outputs.
634 : : *
635 : : * \see preferredRasterFormat()
636 : : * \see setPreferredVectorFormat()
637 : : *
638 : : * \since QGIS 3.10
639 : : */
640 : : void setPreferredRasterFormat( const QString &format ) { mPreferredRasterFormat = format; }
641 : :
642 : : /**
643 : : * Returns the logging level for algorithms to use when pushing feedback messages to users.
644 : : *
645 : : * \see setLogLevel()
646 : : * \since QGIS 3.20
647 : : */
648 : : LogLevel logLevel() const;
649 : :
650 : : /**
651 : : * Sets the logging \a level for algorithms to use when pushing feedback messages to users.
652 : : *
653 : : * \see logLevel()
654 : : * \since QGIS 3.20
655 : : */
656 : : void setLogLevel( LogLevel level );
657 : :
658 : : private:
659 : :
660 : : QgsProcessingContext::Flags mFlags = QgsProcessingContext::Flags();
661 : : QPointer< QgsProject > mProject;
662 : : QgsCoordinateTransformContext mTransformContext;
663 : :
664 : : QString mEllipsoid;
665 : : QgsUnitTypes::DistanceUnit mDistanceUnit = QgsUnitTypes::DistanceUnknownUnit;
666 : : QgsUnitTypes::AreaUnit mAreaUnit = QgsUnitTypes::AreaUnknownUnit;
667 : :
668 : : QgsDateTimeRange mCurrentTimeRange;
669 : :
670 : : //! Temporary project owned by the context, used for storing temporarily loaded map layers
671 : : QgsMapLayerStore tempLayerStore;
672 : : QgsExpressionContext mExpressionContext;
673 : :
674 : : QgsFeatureRequest::InvalidGeometryCheck mInvalidGeometryCheck = QgsFeatureRequest::GeometryNoCheck;
675 : : bool mUseDefaultInvalidGeometryCallback = true;
676 : : std::function< void( const QgsFeature & ) > mInvalidGeometryCallback;
677 : :
678 : : std::function< void( const QgsFeature & ) > mTransformErrorCallback;
679 : : QString mDefaultEncoding;
680 : : QMap< QString, LayerDetails > mLayersToLoadOnCompletion;
681 : :
682 : : QPointer< QgsProcessingFeedback > mFeedback;
683 : :
684 : : QString mPreferredVectorFormat;
685 : : QString mPreferredRasterFormat;
686 : :
687 : : LogLevel mLogLevel = DefaultLevel;
688 : :
689 : : #ifdef SIP_RUN
690 : : QgsProcessingContext( const QgsProcessingContext &other );
691 : : #endif
692 : : };
693 : :
694 : : Q_DECLARE_OPERATORS_FOR_FLAGS( QgsProcessingContext::Flags )
695 : :
696 : :
697 : : /**
698 : : * \brief An interface for layer post-processing handlers for execution following a processing algorithm operation.
699 : : *
700 : : * Note that post-processing of a layer will ONLY occur if that layer is set to be loaded into a QGIS project
701 : : * on algorithm completion. See QgsProcessingContext::layersToLoadOnCompletion().
702 : : *
703 : : * Algorithms that wish to set post-processing steps for generated layers should implement this interface
704 : : * in a separate class (NOT the algorithm class itself!).
705 : : *
706 : : * \ingroup core
707 : : * \since QGIS 3.2
708 : : */
709 : 0 : class CORE_EXPORT QgsProcessingLayerPostProcessorInterface
710 : : {
711 : : public:
712 : :
713 : 0 : virtual ~QgsProcessingLayerPostProcessorInterface() = default;
714 : :
715 : : /**
716 : : * Post-processes the specified \a layer, following successful execution of a processing algorithm. This method
717 : : * always runs in the main thread and can be used to setup renderers, editor widgets, metadata, etc for
718 : : * the given layer.
719 : : *
720 : : * Post-processing classes can utilize settings from the algorithm's \a context and report logging messages
721 : : * or errors via the given \a feedback object.
722 : : *
723 : : * In the case of an algorithm run as part of a larger model, the post-processing occurs following the completed
724 : : * execution of the entire model.
725 : : *
726 : : * Note that post-processing of a layer will ONLY occur if that layer is set to be loaded into a QGIS project
727 : : * on algorithm completion. See QgsProcessingContext::layersToLoadOnCompletion().
728 : : */
729 : : virtual void postProcessLayer( QgsMapLayer *layer, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) = 0;
730 : :
731 : : };
732 : :
733 : :
734 : : #endif // QGSPROCESSINGPARAMETERS_H
735 : :
736 : :
737 : :
738 : :
|
