QGIS API Documentation 3.31.0-Master (d2b117a3c8)
qgsprocessingalgorithm.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsprocessingalgorithm.cpp
3 --------------------------
4 begin : December 2016
5 copyright : (C) 2016 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
19#include "qgsapplication.h"
23#include "qgsrectangle.h"
25#include "qgsprocessingutils.h"
26#include "qgsexception.h"
27#include "qgsmessagelog.h"
28#include "qgsvectorlayer.h"
30#include "qgsmeshlayer.h"
31#include "qgspointcloudlayer.h"
33#include <QRegularExpression>
34#include <QRegularExpressionMatch>
35
37{
38 qDeleteAll( mParameters );
39 qDeleteAll( mOutputs );
40}
41
42QgsProcessingAlgorithm *QgsProcessingAlgorithm::create( const QVariantMap &configuration ) const
43{
44 std::unique_ptr< QgsProcessingAlgorithm > creation( createInstance() );
45 if ( ! creation )
46 throw QgsProcessingException( QObject::tr( "Error creating algorithm from createInstance()" ) );
47 creation->setProvider( provider() );
48 creation->initAlgorithm( configuration );
49 return creation.release();
50}
51
53{
54 if ( mProvider )
55 return QStringLiteral( "%1:%2" ).arg( mProvider->id(), name() );
56 else
57 return name();
58}
59
61{
62 return QString();
63}
64
66{
67 return QString();
68}
69
71{
72 return QString();
73}
74
76{
77 return QString();
78}
79
81{
82 return QgsApplication::getThemeIcon( "/processingAlgorithm.svg" );
83}
84
86{
87 return QgsApplication::iconPath( QStringLiteral( "processingAlgorithm.svg" ) );
88}
89
90QgsProcessingAlgorithm::Flags QgsProcessingAlgorithm::flags() const
91{
93}
94
96{
97 return true;
98}
99
100bool QgsProcessingAlgorithm::checkParameterValues( const QVariantMap &parameters, QgsProcessingContext &context, QString *message ) const
101{
102 for ( const QgsProcessingParameterDefinition *def : mParameters )
103 {
104 if ( !def->checkValueIsAcceptable( parameters.value( def->name() ), &context ) )
105 {
106 if ( message )
107 {
108 // TODO QGIS 4 - move the message handling to the parameter subclasses (but this
109 // requires a change in signature for the virtual checkValueIsAcceptable method)
111 *message = invalidSourceError( parameters, def->name() );
112 else if ( def->type() == QgsProcessingParameterFeatureSink::typeName() )
113 *message = invalidSinkError( parameters, def->name() );
114 else if ( def->type() == QgsProcessingParameterRasterLayer::typeName() )
115 *message = invalidRasterError( parameters, def->name() );
116 else if ( def->type() == QgsProcessingParameterPointCloudLayer::typeName() )
117 *message = invalidPointCloudError( parameters, def->name() );
118 else
119 *message = QObject::tr( "Incorrect parameter value for %1" ).arg( def->name() );
120 }
121 return false;
122 }
123 }
124 return true;
125}
126
127QVariantMap QgsProcessingAlgorithm::preprocessParameters( const QVariantMap &parameters )
128{
129 return parameters;
130}
131
133{
134 return mProvider;
135}
136
138{
139 mProvider = provider;
140
141 if ( mProvider && !mProvider->supportsNonFileBasedOutput() )
142 {
143 // need to update all destination parameters to turn off non file based outputs
144 for ( const QgsProcessingParameterDefinition *definition : std::as_const( mParameters ) )
145 {
146 if ( definition->isDestination() )
147 {
148 const QgsProcessingDestinationParameter *destParam = static_cast< const QgsProcessingDestinationParameter *>( definition );
149 const_cast< QgsProcessingDestinationParameter *>( destParam )->setSupportsNonFileBasedOutput( false );
150 }
151 }
152 }
153}
154
156{
157 return nullptr;
158}
159
161 QgsProcessingContext &context, QgsProcessingFeatureSource *source ) const
162{
163 // start with context's expression context
165
166 // If there's a source capable of generating a context scope, use it
167 if ( source )
168 {
170 if ( scope )
171 c << scope;
172 }
173 else if ( c.scopeCount() == 0 )
174 {
175 //empty scope, populate with initial scopes
178 }
179
180 c << QgsExpressionContextUtils::processingAlgorithmScope( this, parameters, context );
181 return c;
182}
183
184bool QgsProcessingAlgorithm::validateInputCrs( const QVariantMap &parameters, QgsProcessingContext &context ) const
185{
186 if ( !( flags() & FlagRequiresMatchingCrs ) )
187 {
188 // I'm a well behaved algorithm - I take work AWAY from users!
189 return true;
190 }
191
192 bool foundCrs = false;
194 for ( const QgsProcessingParameterDefinition *def : mParameters )
195 {
197 {
198 QgsMapLayer *layer = QgsProcessingParameters::parameterAsLayer( def, parameters, context );
199 if ( layer )
200 {
201 if ( foundCrs && layer->crs().isValid() && crs != layer->crs() )
202 {
203 return false;
204 }
205 else if ( !foundCrs && layer->crs().isValid() )
206 {
207 foundCrs = true;
208 crs = layer->crs();
209 }
210 }
211 }
212 else if ( def->type() == QgsProcessingParameterFeatureSource::typeName() )
213 {
214 std::unique_ptr< QgsFeatureSource > source( QgsProcessingParameters::parameterAsSource( def, parameters, context ) );
215 if ( source )
216 {
217 if ( foundCrs && source->sourceCrs().isValid() && crs != source->sourceCrs() )
218 {
219 return false;
220 }
221 else if ( !foundCrs && source->sourceCrs().isValid() )
222 {
223 foundCrs = true;
224 crs = source->sourceCrs();
225 }
226 }
227 }
228 else if ( def->type() == QgsProcessingParameterMultipleLayers::typeName() )
229 {
230 QList< QgsMapLayer *> layers = QgsProcessingParameters::parameterAsLayerList( def, parameters, context );
231 const auto constLayers = layers;
232 for ( QgsMapLayer *layer : constLayers )
233 {
234 if ( !layer )
235 continue;
236
237 if ( foundCrs && layer->crs().isValid() && crs != layer->crs() )
238 {
239 return false;
240 }
241 else if ( !foundCrs && layer->crs().isValid() )
242 {
243 foundCrs = true;
244 crs = layer->crs();
245 }
246 }
247 }
248 else if ( def->type() == QgsProcessingParameterExtent::typeName() )
249 {
251 if ( foundCrs && extentCrs.isValid() && crs != extentCrs )
252 {
253 return false;
254 }
255 else if ( !foundCrs && extentCrs.isValid() )
256 {
257 foundCrs = true;
258 crs = extentCrs;
259 }
260 }
261 else if ( def->type() == QgsProcessingParameterPoint::typeName() )
262 {
264 if ( foundCrs && pointCrs.isValid() && crs != pointCrs )
265 {
266 return false;
267 }
268 else if ( !foundCrs && pointCrs.isValid() )
269 {
270 foundCrs = true;
271 crs = pointCrs;
272 }
273 }
274 else if ( def->type() == QgsProcessingParameterGeometry::typeName() )
275 {
277 if ( foundCrs && geomCrs.isValid() && crs != geomCrs )
278 {
279 return false;
280 }
281 else if ( !foundCrs && geomCrs.isValid() )
282 {
283 foundCrs = true;
284 crs = geomCrs;
285 }
286 }
287
288 }
289 return true;
290}
291
292QString QgsProcessingAlgorithm::asPythonCommand( const QVariantMap &parameters, QgsProcessingContext &context ) const
293{
294 QString s = QStringLiteral( "processing.run(\"%1\"," ).arg( id() );
295
296 QStringList parts;
297 for ( const QgsProcessingParameterDefinition *def : mParameters )
298 {
300 continue;
301
302 if ( !parameters.contains( def->name() ) )
303 continue;
304
305 parts << QStringLiteral( "'%1':%2" ).arg( def->name(), def->valueAsPythonString( parameters.value( def->name() ), context ) );
306 }
307
308 s += QStringLiteral( " {%1})" ).arg( parts.join( ',' ) );
309 return s;
310}
311
312QString QgsProcessingAlgorithm::asQgisProcessCommand( const QVariantMap &parameters, QgsProcessingContext &context, bool &ok ) const
313{
314 ok = true;
315 QStringList parts;
316 parts.append( QStringLiteral( "qgis_process" ) );
317 parts.append( QStringLiteral( "run" ) );
318 parts.append( id() );
319
320 QgsProcessingContext::ProcessArgumentFlags argumentFlags;
321 // we only include the project path argument if a project is actually required by the algorithm
322 if ( flags() & FlagRequiresProject )
324
325 parts.append( context.asQgisProcessArguments( argumentFlags ) );
326
327 auto escapeIfNeeded = []( const QString & input ) -> QString
328 {
329 // play it safe and escape everything UNLESS it's purely alphanumeric characters (and a very select scattering of other common characters!)
330 const thread_local QRegularExpression nonAlphaNumericRx( QStringLiteral( "[^a-zA-Z0-9.\\-/_]" ) );
331 if ( nonAlphaNumericRx.match( input ).hasMatch() )
332 {
333 QString escaped = input;
334 escaped.replace( '\'', QLatin1String( "'\\''" ) );
335 return QStringLiteral( "'%1'" ).arg( escaped );
336 }
337 else
338 {
339 return input;
340 }
341 };
342
343 for ( const QgsProcessingParameterDefinition *def : mParameters )
344 {
346 continue;
347
348 if ( !parameters.contains( def->name() ) )
349 continue;
350
351 const QStringList partValues = def->valueAsStringList( parameters.value( def->name() ), context, ok );
352 if ( !ok )
353 return QString();
354
355 for ( const QString &partValue : partValues )
356 {
357 parts << QStringLiteral( "--%1=%2" ).arg( def->name(), escapeIfNeeded( partValue ) );
358 }
359 }
360
361 return parts.join( ' ' );
362}
363
364QVariantMap QgsProcessingAlgorithm::asMap( const QVariantMap &parameters, QgsProcessingContext &context ) const
365{
366 QVariantMap properties = context.exportToMap();
367
368 // we only include the project path argument if a project is actually required by the algorithm
369 if ( !( flags() & FlagRequiresProject ) )
370 properties.remove( QStringLiteral( "project_path" ) );
371
372 QVariantMap paramValues;
373 for ( const QgsProcessingParameterDefinition *def : mParameters )
374 {
376 continue;
377
378 if ( !parameters.contains( def->name() ) )
379 continue;
380
381 paramValues.insert( def->name(), def->valueAsJsonObject( parameters.value( def->name() ), context ) );
382 }
383
384 properties.insert( QStringLiteral( "inputs" ), paramValues );
385 return properties;
386}
387
389{
390 if ( !definition )
391 return false;
392
393 // check for duplicate named parameters
395 if ( existingDef && existingDef->name() == definition->name() ) // parameterDefinition is case-insensitive, but we DO allow case-different duplicate names
396 {
397 QgsMessageLog::logMessage( QObject::tr( "Duplicate parameter %1 registered for alg %2" ).arg( definition->name(), id() ), QObject::tr( "Processing" ) );
398 delete definition;
399 return false;
400 }
401
402 if ( definition->isDestination() && mProvider )
403 {
404 QgsProcessingDestinationParameter *destParam = static_cast< QgsProcessingDestinationParameter *>( definition );
405 if ( !mProvider->supportsNonFileBasedOutput() )
406 destParam->setSupportsNonFileBasedOutput( false );
407 }
408
409 mParameters << definition;
410 definition->mAlgorithm = this;
411
412 if ( createOutput )
413 return createAutoOutputForParameter( definition );
414 else
415 return true;
416}
417
419{
421 if ( def )
422 {
423 delete def;
424 mParameters.removeAll( def );
425
426 // remove output automatically created when adding parameter
428 if ( outputDef && outputDef->autoCreated() )
429 {
430 delete outputDef;
431 mOutputs.removeAll( outputDef );
432 }
433 }
434}
435
437{
438 if ( !definition )
439 return false;
440
441 // check for duplicate named outputs
442 if ( QgsProcessingAlgorithm::outputDefinition( definition->name() ) )
443 {
444 QgsMessageLog::logMessage( QObject::tr( "Duplicate output %1 registered for alg %2" ).arg( definition->name(), id() ), QObject::tr( "Processing" ) );
445 delete definition;
446 return false;
447 }
448
449 mOutputs << definition;
450 return true;
451}
452
454{
455 return true;
456}
457
459{
460 return QVariantMap();
461}
462
464{
465 // first pass - case sensitive match
466 for ( const QgsProcessingParameterDefinition *def : mParameters )
467 {
468 if ( def->name() == name )
469 return def;
470 }
471
472 // second pass - case insensitive
473 for ( const QgsProcessingParameterDefinition *def : mParameters )
474 {
475 if ( def->name().compare( name, Qt::CaseInsensitive ) == 0 )
476 return def;
477 }
478 return nullptr;
479}
480
482{
483 int count = 0;
484 for ( const QgsProcessingParameterDefinition *def : mParameters )
485 {
486 if ( !( def->flags() & QgsProcessingParameterDefinition::FlagHidden ) )
487 count++;
488 }
489 return count;
490}
491
493{
495 for ( const QgsProcessingParameterDefinition *def : mParameters )
496 {
497 if ( def->isDestination() )
498 result << def;
499 }
500 return result;
501}
502
504{
505 for ( const QgsProcessingOutputDefinition *def : mOutputs )
506 {
507 if ( def->name().compare( name, Qt::CaseInsensitive ) == 0 )
508 return def;
509 }
510 return nullptr;
511}
512
514{
515 for ( const QgsProcessingOutputDefinition *def : mOutputs )
516 {
517 if ( def->type() == QLatin1String( "outputHtml" ) )
518 return true;
519 }
520 return false;
521}
522
523QgsProcessingAlgorithm::VectorProperties QgsProcessingAlgorithm::sinkProperties( const QString &, const QVariantMap &, QgsProcessingContext &, const QMap<QString, QgsProcessingAlgorithm::VectorProperties> & ) const
524{
525 return VectorProperties();
526}
527
528QVariantMap QgsProcessingAlgorithm::run( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback, bool *ok, const QVariantMap &configuration, bool catchExceptions ) const
529{
530 std::unique_ptr< QgsProcessingAlgorithm > alg( create( configuration ) );
531 if ( ok )
532 *ok = false;
533
534 bool res = alg->prepare( parameters, context, feedback );
535 if ( !res )
536 return QVariantMap();
537
538 QVariantMap runRes;
539 try
540 {
541 runRes = alg->runPrepared( parameters, context, feedback );
542 }
543 catch ( QgsProcessingException &e )
544 {
545 if ( !catchExceptions )
546 throw e;
547
548 QgsMessageLog::logMessage( e.what(), QObject::tr( "Processing" ), Qgis::MessageLevel::Critical );
549 feedback->reportError( e.what() );
550 return QVariantMap();
551 }
552
553 if ( ok )
554 *ok = true;
555
556 QVariantMap ppRes = alg->postProcess( context, feedback );
557 if ( !ppRes.isEmpty() )
558 return ppRes;
559 else
560 return runRes;
561}
562
563bool QgsProcessingAlgorithm::prepare( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
564{
565 Q_ASSERT_X( QThread::currentThread() == context.temporaryLayerStore()->thread(), "QgsProcessingAlgorithm::prepare", "prepare() must be called from the same thread as context was created in" );
566 Q_ASSERT_X( !mHasPrepared, "QgsProcessingAlgorithm::prepare", "prepare() has already been called for the algorithm instance" );
567 try
568 {
569 mHasPrepared = prepareAlgorithm( parameters, context, feedback );
570 return mHasPrepared;
571 }
572 catch ( QgsProcessingException &e )
573 {
574 QgsMessageLog::logMessage( e.what(), QObject::tr( "Processing" ), Qgis::MessageLevel::Critical );
575 feedback->reportError( e.what() );
576 return false;
577 }
578}
579
580QVariantMap QgsProcessingAlgorithm::runPrepared( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
581{
582 Q_ASSERT_X( mHasPrepared, "QgsProcessingAlgorithm::runPrepared", QStringLiteral( "prepare() was not called for the algorithm instance %1" ).arg( name() ).toLatin1() );
583 Q_ASSERT_X( !mHasExecuted, "QgsProcessingAlgorithm::runPrepared", "runPrepared() was already called for this algorithm instance" );
584
585 // Hey kids, let's all be thread safe! It's the fun thing to do!
586 //
587 // First, let's see if we're going to run into issues.
588 QgsProcessingContext *runContext = nullptr;
589 if ( context.thread() == QThread::currentThread() )
590 {
591 // OH. No issues. Seems you're running everything in the same thread, so go about your business. Sorry about
592 // the intrusion, we're just making sure everything's nice and safe here. We like to keep a clean and tidy neighbourhood,
593 // you know, for the kids and dogs and all.
594 runContext = &context;
595 }
596 else
597 {
598 // HA! I knew things looked a bit suspicious - seems you're running this algorithm in a different thread
599 // from that which the passed context has an affinity for. That's fine and all, but we need to make sure
600 // we proceed safely...
601
602 // So first we create a temporary local context with affinity for the current thread
603 mLocalContext.reset( new QgsProcessingContext() );
604 // copy across everything we can safely do from the passed context
605 mLocalContext->copyThreadSafeSettings( context );
606 // and we'll run the actual algorithm processing using the local thread safe context
607 runContext = mLocalContext.get();
608 }
609
610 try
611 {
612 QVariantMap runResults = processAlgorithm( parameters, *runContext, feedback );
613
614 mHasExecuted = true;
615 if ( mLocalContext )
616 {
617 // ok, time to clean things up. We need to push the temporary context back into
618 // the thread that the passed context is associated with (we can only push from the
619 // current thread, so we HAVE to do this here)
620 mLocalContext->pushToThread( context.thread() );
621 }
622 return runResults;
623 }
624 catch ( QgsProcessingException & )
625 {
626 if ( mLocalContext )
627 {
628 // see above!
629 mLocalContext->pushToThread( context.thread() );
630 }
631 //rethrow
632 throw;
633 }
634}
635
637{
638 Q_ASSERT_X( QThread::currentThread() == context.temporaryLayerStore()->thread(), "QgsProcessingAlgorithm::postProcess", "postProcess() must be called from the same thread the context was created in" );
639 Q_ASSERT_X( mHasExecuted, "QgsProcessingAlgorithm::postProcess", QStringLiteral( "algorithm instance %1 was not executed" ).arg( name() ).toLatin1() );
640 Q_ASSERT_X( !mHasPostProcessed, "QgsProcessingAlgorithm::postProcess", "postProcess() was already called for this algorithm instance" );
641
642 if ( mLocalContext )
643 {
644 // algorithm was processed using a temporary thread safe context. So now we need
645 // to take the results from that temporary context, and smash them into the passed
646 // context
647 context.takeResultsFrom( *mLocalContext );
648 // now get lost, we don't need you anymore
649 mLocalContext.reset();
650 }
651
652 mHasPostProcessed = true;
653 try
654 {
655 return postProcessAlgorithm( context, feedback );
656 }
657 catch ( QgsProcessingException &e )
658 {
659 QgsMessageLog::logMessage( e.what(), QObject::tr( "Processing" ), Qgis::MessageLevel::Critical );
660 feedback->reportError( e.what() );
661 return QVariantMap();
662 }
663}
664
665QString QgsProcessingAlgorithm::parameterAsString( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const
666{
668}
669
670QString QgsProcessingAlgorithm::parameterAsExpression( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const
671{
673}
674
675double QgsProcessingAlgorithm::parameterAsDouble( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const
676{
678}
679
680int QgsProcessingAlgorithm::parameterAsInt( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const
681{
682 return QgsProcessingParameters::parameterAsInt( parameterDefinition( name ), parameters, context );
683}
684
685QList<int> QgsProcessingAlgorithm::parameterAsInts( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const
686{
687 return QgsProcessingParameters::parameterAsInts( parameterDefinition( name ), parameters, context );
688}
689
690int QgsProcessingAlgorithm::parameterAsEnum( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const
691{
692 return QgsProcessingParameters::parameterAsEnum( parameterDefinition( name ), parameters, context );
693}
694
695QList<int> QgsProcessingAlgorithm::parameterAsEnums( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const
696{
698}
699
700QString QgsProcessingAlgorithm::parameterAsEnumString( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const
701{
703}
704
705QStringList QgsProcessingAlgorithm::parameterAsEnumStrings( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const
706{
708}
709
710bool QgsProcessingAlgorithm::parameterAsBool( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const
711{
712 return QgsProcessingParameters::parameterAsBool( parameterDefinition( name ), parameters, context );
713}
714
715bool QgsProcessingAlgorithm::parameterAsBoolean( const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context ) const
716{
717 return QgsProcessingParameters::parameterAsBool( parameterDefinition( name ), parameters, context );
718}
719
720QgsFeatureSink *QgsProcessingAlgorithm::parameterAsSink( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, QString &destinationIdentifier, const QgsFields &fields, Qgis::WkbType geometryType, const QgsCoordinateReferenceSystem &crs, QgsFeatureSink::SinkFlags sinkFlags, const QVariantMap &createOptions, const QStringList &datasourceOptions, const QStringList &layerOptions ) const
721{
722 if ( !parameterDefinition( name ) )
723 throw QgsProcessingException( QObject::tr( "No parameter definition for the sink '%1'" ).arg( name ) );
724
725 return QgsProcessingParameters::parameterAsSink( parameterDefinition( name ), parameters, fields, geometryType, crs, context, destinationIdentifier, sinkFlags, createOptions, datasourceOptions, layerOptions );
726}
727
728QgsProcessingFeatureSource *QgsProcessingAlgorithm::parameterAsSource( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
729{
731}
732
733QString QgsProcessingAlgorithm::parameterAsCompatibleSourceLayerPath( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat, QgsProcessingFeedback *feedback ) const
734{
735 return QgsProcessingParameters::parameterAsCompatibleSourceLayerPath( parameterDefinition( name ), parameters, context, compatibleFormats, preferredFormat, feedback );
736}
737
738QString QgsProcessingAlgorithm::parameterAsCompatibleSourceLayerPathAndLayerName( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat, QgsProcessingFeedback *feedback, QString *layerName ) const
739{
740 return QgsProcessingParameters::parameterAsCompatibleSourceLayerPathAndLayerName( parameterDefinition( name ), parameters, context, compatibleFormats, preferredFormat, feedback, layerName );
741}
742
743QgsMapLayer *QgsProcessingAlgorithm::parameterAsLayer( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
744{
746}
747
748QgsRasterLayer *QgsProcessingAlgorithm::parameterAsRasterLayer( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
749{
751}
752
753QgsMeshLayer *QgsProcessingAlgorithm::parameterAsMeshLayer( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
754{
756}
757
758QString QgsProcessingAlgorithm::parameterAsOutputLayer( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
759{
761}
762
763QString QgsProcessingAlgorithm::parameterAsFileOutput( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
764{
766}
767
768QgsVectorLayer *QgsProcessingAlgorithm::parameterAsVectorLayer( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
769{
771}
772
773QgsCoordinateReferenceSystem QgsProcessingAlgorithm::parameterAsCrs( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
774{
775 return QgsProcessingParameters::parameterAsCrs( parameterDefinition( name ), parameters, context );
776}
777
778QgsCoordinateReferenceSystem QgsProcessingAlgorithm::parameterAsExtentCrs( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
779{
781}
782
783QgsRectangle QgsProcessingAlgorithm::parameterAsExtent( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs ) const
784{
786}
787
788QgsGeometry QgsProcessingAlgorithm::parameterAsExtentGeometry( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs ) const
789{
791}
792
793QgsPointXY QgsProcessingAlgorithm::parameterAsPoint( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs ) const
794{
796}
797
798QgsCoordinateReferenceSystem QgsProcessingAlgorithm::parameterAsPointCrs( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
799{
801}
802
803QgsGeometry QgsProcessingAlgorithm::parameterAsGeometry( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs ) const
804{
806}
807
808QgsCoordinateReferenceSystem QgsProcessingAlgorithm::parameterAsGeometryCrs( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
809{
811}
812
813QString QgsProcessingAlgorithm::parameterAsFile( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
814{
815 return QgsProcessingParameters::parameterAsFile( parameterDefinition( name ), parameters, context );
816}
817
818QVariantList QgsProcessingAlgorithm::parameterAsMatrix( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
819{
821}
822
823QList<QgsMapLayer *> QgsProcessingAlgorithm::parameterAsLayerList( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
824{
826}
827
828QStringList QgsProcessingAlgorithm::parameterAsFileList( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
829{
831}
832
833QList<double> QgsProcessingAlgorithm::parameterAsRange( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
834{
836}
837
838QStringList QgsProcessingAlgorithm::parameterAsFields( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
839{
841}
842
843QgsPrintLayout *QgsProcessingAlgorithm::parameterAsLayout( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context )
844{
846}
847
848QgsLayoutItem *QgsProcessingAlgorithm::parameterAsLayoutItem( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, QgsPrintLayout *layout )
849{
850 return QgsProcessingParameters::parameterAsLayoutItem( parameterDefinition( name ), parameters, context, layout );
851}
852
853QColor QgsProcessingAlgorithm::parameterAsColor( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
854{
856}
857
858QString QgsProcessingAlgorithm::parameterAsConnectionName( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
859{
861}
862
863QDateTime QgsProcessingAlgorithm::parameterAsDateTime( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
864{
866}
867
868QString QgsProcessingAlgorithm::parameterAsSchema( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
869{
871}
872
873QString QgsProcessingAlgorithm::parameterAsDatabaseTableName( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
874{
876}
877
878QgsPointCloudLayer *QgsProcessingAlgorithm::parameterAsPointCloudLayer( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
879{
881}
882
883QgsAnnotationLayer *QgsProcessingAlgorithm::parameterAsAnnotationLayer( const QVariantMap &parameters, const QString &name, QgsProcessingContext &context ) const
884{
886}
887
888QString QgsProcessingAlgorithm::invalidSourceError( const QVariantMap &parameters, const QString &name )
889{
890 if ( !parameters.contains( name ) )
891 return QObject::tr( "Could not load source layer for %1: no value specified for parameter" ).arg( name );
892 else
893 {
894 QVariant var = parameters.value( name );
895 if ( var.userType() == QMetaType::type( "QgsProcessingFeatureSourceDefinition" ) )
896 {
897 QgsProcessingFeatureSourceDefinition fromVar = qvariant_cast<QgsProcessingFeatureSourceDefinition>( var );
898 var = fromVar.source;
899 }
900 else if ( var.userType() == QMetaType::type( "QgsProcessingOutputLayerDefinition" ) )
901 {
902 QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( var );
903 var = fromVar.sink;
904 }
905 if ( var.userType() == QMetaType::type( "QgsProperty" ) )
906 {
907 QgsProperty p = var.value< QgsProperty >();
909 {
910 var = p.staticValue();
911 }
912 }
913 if ( !var.toString().isEmpty() )
914 return QObject::tr( "Could not load source layer for %1: %2 not found" ).arg( name, var.toString() );
915 else
916 return QObject::tr( "Could not load source layer for %1: invalid value" ).arg( name );
917 }
918}
919
920QString QgsProcessingAlgorithm::invalidRasterError( const QVariantMap &parameters, const QString &name )
921{
922 if ( !parameters.contains( name ) )
923 return QObject::tr( "Could not load source layer for %1: no value specified for parameter" ).arg( name );
924 else
925 {
926 QVariant var = parameters.value( name );
927 if ( var.userType() == QMetaType::type( "QgsProperty" ) )
928 {
929 QgsProperty p = var.value< QgsProperty >();
931 {
932 var = p.staticValue();
933 }
934 }
935 if ( !var.toString().isEmpty() )
936 return QObject::tr( "Could not load source layer for %1: %2 not found" ).arg( name, var.toString() );
937 else
938 return QObject::tr( "Could not load source layer for %1: invalid value" ).arg( name );
939 }
940}
941
942QString QgsProcessingAlgorithm::invalidSinkError( const QVariantMap &parameters, const QString &name )
943{
944 if ( !parameters.contains( name ) )
945 return QObject::tr( "Could not create destination layer for %1: no value specified for parameter" ).arg( name );
946 else
947 {
948 QVariant var = parameters.value( name );
949 if ( var.userType() == QMetaType::type( "QgsProcessingOutputLayerDefinition" ) )
950 {
951 QgsProcessingOutputLayerDefinition fromVar = qvariant_cast<QgsProcessingOutputLayerDefinition>( var );
952 var = fromVar.sink;
953 }
954 if ( var.userType() == QMetaType::type( "QgsProperty" ) )
955 {
956 QgsProperty p = var.value< QgsProperty >();
958 {
959 var = p.staticValue();
960 }
961 }
962 if ( !var.toString().isEmpty() )
963 return QObject::tr( "Could not create destination layer for %1: %2" ).arg( name, var.toString() );
964 else
965 return QObject::tr( "Could not create destination layer for %1: invalid value" ).arg( name );
966 }
967}
968
969QString QgsProcessingAlgorithm::invalidPointCloudError( const QVariantMap &parameters, const QString &name )
970{
971 if ( !parameters.contains( name ) )
972 return QObject::tr( "Could not load source layer for %1: no value specified for parameter" ).arg( name );
973 else
974 {
975 QVariant var = parameters.value( name );
976 if ( var.userType() == QMetaType::type( "QgsProperty" ) )
977 {
978 QgsProperty p = var.value< QgsProperty >();
980 {
981 var = p.staticValue();
982 }
983 }
984 if ( !var.toString().isEmpty() )
985 return QObject::tr( "Could not load source layer for %1: %2 not found" ).arg( name, var.toString() );
986 else
987 return QObject::tr( "Could not load source layer for %1: invalid value" ).arg( name );
988 }
989}
990
991QString QgsProcessingAlgorithm::writeFeatureError( QgsFeatureSink *sink, const QVariantMap &parameters, const QString &name )
992{
993 Q_UNUSED( sink );
994 Q_UNUSED( parameters );
995 if ( !name.isEmpty() )
996 return QObject::tr( "Could not write feature into %1" ).arg( name );
997 else
998 return QObject::tr( "Could not write feature" );
999}
1000
1002{
1003 Q_UNUSED( layer )
1004 return false;
1005}
1006
1007
1008bool QgsProcessingAlgorithm::createAutoOutputForParameter( QgsProcessingParameterDefinition *parameter )
1009{
1010 if ( !parameter->isDestination() )
1011 return true; // nothing created, but nothing went wrong - so return true
1012
1013 QgsProcessingDestinationParameter *dest = static_cast< QgsProcessingDestinationParameter * >( parameter );
1015 if ( !output )
1016 return true; // nothing created - but nothing went wrong - so return true
1017 output->setAutoCreated( true );
1018
1019 if ( !addOutput( output ) )
1020 {
1021 // couldn't add output - probably a duplicate name
1022 return false;
1023 }
1024 else
1025 {
1026 return true;
1027 }
1028}
1029
1030
1031//
1032// QgsProcessingFeatureBasedAlgorithm
1033//
1034
1035QgsProcessingAlgorithm::Flags QgsProcessingFeatureBasedAlgorithm::flags() const
1036{
1039 return f;
1040}
1041
1043{
1045 initParameters( config );
1046 addParameter( new QgsProcessingParameterFeatureSink( QStringLiteral( "OUTPUT" ), outputName(), outputLayerType(), QVariant(), false, true, true ) );
1047}
1048
1050{
1051 return QStringLiteral( "INPUT" );
1052}
1053
1055{
1056 return QObject::tr( "Input layer" );
1057}
1058
1060{
1061 return QList<int>();
1062}
1063
1065{
1067}
1068
1070{
1071 return static_cast<QgsProcessingFeatureSource::Flag>( 0 );
1072}
1073
1074QgsFeatureSink::SinkFlags QgsProcessingFeatureBasedAlgorithm::sinkFlags() const
1075{
1076 return QgsFeatureSink::SinkFlags();
1077}
1078
1080{
1081 return inputWkbType;
1082}
1083
1085{
1086 return inputFields;
1087}
1088
1090{
1091 return inputCrs;
1092}
1093
1095{
1096}
1097
1099{
1100 if ( mSource )
1101 return mSource->sourceCrs();
1102 else
1104}
1105
1106QVariantMap QgsProcessingFeatureBasedAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
1107{
1108 prepareSource( parameters, context );
1109 QString dest;
1110 std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest,
1111 outputFields( mSource->fields() ),
1112 outputWkbType( mSource->wkbType() ),
1113 outputCrs( mSource->sourceCrs() ),
1114 sinkFlags() ) );
1115 if ( !sink )
1116 throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
1117
1118 // prepare expression context for feature iteration
1119 QgsExpressionContext prevContext = context.expressionContext();
1120 QgsExpressionContext algContext = prevContext;
1121
1122 algContext.appendScopes( createExpressionContext( parameters, context, mSource.get() ).takeScopes() );
1123 context.setExpressionContext( algContext );
1124
1125 long count = mSource->featureCount();
1126
1127 QgsFeature f;
1128 QgsFeatureIterator it = mSource->getFeatures( request(), sourceFlags() );
1129
1130 double step = count > 0 ? 100.0 / count : 1;
1131 int current = 0;
1132 while ( it.nextFeature( f ) )
1133 {
1134 if ( feedback->isCanceled() )
1135 {
1136 break;
1137 }
1138
1139 context.expressionContext().setFeature( f );
1140 const QgsFeatureList transformed = processFeature( f, context, feedback );
1141 for ( QgsFeature transformedFeature : transformed )
1142 sink->addFeature( transformedFeature, QgsFeatureSink::FastInsert );
1143
1144 feedback->setProgress( current * step );
1145 current++;
1146 }
1147
1148 mSource.reset();
1149
1150 // probably not necessary - context's aren't usually recycled, but can't hurt
1151 context.setExpressionContext( prevContext );
1152
1153 QVariantMap outputs;
1154 outputs.insert( QStringLiteral( "OUTPUT" ), dest );
1155 return outputs;
1156}
1157
1159{
1160 return QgsFeatureRequest();
1161}
1162
1164{
1165 const QgsVectorLayer *layer = qobject_cast< const QgsVectorLayer * >( l );
1166 if ( !layer )
1167 return false;
1168
1169 Qgis::GeometryType inPlaceGeometryType = layer->geometryType();
1170 if ( !inputLayerTypes().empty() &&
1173 ( ( inPlaceGeometryType == Qgis::GeometryType::Polygon && !inputLayerTypes().contains( QgsProcessing::TypeVectorPolygon ) ) ||
1174 ( inPlaceGeometryType == Qgis::GeometryType::Line && !inputLayerTypes().contains( QgsProcessing::TypeVectorLine ) ) ||
1175 ( inPlaceGeometryType == Qgis::GeometryType::Point && !inputLayerTypes().contains( QgsProcessing::TypeVectorPoint ) ) ) )
1176 return false;
1177
1179 if ( inPlaceGeometryType == Qgis::GeometryType::Point )
1180 type = Qgis::WkbType::Point;
1181 else if ( inPlaceGeometryType == Qgis::GeometryType::Line )
1183 else if ( inPlaceGeometryType == Qgis::GeometryType::Polygon )
1185
1186 if ( QgsWkbTypes::geometryType( outputWkbType( type ) ) != inPlaceGeometryType )
1187 return false;
1188
1189 return true;
1190}
1191
1193{
1194 if ( ! mSource )
1195 {
1196 mSource.reset( parameterAsSource( parameters, inputParameterName(), context ) );
1197 if ( !mSource )
1199 }
1200}
1201
1202
1203QgsProcessingAlgorithm::VectorProperties QgsProcessingFeatureBasedAlgorithm::sinkProperties( const QString &sink, const QVariantMap &parameters, QgsProcessingContext &context, const QMap<QString, QgsProcessingAlgorithm::VectorProperties> &sourceProperties ) const
1204{
1206 if ( sink == QLatin1String( "OUTPUT" ) )
1207 {
1208 if ( sourceProperties.value( QStringLiteral( "INPUT" ) ).availability == QgsProcessingAlgorithm::Available )
1209 {
1210 const VectorProperties inputProps = sourceProperties.value( QStringLiteral( "INPUT" ) );
1211 result.fields = outputFields( inputProps.fields );
1212 result.crs = outputCrs( inputProps.crs );
1213 result.wkbType = outputWkbType( inputProps.wkbType );
1214 result.availability = Available;
1215 return result;
1216 }
1217 else
1218 {
1219 std::unique_ptr< QgsProcessingFeatureSource > source( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
1220 if ( source )
1221 {
1222 result.fields = outputFields( source->fields() );
1223 result.crs = outputCrs( source->sourceCrs() );
1224 result.wkbType = outputWkbType( source->wkbType() );
1225 result.availability = Available;
1226 return result;
1227 }
1228 }
1229 }
1230 return result;
1231}
1232
GeometryType
The geometry types are used to group Qgis::WkbType in a coarse way.
Definition: qgis.h:228
WkbType
The WKB type describes the number of dimensions a geometry has.
Definition: qgis.h:155
@ LineString
LineString.
@ Polygon
Polygon.
@ Unknown
Unknown.
Represents a map layer containing a set of georeferenced annotations, e.g.
static QIcon getThemeIcon(const QString &name, const QColor &fillColor=QColor(), const QColor &strokeColor=QColor())
Helper to get a theme icon.
static QString iconPath(const QString &iconFile)
Returns path to the desired icon file.
This class represents a coordinate reference system (CRS).
bool isValid() const
Returns whether this CRS is correctly initialized and usable.
QString what() const
Definition: qgsexception.h:48
Single scope for storing variables and functions for use within a QgsExpressionContext.
static QgsExpressionContextScope * processingAlgorithmScope(const QgsProcessingAlgorithm *algorithm, const QVariantMap &parameters, QgsProcessingContext &context)
Creates a new scope which contains variables and functions relating to a processing algorithm,...
static QgsExpressionContextScope * projectScope(const QgsProject *project)
Creates a new scope which contains variables and functions relating to a QGIS project.
static QgsExpressionContextScope * globalScope()
Creates a new scope which contains variables and functions relating to the global QGIS context.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
QList< QgsExpressionContextScope * > takeScopes()
Returns all scopes from this context and remove them, leaving this context without any context.
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
void appendScopes(const QList< QgsExpressionContextScope * > &scopes)
Appends a list of scopes to the end of the context.
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
This class wraps a request for features to a vector layer (or directly its vector data provider).
An interface for objects which accept features via addFeature(s) methods.
@ FastInsert
Use faster inserts, at the cost of updating the passed features to reflect changes made at the provid...
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition: qgsfeature.h:56
bool isCanceled() const SIP_HOLDGIL
Tells whether the operation has been canceled already.
Definition: qgsfeedback.h:54
void setProgress(double progress)
Sets the current progress for the feedback object.
Definition: qgsfeedback.h:63
Container of fields for a vector layer.
Definition: qgsfields.h:45
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:164
Base class for graphical items within a QgsLayout.
Base class for all map layer types.
Definition: qgsmaplayer.h:73
QgsCoordinateReferenceSystem crs
Definition: qgsmaplayer.h:79
Represents a mesh layer supporting display of data on structured or unstructured meshes.
Definition: qgsmeshlayer.h:100
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).
Represents a map layer supporting display of point clouds.
A class to represent a 2D point.
Definition: qgspointxy.h:59
Print layout, a QgsLayout subclass for static or atlas-based layouts.
Abstract base class for processing algorithms.
QString parameterAsCompatibleSourceLayerPath(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat=QString("shp"), QgsProcessingFeedback *feedback=nullptr) const
Evaluates the parameter with matching name to a source vector layer file path of compatible format.
QString parameterAsConnectionName(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a connection name string.
QVariantMap runPrepared(const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback) SIP_THROW(QgsProcessingException)
Runs the algorithm, which has been prepared by an earlier call to prepare().
const QgsProcessingOutputDefinition * outputDefinition(const QString &name) const
Returns a matching output by name.
QString parameterAsCompatibleSourceLayerPathAndLayerName(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat=QString("shp"), QgsProcessingFeedback *feedback=nullptr, QString *layerName=nullptr) const
Evaluates the parameter with matching name to a source vector layer file path and layer name of compa...
QgsGeometry parameterAsExtentGeometry(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs=QgsCoordinateReferenceSystem()) const
Evaluates the parameter with matching name to a rectangular extent, and returns a geometry covering t...
virtual QgsProcessingAlgorithm * createInstance() const =0
Creates a new instance of the algorithm class.
QgsMapLayer * parameterAsLayer(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a map layer.
QgsRasterLayer * parameterAsRasterLayer(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a raster layer.
@ Available
Properties are available.
int parameterAsInt(const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context) const
Evaluates the parameter with matching name to a static integer value.
virtual QString helpUrl() const
Returns a url pointing to the algorithm's help page.
int parameterAsEnum(const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context) const
Evaluates the parameter with matching name to a enum value.
virtual Flags flags() const
Returns the flags indicating how and when the algorithm operates and should be exposed to users.
void setProvider(QgsProcessingProvider *provider)
Associates this algorithm with its provider.
virtual QIcon icon() const
Returns an icon for the algorithm.
virtual QString shortHelpString() const
Returns a localised short helper string for the algorithm.
virtual bool validateInputCrs(const QVariantMap &parameters, QgsProcessingContext &context) const
Checks whether the coordinate reference systems for the specified set of parameters are valid for the...
virtual QString shortDescription() const
Returns an optional translated short description of the algorithm.
QStringList parameterAsFields(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a list of fields.
QgsProcessingFeatureSource * parameterAsSource(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a feature source.
int countVisibleParameters() const
Returns the number of visible (non-hidden) parameters defined by this algorithm.
QString parameterAsFile(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a file/folder name.
QString id() const
Returns the unique ID for the algorithm, which is a combination of the algorithm provider's ID and th...
virtual QVariantMap preprocessParameters(const QVariantMap &parameters)
Pre-processes a set of parameters, allowing the algorithm to clean their values.
static QString invalidRasterError(const QVariantMap &parameters, const QString &name)
Returns a user-friendly string to use as an error when a raster layer input could not be loaded.
QgsVectorLayer * parameterAsVectorLayer(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a vector layer.
@ FlagSupportsInPlaceEdits
Algorithm supports in-place editing.
@ FlagCanCancel
Algorithm can be canceled.
@ FlagRequiresProject
The algorithm requires that a valid QgsProject is available from the processing context in order to e...
@ FlagSupportsBatch
Algorithm supports batch mode.
@ FlagRequiresMatchingCrs
Algorithm requires that all input layers have matching coordinate reference systems.
static QString writeFeatureError(QgsFeatureSink *sink, const QVariantMap &parameters, const QString &name)
Returns a user-friendly string to use as an error when a feature cannot be written into a sink.
virtual QVariantMap processAlgorithm(const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback) SIP_THROW(QgsProcessingException)=0
Runs the algorithm using the specified parameters.
QStringList parameterAsFileList(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a list of files (for QgsProcessingParameterMultipleLaye...
bool prepare(const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback)
Prepares the algorithm for execution.
QString parameterAsDatabaseTableName(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a database table name string.
QgsFeatureSink * parameterAsSink(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, QString &destinationIdentifier, const QgsFields &fields, Qgis::WkbType geometryType=Qgis::WkbType::NoGeometry, const QgsCoordinateReferenceSystem &crs=QgsCoordinateReferenceSystem(), QgsFeatureSink::SinkFlags sinkFlags=QgsFeatureSink::SinkFlags(), const QVariantMap &createOptions=QVariantMap(), const QStringList &datasourceOptions=QStringList(), const QStringList &layerOptions=QStringList()) const SIP_THROW(QgsProcessingException)
Evaluates the parameter with matching name to a feature sink.
QString parameterAsExpression(const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context) const
Evaluates the parameter with matching name to an expression.
void removeParameter(const QString &name)
Removes the parameter with matching name from the algorithm, and deletes any existing definition.
QgsAnnotationLayer * parameterAsAnnotationLayer(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to an annotation layer.
bool addParameter(QgsProcessingParameterDefinition *parameterDefinition, bool createOutput=true)
Adds a parameter definition to the algorithm.
QgsGeometry parameterAsGeometry(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs=QgsCoordinateReferenceSystem()) const
Evaluates the parameter with matching name to a geometry.
virtual QString asQgisProcessCommand(const QVariantMap &parameters, QgsProcessingContext &context, bool &ok) const
Returns a command string which will execute the algorithm using the specified parameters via the comm...
bool parameterAsBoolean(const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context) const
Evaluates the parameter with matching name to a static boolean value.
QList< double > parameterAsRange(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a range of values.
QVariantList parameterAsMatrix(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a matrix/table of values.
QgsProcessingAlgorithm * create(const QVariantMap &configuration=QVariantMap()) const SIP_THROW(QgsProcessingException)
Creates a copy of the algorithm, ready for execution.
virtual bool prepareAlgorithm(const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback) SIP_THROW(QgsProcessingException)
Prepares the algorithm to run using the specified parameters.
virtual QgsExpressionContext createExpressionContext(const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeatureSource *source=nullptr) const
Creates an expression context relating to the algorithm.
QgsProcessingParameterDefinitions destinationParameterDefinitions() const
Returns a list of destination parameters definitions utilized by the algorithm.
static QString invalidSinkError(const QVariantMap &parameters, const QString &name)
Returns a user-friendly string to use as an error when a sink parameter could not be created.
bool hasHtmlOutputs() const
Returns true if this algorithm generates HTML outputs.
bool addOutput(QgsProcessingOutputDefinition *outputDefinition)
Adds an output definition to the algorithm.
double parameterAsDouble(const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context) const
Evaluates the parameter with matching name to a static double value.
QgsCoordinateReferenceSystem parameterAsPointCrs(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Returns the coordinate reference system associated with an point parameter value.
QVariantMap postProcess(QgsProcessingContext &context, QgsProcessingFeedback *feedback)
Should be called in the main thread following the completion of runPrepared().
QString parameterAsString(const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context) const
Evaluates the parameter with matching name to a static string value.
QgsRectangle parameterAsExtent(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs=QgsCoordinateReferenceSystem()) const
Evaluates the parameter with matching name to a rectangular extent.
QgsPrintLayout * parameterAsLayout(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context)
Evaluates the parameter with matching name to a print layout.
QgsCoordinateReferenceSystem parameterAsCrs(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a coordinate reference system.
QString parameterAsFileOutput(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a file based output destination.
QgsLayoutItem * parameterAsLayoutItem(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, QgsPrintLayout *layout)
Evaluates the parameter with matching name to a print layout item, taken from the specified layout.
const QgsProcessingParameterDefinition * parameterDefinition(const QString &name) const
Returns a matching parameter by name.
virtual QString svgIconPath() const
Returns a path to an SVG version of the algorithm's icon.
QString parameterAsSchema(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a database schema name string.
virtual Q_DECL_DEPRECATED QString helpString() const
Returns a localised help string for the algorithm.
QStringList parameterAsEnumStrings(const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context) const
Evaluates the parameter with matching name to list of static enum strings.
QgsPointXY parameterAsPoint(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs=QgsCoordinateReferenceSystem()) const
Evaluates the parameter with matching name to a point.
virtual QWidget * createCustomParametersWidget(QWidget *parent=nullptr) const
If an algorithm subclass implements a custom parameters widget, a copy of this widget should be const...
QList< QgsMapLayer * > parameterAsLayerList(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a list of map layers.
virtual QgsProcessingAlgorithm::VectorProperties sinkProperties(const QString &sink, const QVariantMap &parameters, QgsProcessingContext &context, const QMap< QString, QgsProcessingAlgorithm::VectorProperties > &sourceProperties) const
Returns the vector properties which will be used for the sink with matching name.
virtual QVariantMap postProcessAlgorithm(QgsProcessingContext &context, QgsProcessingFeedback *feedback) SIP_THROW(QgsProcessingException)
Allows the algorithm to perform any required cleanup tasks.
QgsCoordinateReferenceSystem parameterAsExtentCrs(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Returns the coordinate reference system associated with an extent parameter value.
QgsMeshLayer * parameterAsMeshLayer(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a mesh layer.
QgsCoordinateReferenceSystem parameterAsGeometryCrs(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Returns the coordinate reference system associated with a geometry parameter value.
virtual QString asPythonCommand(const QVariantMap &parameters, QgsProcessingContext &context) const
Returns a Python command string which can be executed to run the algorithm using the specified parame...
QString parameterAsEnumString(const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context) const
Evaluates the parameter with matching name to a static enum string.
virtual bool canExecute(QString *errorMessage=nullptr) const
Returns true if the algorithm can execute.
QgsProcessingProvider * provider() const
Returns the provider to which this algorithm belongs.
virtual QVariantMap asMap(const QVariantMap &parameters, QgsProcessingContext &context) const
Returns a JSON serializable variant map containing the specified parameters and context settings.
QList< int > parameterAsInts(const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context) const
Evaluates the parameter with matching name to a list of integer values.
virtual bool supportInPlaceEdit(const QgsMapLayer *layer) const
Checks whether this algorithm supports in-place editing on the given layer Default implementation ret...
bool parameterAsBool(const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context) const
Evaluates the parameter with matching name to a static boolean value.
virtual QString name() const =0
Returns the algorithm name, used for identifying the algorithm.
static QString invalidPointCloudError(const QVariantMap &parameters, const QString &name)
Returns a user-friendly string to use as an error when a point cloud layer input could not be loaded.
QgsPointCloudLayer * parameterAsPointCloudLayer(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a point cloud layer.
QList< int > parameterAsEnums(const QVariantMap &parameters, const QString &name, const QgsProcessingContext &context) const
Evaluates the parameter with matching name to list of enum values.
virtual bool checkParameterValues(const QVariantMap &parameters, QgsProcessingContext &context, QString *message=nullptr) const
Checks the supplied parameter values to verify that they satisfy the requirements of this algorithm i...
QVariantMap run(const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback, bool *ok=nullptr, const QVariantMap &configuration=QVariantMap(), bool catchExceptions=true) const SIP_THROW(QgsProcessingException)
Executes the algorithm using the specified parameters.
static QString invalidSourceError(const QVariantMap &parameters, const QString &name)
Returns a user-friendly string to use as an error when a source parameter could not be loaded.
QDateTime parameterAsDateTime(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a DateTime, or returns an invalid date time if the para...
QString parameterAsOutputLayer(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a output layer destination.
QColor parameterAsColor(const QVariantMap &parameters, const QString &name, QgsProcessingContext &context) const
Evaluates the parameter with matching name to a color, or returns an invalid color if the parameter w...
Contains information about the context in which a processing algorithm is executed.
QThread * thread()
Returns the thread in which the context lives.
@ IncludeProjectPath
Include the associated project path argument.
QgsExpressionContext & expressionContext()
Returns the expression context.
void takeResultsFrom(QgsProcessingContext &context)
Takes the results from another context and merges them with the results currently stored in this cont...
QVariantMap exportToMap() const
Exports the context's settings to a variant map.
QStringList asQgisProcessArguments(QgsProcessingContext::ProcessArgumentFlags flags=QgsProcessingContext::ProcessArgumentFlags()) const
Returns list of the equivalent qgis_process arguments representing the settings from the context.
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
QgsProject * project() const
Returns the project in which the algorithm is being executed.
QgsMapLayerStore * temporaryLayerStore()
Returns a reference to the layer store used for storing temporary layers during algorithm execution.
Base class for all parameter definitions which represent file or layer destinations,...
virtual QgsProcessingOutputDefinition * toOutputDefinition() const =0
Returns a new QgsProcessingOutputDefinition corresponding to the definition of the destination parame...
void setSupportsNonFileBasedOutput(bool supportsNonFileBasedOutput)
Sets whether the destination parameter supports non filed-based outputs, such as memory layers or dir...
Custom exception class for processing related exceptions.
Definition: qgsexception.h:83
virtual QgsFeatureRequest request() const
Returns the feature request used for fetching features to process from the source layer.
bool supportInPlaceEdit(const QgsMapLayer *layer) const override
Checks whether this algorithm supports in-place editing on the given layer Default implementation for...
virtual QString inputParameterName() const
Returns the name of the parameter corresponding to the input layer.
QgsProcessingAlgorithm::VectorProperties sinkProperties(const QString &sink, const QVariantMap &parameters, QgsProcessingContext &context, const QMap< QString, QgsProcessingAlgorithm::VectorProperties > &sourceProperties) const override
Returns the vector properties which will be used for the sink with matching name.
virtual void initParameters(const QVariantMap &configuration=QVariantMap())
Initializes any extra parameters added by the algorithm subclass.
QVariantMap processAlgorithm(const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback) override SIP_THROW(QgsProcessingException)
Runs the algorithm using the specified parameters.
virtual Qgis::WkbType outputWkbType(Qgis::WkbType inputWkbType) const
Maps the input WKB geometry type (inputWkbType) to the corresponding output WKB type generated by the...
virtual QgsCoordinateReferenceSystem outputCrs(const QgsCoordinateReferenceSystem &inputCrs) const
Maps the input source coordinate reference system (inputCrs) to a corresponding output CRS generated ...
void prepareSource(const QVariantMap &parameters, QgsProcessingContext &context)
Read the source from parameters and context and set it.
virtual QgsFields outputFields(const QgsFields &inputFields) const
Maps the input source fields (inputFields) to corresponding output fields generated by the algorithm.
virtual QString outputName() const =0
Returns the translated, user visible name for any layers created by this algorithm.
virtual QString inputParameterDescription() const
Returns the translated description of the parameter corresponding to the input layer.
virtual QgsProcessing::SourceType outputLayerType() const
Returns the layer type for layers generated by this algorithm, if this is possible to determine in ad...
virtual QgsFeatureSink::SinkFlags sinkFlags() const
Returns the feature sink flags to be used for the output.
virtual QgsFeatureList processFeature(const QgsFeature &feature, QgsProcessingContext &context, QgsProcessingFeedback *feedback) SIP_THROW(QgsProcessingException)=0
Processes an individual input feature from the source.
void initAlgorithm(const QVariantMap &configuration=QVariantMap()) override
Initializes the algorithm using the specified configuration.
QgsProcessingAlgorithm::Flags flags() const override
Returns the flags indicating how and when the algorithm operates and should be exposed to users.
virtual QgsProcessingFeatureSource::Flag sourceFlags() const
Returns the processing feature source flags to be used in the algorithm.
virtual QList< int > inputLayerTypes() const
Returns the valid input layer types for the source layer for this algorithm.
QgsCoordinateReferenceSystem sourceCrs() const
Returns the source's coordinate reference system.
Encapsulates settings relating to a feature source input to a processing algorithm.
QgsFeatureSource subclass which proxies methods to an underlying QgsFeatureSource,...
QgsExpressionContextScope * createExpressionContextScope() const
Returns an expression context scope suitable for this source.
Flag
Flags controlling how QgsProcessingFeatureSource fetches features.
Base class for providing feedback from a processing algorithm.
virtual void reportError(const QString &error, bool fatalError=false)
Reports that the algorithm encountered an error while executing.
Base class for the definition of processing outputs.
QString name() const
Returns the name of the output.
bool autoCreated() const
Returns true if the output was automatically created when adding a parameter.
Encapsulates settings relating to a feature sink or output raster layer for a processing algorithm.
QgsProperty sink
Sink/layer definition.
Base class for the definition of processing parameters.
QgsProcessingAlgorithm * mAlgorithm
Pointer to algorithm which owns this parameter.
virtual bool isDestination() const
Returns true if this parameter represents a file or layer destination, e.g.
@ FlagHidden
Parameter is hidden and should not be shown to users.
QString name() const
Returns the name of the parameter.
static QString typeName()
Returns the type name for the parameter class.
A feature sink output for processing algorithms.
static QString typeName()
Returns the type name for the parameter class.
An input feature source (such as vector layers) parameter for processing algorithms.
static QString typeName()
Returns the type name for the parameter class.
static QString typeName()
Returns the type name for the parameter class.
static QString typeName()
Returns the type name for the parameter class.
static QString typeName()
Returns the type name for the parameter class.
static QString typeName()
Returns the type name for the parameter class.
static QString typeName()
Returns the type name for the parameter class.
static QString typeName()
Returns the type name for the parameter class.
static QList< QgsMapLayer * > parameterAsLayerList(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a list of map layers.
static int parameterAsEnum(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context)
Evaluates the parameter with matching definition to a enum value.
static double parameterAsDouble(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context)
Evaluates the parameter with matching definition to a static double value.
static QgsPointXY parameterAsPoint(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs=QgsCoordinateReferenceSystem())
Evaluates the parameter with matching definition to a point.
static QString parameterAsOutputLayer(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a output layer destination.
static QgsFeatureSink * parameterAsSink(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsFields &fields, Qgis::WkbType geometryType, const QgsCoordinateReferenceSystem &crs, QgsProcessingContext &context, QString &destinationIdentifier, QgsFeatureSink::SinkFlags sinkFlags=QgsFeatureSink::SinkFlags(), const QVariantMap &createOptions=QVariantMap(), const QStringList &datasourceOptions=QStringList(), const QStringList &layerOptions=QStringList())
Evaluates the parameter with matching definition to a feature sink.
static QgsPrintLayout * parameterAsLayout(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a print layout.
static QgsRectangle parameterAsExtent(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs=QgsCoordinateReferenceSystem())
Evaluates the parameter with matching definition to a rectangular extent.
static QgsCoordinateReferenceSystem parameterAsGeometryCrs(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Returns the coordinate reference system associated with a geometry parameter value.
static QgsAnnotationLayer * parameterAsAnnotationLayer(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to an annotation layer.
static QString parameterAsEnumString(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context)
Evaluates the parameter with matching definition to a static enum string.
static QList< double > parameterAsRange(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a range of values.
static QgsMapLayer * parameterAsLayer(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingUtils::LayerHint layerHint=QgsProcessingUtils::LayerHint::UnknownType)
Evaluates the parameter with matching definition to a map layer.
static QList< int > parameterAsInts(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context)
Evaluates the parameter with matching definition to a list of integer values.
static QString parameterAsConnectionName(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context)
Evaluates the parameter with matching definition to a connection name string.
static QgsProcessingFeatureSource * parameterAsSource(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a feature source.
static QString parameterAsFileOutput(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a file based output destination.
static QgsCoordinateReferenceSystem parameterAsPointCrs(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Returns the coordinate reference system associated with an point parameter value.
static QgsLayoutItem * parameterAsLayoutItem(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, QgsPrintLayout *layout)
Evaluates the parameter with matching definition to a print layout item, taken from the specified lay...
static bool parameterAsBool(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context)
Evaluates the parameter with matching definition to a static boolean value.
static QString parameterAsCompatibleSourceLayerPathAndLayerName(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat=QString("shp"), QgsProcessingFeedback *feedback=nullptr, QString *layerName=nullptr)
Evaluates the parameter with matching definition to a source vector layer file path and layer name of...
static QgsMeshLayer * parameterAsMeshLayer(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition and value to a mesh layer.
static QString parameterAsCompatibleSourceLayerPath(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QStringList &compatibleFormats, const QString &preferredFormat=QString("shp"), QgsProcessingFeedback *feedback=nullptr)
Evaluates the parameter with matching definition to a source vector layer file path of compatible for...
static QColor parameterAsColor(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Returns the color associated with an point parameter value, or an invalid color if the parameter was ...
static QgsVectorLayer * parameterAsVectorLayer(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a vector layer.
static QgsPointCloudLayer * parameterAsPointCloudLayer(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a point cloud layer.
static int parameterAsInt(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context)
Evaluates the parameter with matching definition to a static integer value.
static QString parameterAsDatabaseTableName(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context)
Evaluates the parameter with matching definition to a database table name.
static QString parameterAsSchema(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context)
Evaluates the parameter with matching definition to a database schema name.
static QgsGeometry parameterAsGeometry(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs=QgsCoordinateReferenceSystem())
Evaluates the parameter with matching definition to a geometry.
static QString parameterAsExpression(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context)
Evaluates the parameter with matching definition to an expression.
static QString parameterAsString(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context)
Evaluates the parameter with matching definition to a static string value.
static QgsRasterLayer * parameterAsRasterLayer(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a raster layer.
static QList< int > parameterAsEnums(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context)
Evaluates the parameter with matching definition to list of enum values.
static QStringList parameterAsEnumStrings(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context)
Evaluates the parameter with matching definition to list of static enum strings.
static QgsGeometry parameterAsExtentGeometry(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context, const QgsCoordinateReferenceSystem &crs=QgsCoordinateReferenceSystem())
Evaluates the parameter with matching definition to a rectangular extent, and returns a geometry cove...
static QStringList parameterAsFileList(const QgsProcessingParameterDefinition *definition, const QVariant &value, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a list of files (for QgsProcessingParameterMultip...
static QStringList parameterAsFields(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a list of fields.
static QgsCoordinateReferenceSystem parameterAsExtentCrs(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Returns the coordinate reference system associated with an extent parameter value.
static QDateTime parameterAsDateTime(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, const QgsProcessingContext &context)
Evaluates the parameter with matching definition to a static datetime value.
static QString parameterAsFile(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a file/folder name.
static QVariantList parameterAsMatrix(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a matrix/table of values.
static QgsCoordinateReferenceSystem parameterAsCrs(const QgsProcessingParameterDefinition *definition, const QVariantMap &parameters, QgsProcessingContext &context)
Evaluates the parameter with matching definition to a coordinate reference system.
Abstract base class for processing providers.
virtual QString id() const =0
Returns the unique provider id, used for identifying the provider.
virtual bool supportsNonFileBasedOutput() const
Returns true if the provider supports non-file based outputs (such as memory layers or direct databas...
SourceType
Data source types enum.
Definition: qgsprocessing.h:47
@ TypeVectorLine
Vector line layers.
Definition: qgsprocessing.h:51
@ TypeVectorPolygon
Vector polygon layers.
Definition: qgsprocessing.h:52
@ TypeVector
Tables (i.e. vector layers with or without geometry). When used for a sink this indicates the sink ha...
Definition: qgsprocessing.h:55
@ TypeVectorPoint
Vector point layers.
Definition: qgsprocessing.h:50
@ TypeVectorAnyGeometry
Any vector layer with geometry.
Definition: qgsprocessing.h:49
A store for object properties.
Definition: qgsproperty.h:230
@ StaticProperty
Static property (QgsStaticProperty)
Definition: qgsproperty.h:237
QVariant value(const QgsExpressionContext &context, const QVariant &defaultValue=QVariant(), bool *ok=nullptr) const
Calculates the current value of the property, including any transforms which are set for the property...
QVariant staticValue() const
Returns the current static value for the property.
Type propertyType() const
Returns the property type.
Represents a raster layer.
A rectangle specified with double values.
Definition: qgsrectangle.h:42
Represents a vector layer which manages a vector based data sets.
Q_INVOKABLE Qgis::GeometryType geometryType() const
Returns point, line or polygon.
static Qgis::GeometryType geometryType(Qgis::WkbType type) SIP_HOLDGIL
Returns the geometry type for a WKB type, e.g., both MultiPolygon and CurvePolygon would have a Polyg...
Definition: qgswkbtypes.h:865
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
QList< QgsFeature > QgsFeatureList
Definition: qgsfeature.h:920
QList< const QgsProcessingParameterDefinition * > QgsProcessingParameterDefinitions
List of processing parameters.
const QgsCoordinateReferenceSystem & crs
Properties of a vector source or sink used in an algorithm.
Qgis::WkbType wkbType
Geometry (WKB) type.
QgsCoordinateReferenceSystem crs
Coordinate Reference System.
QgsProcessingAlgorithm::PropertyAvailability availability
Availability of the properties. By default properties are not available.