19#include "moc_qgsprocessingutils.cpp"
41#include <QRegularExpression>
47 return compatibleMapLayers< QgsRasterLayer >( project, sort );
53 return QList<QgsVectorLayer *>();
55 QList<QgsVectorLayer *> layers;
59 if ( canUseLayer( l, geometryTypes ) )
67 return QString::localeAwareCompare( a->name(), b->name() ) < 0;
75 return compatibleMapLayers< QgsMeshLayer >( project, sort );
80 return compatibleMapLayers< QgsPluginLayer >( project, sort );
85 return compatibleMapLayers< QgsPointCloudLayer >( project, sort );
91 QList<QgsAnnotationLayer *> res = compatibleMapLayers< QgsAnnotationLayer >( project,
false );
99 return QString::localeAwareCompare( a->name(), b->name() ) < 0;
108 return compatibleMapLayers< QgsVectorTileLayer >( project, sort );
113 return compatibleMapLayers< QgsTiledSceneLayer >( project, sort );
116template<
typename T> QList<T *> QgsProcessingUtils::compatibleMapLayers(
QgsProject *project,
bool sort )
122 const auto projectLayers = project->
layers<T *>();
123 for ( T *l : projectLayers )
125 if ( canUseLayer( l ) )
131 std::sort( layers.begin(), layers.end(), [](
const T * a,
const T * b ) ->
bool
133 return QString::localeAwareCompare( a->name(), b->name() ) < 0;
142 return QList<QgsMapLayer *>();
144 QList<QgsMapLayer *> layers;
146 const auto rasterLayers = compatibleMapLayers< QgsRasterLayer >( project,
false );
154 const auto meshLayers = compatibleMapLayers< QgsMeshLayer >( project,
false );
158 const auto pointCloudLayers = compatibleMapLayers< QgsPointCloudLayer >( project,
false );
162 const auto annotationLayers = compatibleMapLayers< QgsAnnotationLayer >( project,
false );
167 const auto vectorTileLayers = compatibleMapLayers< QgsVectorTileLayer >( project,
false );
171 const auto tiledSceneLayers = compatibleMapLayers< QgsTiledSceneLayer >( project,
false );
175 const auto pluginLayers = compatibleMapLayers< QgsPluginLayer >( project,
false );
183 return QString::localeAwareCompare( a->name(), b->name() ) < 0;
191 return QStringLiteral(
"%1://%2" ).arg( providerKey, uri );
196 const thread_local QRegularExpression re( QStringLiteral(
"^(\\w+?):\\/\\/(.+)$" ) );
197 const QRegularExpressionMatch match = re.match(
string );
198 if ( !match.hasMatch() )
201 providerKey = match.captured( 1 );
202 uri = match.captured( 2 );
210 if ( !store ||
string.isEmpty() )
213 QList< QgsMapLayer * > layers = store->
mapLayers().values();
215 layers.erase( std::remove_if( layers.begin(), layers.end(), [](
QgsMapLayer * layer )
217 switch ( layer->type() )
219 case Qgis::LayerType::Vector:
220 return !canUseLayer( qobject_cast< QgsVectorLayer * >( layer ) );
221 case Qgis::LayerType::Raster:
222 return !canUseLayer( qobject_cast< QgsRasterLayer * >( layer ) );
223 case Qgis::LayerType::Plugin:
224 case Qgis::LayerType::Group:
226 case Qgis::LayerType::Mesh:
227 return !canUseLayer( qobject_cast< QgsMeshLayer * >( layer ) );
228 case Qgis::LayerType::VectorTile:
229 return !canUseLayer( qobject_cast< QgsVectorTileLayer * >( layer ) );
230 case Qgis::LayerType::TiledScene:
231 return !canUseLayer( qobject_cast< QgsTiledSceneLayer * >( layer ) );
232 case Qgis::LayerType::PointCloud:
233 return !canUseLayer( qobject_cast< QgsPointCloudLayer * >( layer ) );
234 case Qgis::LayerType::Annotation:
235 return !canUseLayer( qobject_cast< QgsAnnotationLayer * >( layer ) );
240 auto isCompatibleType = [typeHint](
QgsMapLayer * l ) ->
bool
244 case LayerHint::UnknownType:
247 case LayerHint::Vector:
250 case LayerHint::Raster:
253 case LayerHint::Mesh:
256 case LayerHint::PointCloud:
259 case LayerHint::Annotation:
262 case LayerHint::VectorTile:
265 case LayerHint::TiledScene:
273 if ( isCompatibleType( l ) && l->id() ==
string )
278 if ( isCompatibleType( l ) && l->name() ==
string )
283 if ( isCompatibleType( l ) && normalizeLayerSource( l->source() ) == normalizeLayerSource(
string ) )
300 if ( providerMetadata )
303 const QVariantMap parts = providerMetadata->
decodeUri( uri );
304 const QString layerName = parts.value( QStringLiteral(
"layerName" ) ).toString();
306 if ( !layerName.isEmpty() )
310 else if (
const QString path = parts.value( QStringLiteral(
"path" ) ).toString(); !path.isEmpty() )
312 name = QFileInfo( path ).baseName();
317 const QStringList components = uri.split(
'|' );
318 if ( components.isEmpty() )
321 if ( QFileInfo fi( components.at( 0 ) ); fi.isFile() )
322 name = fi.baseName();
324 name = QFileInfo( uri ).baseName();
327 if ( name.isEmpty() )
331 if ( name.isEmpty() )
336 QList< Qgis::LayerType > candidateTypes;
341 if ( providerMetadata )
375 options.loadDefaultStyle =
false;
376 options.skipCrsValidation =
true;
378 std::unique_ptr< QgsVectorLayer > layer;
379 if ( providerMetadata )
381 layer = std::make_unique<QgsVectorLayer>( uri, name, providerMetadata->
key(), options );
386 layer = std::make_unique<QgsVectorLayer>( uri, name, QStringLiteral(
"ogr" ), options );
388 if ( layer->isValid() )
390 return layer.release();
399 std::unique_ptr< QgsRasterLayer > rasterLayer;
400 if ( providerMetadata )
402 rasterLayer = std::make_unique< QgsRasterLayer >( uri, name, providerMetadata->
key(), rasterOptions );
407 rasterLayer = std::make_unique< QgsRasterLayer >( uri, name, QStringLiteral(
"gdal" ), rasterOptions );
410 if ( rasterLayer->isValid() )
412 return rasterLayer.release();
420 std::unique_ptr< QgsMeshLayer > meshLayer;
421 if ( providerMetadata )
423 meshLayer = std::make_unique< QgsMeshLayer >( uri, name, providerMetadata->
key(), meshOptions );
427 meshLayer = std::make_unique< QgsMeshLayer >( uri, name, QStringLiteral(
"mdal" ), meshOptions );
429 if ( meshLayer->isValid() )
431 return meshLayer.release();
444 std::unique_ptr< QgsPointCloudLayer > pointCloudLayer;
445 if ( providerMetadata )
447 pointCloudLayer = std::make_unique< QgsPointCloudLayer >( uri, name, providerMetadata->
key(), pointCloudOptions );
452 if ( !preferredProviders.empty() )
454 pointCloudLayer = std::make_unique< QgsPointCloudLayer >( uri, name, preferredProviders.at( 0 ).metadata()->key(), pointCloudOptions );
464 pointCloudLayer = std::make_unique< QgsPointCloudLayer >( uri, name, QStringLiteral(
"pdal" ), pointCloudOptions );
468 if ( pointCloudLayer && pointCloudLayer->isValid() )
470 return pointCloudLayer.release();
476 dsUri.
setParam(
"type",
"mbtiles" );
479 std::unique_ptr< QgsVectorTileLayer > tileLayer;
480 tileLayer = std::make_unique< QgsVectorTileLayer >( dsUri.
encodedUri(), name );
482 if ( tileLayer->isValid() )
484 return tileLayer.release();
492 std::unique_ptr< QgsTiledSceneLayer > tiledSceneLayer;
493 if ( providerMetadata )
495 tiledSceneLayer = std::make_unique< QgsTiledSceneLayer >( uri, name, providerMetadata->
key(), tiledSceneOptions );
500 if ( !preferredProviders.empty() )
502 tiledSceneLayer = std::make_unique< QgsTiledSceneLayer >( uri, name, preferredProviders.at( 0 ).metadata()->key(), tiledSceneOptions );
505 if ( tiledSceneLayer && tiledSceneLayer->isValid() )
507 return tiledSceneLayer.release();
515 if (
string.isEmpty() )
519 if ( context.
project() && ( typeHint ==
LayerHint::Annotation ) &&
string.compare( QLatin1String(
"main" ), Qt::CaseInsensitive ) == 0 )
523 if (
auto *lProject = context.
project() )
525 QgsMapLayer *layer = mapLayerFromStore(
string, lProject->layerStore(), typeHint );
539 if ( !allowLoadingNewLayers )
542 layer = loadMapLayerFromString(
string, context.
transformContext(), typeHint, flags );
556 QVariant val = value;
557 bool selectedFeaturesOnly =
false;
558 long long featureLimit = -1;
559 QString filterExpression;
560 bool overrideGeometryCheck =
false;
562 if ( val.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
573 else if ( val.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
580 if (
QgsVectorLayer *layer = qobject_cast< QgsVectorLayer * >( qvariant_cast<QObject *>( val ) ) )
582 auto source = std::make_unique< QgsProcessingFeatureSource >( layer, context,
false, featureLimit, filterExpression );
583 if ( overrideGeometryCheck )
584 source->setInvalidGeometryCheck( geometryCheck );
585 return source.release();
589 if ( val.userType() == qMetaTypeId<QgsProperty>() )
593 else if ( !val.isValid() || val.toString().isEmpty() )
596 if (
QgsVectorLayer *layer = qobject_cast< QgsVectorLayer * >( qvariant_cast<QObject *>( fallbackValue ) ) )
598 auto source = std::make_unique< QgsProcessingFeatureSource >( layer, context,
false, featureLimit, filterExpression );
599 if ( overrideGeometryCheck )
600 source->setInvalidGeometryCheck( geometryCheck );
601 return source.release();
604 layerRef = fallbackValue.toString();
608 layerRef = val.toString();
611 if ( layerRef.isEmpty() )
618 std::unique_ptr< QgsProcessingFeatureSource> source;
619 if ( selectedFeaturesOnly )
625 source = std::make_unique< QgsProcessingFeatureSource >( vl, context,
false, featureLimit, filterExpression );
628 if ( overrideGeometryCheck )
629 source->setInvalidGeometryCheck( geometryCheck );
630 return source.release();
635 QVariant val = value;
637 if ( val.userType() == qMetaTypeId<QgsCoordinateReferenceSystem>() )
642 else if ( val.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
648 else if ( val.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
661 if (
QgsMapLayer *layer = qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( val ) ) )
664 if ( val.userType() == qMetaTypeId<QgsProperty>() )
667 if ( !val.isValid() )
673 QString crsText = val.toString();
674 if ( crsText.isEmpty() )
675 crsText = fallbackValue.toString();
677 if ( crsText.isEmpty() )
681 if ( context.
project() && crsText.compare( QLatin1String(
"ProjectCrs" ), Qt::CaseInsensitive ) == 0 )
697bool QgsProcessingUtils::canUseLayer(
const QgsMeshLayer *layer )
702bool QgsProcessingUtils::canUseLayer(
const QgsPluginLayer *layer )
704 return layer && layer->
isValid();
709 return layer && layer->
isValid();
712bool QgsProcessingUtils::canUseLayer(
const QgsRasterLayer *layer )
714 return layer && layer->
isValid();
719 return layer && layer->
isValid();
724 return layer && layer->
isValid();
729 return layer && layer->
isValid();
732bool QgsProcessingUtils::canUseLayer(
const QgsVectorLayer *layer,
const QList<int> &sourceTypes )
734 return layer && layer->
isValid() &&
735 ( sourceTypes.isEmpty()
746 QString normalized = source;
747 normalized.replace(
'\\',
'/' );
748 return normalized.trimmed();
757 if ( !source.isEmpty() )
762 if ( provider.compare( QLatin1String(
"gdal" ), Qt::CaseInsensitive ) == 0
763 || provider.compare( QLatin1String(
"ogr" ), Qt::CaseInsensitive ) == 0
764 || provider.compare( QLatin1String(
"mdal" ), Qt::CaseInsensitive ) == 0 )
767 return QStringLiteral(
"%1://%2" ).arg( provider, source );
780 if ( !value.isValid() )
781 return QStringLiteral(
"None" );
783 if ( value.userType() == qMetaTypeId<QgsProperty>() )
784 return QStringLiteral(
"QgsProperty.fromExpression('%1')" ).arg( value.value<
QgsProperty >().
asExpression() );
785 else if ( value.userType() == qMetaTypeId<QgsCoordinateReferenceSystem>() )
788 return QStringLiteral(
"QgsCoordinateReferenceSystem()" );
792 else if ( value.userType() == qMetaTypeId<QgsRectangle>() )
800 else if ( value.userType() == qMetaTypeId<QgsReferencedRectangle>() )
808 else if ( value.userType() == qMetaTypeId<QgsPointXY>() )
814 else if ( value.userType() == qMetaTypeId<QgsReferencedPointXY>() )
822 switch ( value.userType() )
824 case QMetaType::Type::Bool:
825 return value.toBool() ? QStringLiteral(
"True" ) : QStringLiteral(
"False" );
827 case QMetaType::Type::Double:
828 return QString::number( value.toDouble() );
830 case QMetaType::Type::Int:
831 case QMetaType::Type::UInt:
832 return QString::number( value.toInt() );
834 case QMetaType::Type::LongLong:
835 case QMetaType::Type::ULongLong:
836 return QString::number( value.toLongLong() );
838 case QMetaType::Type::QVariantList:
841 const QVariantList vl = value.toList();
842 for (
const QVariant &v : vl )
846 return parts.join(
',' ).prepend(
'[' ).append(
']' );
849 case QMetaType::Type::QVariantMap:
851 const QVariantMap map = value.toMap();
853 parts.reserve( map.size() );
854 for (
auto it = map.constBegin(); it != map.constEnd(); ++it )
858 return parts.join(
',' ).prepend(
'{' ).append(
'}' );
861 case QMetaType::Type::QDateTime:
863 const QDateTime dateTime = value.toDateTime();
864 return QStringLiteral(
"QDateTime(QDate(%1, %2, %3), QTime(%4, %5, %6))" )
865 .arg( dateTime.date().year() )
866 .arg( dateTime.date().month() )
867 .arg( dateTime.date().day() )
868 .arg( dateTime.time().hour() )
869 .arg( dateTime.time().minute() )
870 .arg( dateTime.time().second() );
883 s.replace(
'\\', QLatin1String(
"\\\\" ) );
884 s.replace(
'\n', QLatin1String(
"\\n" ) );
885 s.replace(
'\r', QLatin1String(
"\\r" ) );
886 s.replace(
'\t', QLatin1String(
"\\t" ) );
888 if ( s.contains(
'\'' ) && !s.contains(
'\"' ) )
890 s = s.prepend(
'"' ).append(
'"' );
894 s.replace(
'\'', QLatin1String(
"\\\'" ) );
895 s = s.prepend(
'\'' ).append(
'\'' );
900void QgsProcessingUtils::parseDestinationString( QString &destination, QString &providerKey, QString &uri, QString &layerName, QString &format, QMap<QString, QVariant> &options,
bool &useWriter, QString &extension )
907 const thread_local QRegularExpression splitRx( QStringLiteral(
"^(.{3,}?):(.*)$" ) );
908 QRegularExpressionMatch match = splitRx.match( destination );
909 if ( match.hasMatch() )
911 providerKey = match.captured( 1 );
912 uri = match.captured( 2 );
919 if ( providerKey == QLatin1String(
"postgis" ) )
921 providerKey = QStringLiteral(
"postgres" );
923 if ( providerKey == QLatin1String(
"ogr" ) )
928 if ( !dsUri.
table().isEmpty() )
930 layerName = dsUri.
table();
931 options.insert( QStringLiteral(
"layerName" ), layerName );
934 extension = QFileInfo( uri ).completeSuffix();
936 options.insert( QStringLiteral(
"driverName" ), format );
940 extension = QFileInfo( uri ).completeSuffix();
943 options.insert( QStringLiteral(
"update" ),
true );
950 providerKey = QStringLiteral(
"ogr" );
952 const thread_local QRegularExpression splitRx( QStringLiteral(
"^(.*)\\.(.*?)$" ) );
953 QRegularExpressionMatch match = splitRx.match( destination );
954 if ( match.hasMatch() )
956 extension = match.captured( 2 );
960 if ( format.isEmpty() )
962 format = QStringLiteral(
"GPKG" );
963 destination = destination + QStringLiteral(
".gpkg" );
966 options.insert( QStringLiteral(
"driverName" ), format );
973 QVariantMap options = createOptions;
974 if ( !options.contains( QStringLiteral(
"fileEncoding" ) ) )
980 if ( destination.isEmpty() || destination.startsWith( QLatin1String(
"memory:" ) ) )
983 if ( destination.startsWith( QLatin1String(
"memory:" ) ) )
984 destination = destination.mid( 7 );
986 if ( destination.isEmpty() )
987 destination = QStringLiteral(
"output" );
991 if ( !layer || !layer->isValid() )
998 for (
const QgsField &field : fields )
1001 if ( !field.alias().isEmpty() )
1002 feedback->pushWarning( QObject::tr(
"%1: Aliases are not compatible with scratch layers" ).arg( field.name() ) );
1003 if ( !field.alias().isEmpty() )
1004 feedback->pushWarning( QObject::tr(
"%1: Comments are not compatible with scratch layers" ).arg( field.name() ) );
1011 destination = layer->id();
1014 auto sink = std::make_unique<QgsProcessingFeatureSink>( layer->dataProvider(), destination, context );
1017 return sink.release();
1021 QString providerKey;
1026 bool useWriter =
false;
1027 parseDestinationString( destination, providerKey, uri, layerName, format, options, useWriter, extension );
1030 if ( useWriter && providerKey == QLatin1String(
"ogr" ) )
1034 QString finalFileName;
1035 QString finalLayerName;
1037 saveOptions.
fileEncoding = options.value( QStringLiteral(
"fileEncoding" ) ).toString();
1038 saveOptions.
layerName = !layerName.isEmpty() ? layerName : options.value( QStringLiteral(
"layerName" ) ).toString();
1043 if ( remappingDefinition )
1047 auto vl = std::make_unique< QgsVectorLayer >( destination );
1048 if ( vl->isValid() )
1052 newFields = vl->fields();
1062 if ( writer->hasError() )
1064 throw QgsProcessingException( QObject::tr(
"Could not create layer %1: %2" ).arg( destination, writer->errorMessage() ) );
1069 for (
const QgsField &field : fields )
1072 feedback->pushWarning( QObject::tr(
"%1: Aliases are not supported by %2" ).arg( field.name(), writer->driverLongName() ) );
1074 feedback->pushWarning( QObject::tr(
"%1: Comments are not supported by %2" ).arg( field.name(), writer->driverLongName() ) );
1078 destination = finalFileName;
1079 if ( !saveOptions.
layerName.isEmpty() && !finalLayerName.isEmpty() )
1080 destination += QStringLiteral(
"|layername=%1" ).arg( finalLayerName );
1082 if ( remappingDefinition )
1084 auto remapSink = std::make_unique< QgsRemappingProxyFeatureSink >( *remappingDefinition, writer.release(),
true );
1095 if ( remappingDefinition )
1100 if ( !layerName.isEmpty() )
1103 parts.insert( QStringLiteral(
"layerName" ), layerName );
1107 auto layer = std::make_unique<QgsVectorLayer>( uri, destination, providerKey, layerOptions );
1109 destination = layer->
id();
1120 for (
const QgsField &field : fields )
1123 feedback->pushWarning( QObject::tr(
"%1: Aliases are not supported by the %2 provider" ).arg( field.name(), providerKey ) );
1125 feedback->pushWarning( QObject::tr(
"%1: Comments are not supported by the %2 provider" ).arg( field.name(), providerKey ) );
1129 auto remapSink = std::make_unique< QgsRemappingProxyFeatureSink >( *remappingDefinition, layer->
dataProvider(),
false );
1139 auto exporter = std::make_unique<QgsVectorLayerExporter>( uri, providerKey, newFields, geometryType,
crs,
true, options, sinkFlags );
1142 throw QgsProcessingException( QObject::tr(
"Could not create layer %1: %2" ).arg( destination, exporter->errorMessage() ) );
1146 if ( !layerName.isEmpty() )
1148 uri += QStringLiteral(
"|layername=%1" ).arg( layerName );
1155 for (
const QgsField &field : fields )
1158 feedback->pushWarning( QObject::tr(
"%1: Aliases are not supported by the %2 provider" ).arg( field.name(), providerKey ) );
1160 feedback->pushWarning( QObject::tr(
"%1: Comments are not supported by the %2 provider" ).arg( field.name(), providerKey ) );
1218 if ( !input.isValid() )
1219 return QStringLiteral(
"memory:%1" ).arg(
id.toString() );
1221 if ( input.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
1228 else if ( input.userType() == qMetaTypeId<QgsProperty>() )
1235 QString res = input.toString();
1241 else if ( res.startsWith( QLatin1String(
"memory:" ) ) )
1243 return QString( res +
'_' +
id.toString() );
1249 int lastIndex = res.lastIndexOf(
'.' );
1250 return lastIndex >= 0 ? QString( res.left( lastIndex ) +
'_' +
id.toString() + res.mid( lastIndex ) ) : QString( res +
'_' +
id.toString() );
1261 static std::vector< std::unique_ptr< QTemporaryDir > > sTempFolders;
1262 static QString sFolder;
1263 static QMutex sMutex;
1264 QMutexLocker locker( &sMutex );
1269 if ( basePath.isEmpty() )
1272 if ( basePath.isEmpty() )
1275 if ( sTempFolders.empty() )
1277 const QString templatePath = QStringLiteral(
"%1/processing_XXXXXX" ).arg( QDir::tempPath() );
1278 auto tempFolder = std::make_unique< QTemporaryDir >( templatePath );
1280 sTempFolders.emplace_back( std::move(
tempFolder ) );
1283 else if ( sFolder.isEmpty() || !sFolder.startsWith( basePath ) || sTempFolders.empty() )
1285 if ( !QDir().exists( basePath ) )
1286 QDir().mkpath( basePath );
1288 const QString templatePath = QStringLiteral(
"%1/processing_XXXXXX" ).arg( basePath );
1289 auto tempFolder = std::make_unique< QTemporaryDir >( templatePath );
1291 sTempFolders.emplace_back( std::move(
tempFolder ) );
1298 QString subPath = QUuid::createUuid().toString().remove(
'-' ).remove(
'{' ).remove(
'}' );
1299 QString path =
tempFolder( context ) +
'/' + subPath;
1300 if ( !QDir( path ).exists() )
1303 tmpDir.mkdir( path );
1310 auto getText = [map](
const QString & key )->QString
1312 if ( map.contains( key ) )
1313 return map.value( key ).toString();
1318 s += QStringLiteral(
"<html><body><p>" ) + getText( QStringLiteral(
"ALG_DESC" ) ) + QStringLiteral(
"</p>\n" );
1327 if ( !getText( def->name() ).isEmpty() )
1329 inputs += QStringLiteral(
"<h3>" ) + def->description() + QStringLiteral(
"</h3>\n" );
1330 inputs += QStringLiteral(
"<p>" ) + getText( def->name() ) + QStringLiteral(
"</p>\n" );
1333 if ( !inputs.isEmpty() )
1334 s += QStringLiteral(
"<h2>" ) + QObject::tr(
"Input parameters" ) + QStringLiteral(
"</h2>\n" ) + inputs;
1340 if ( !getText( def->name() ).isEmpty() )
1342 outputs += QStringLiteral(
"<h3>" ) + def->description() + QStringLiteral(
"</h3>\n" );
1343 outputs += QStringLiteral(
"<p>" ) + getText( def->name() ) + QStringLiteral(
"</p>\n" );
1346 if ( !outputs.isEmpty() )
1347 s += QStringLiteral(
"<h2>" ) + QObject::tr(
"Outputs" ) + QStringLiteral(
"</h2>\n" ) + outputs;
1349 if ( !map.value( QStringLiteral(
"EXAMPLES" ) ).toString().isEmpty() )
1350 s += QStringLiteral(
"<h2>%1</h2>\n<p>%2</p>" ).arg( QObject::tr(
"Examples" ), getText( QStringLiteral(
"EXAMPLES" ) ) );
1352 s += QLatin1String(
"<br>" );
1353 if ( !map.value( QStringLiteral(
"ALG_CREATOR" ) ).toString().isEmpty() )
1354 s += QStringLiteral(
"<p align=\"right\">" ) + QObject::tr(
"Algorithm author:" ) + QStringLiteral(
" " ) + getText( QStringLiteral(
"ALG_CREATOR" ) ) + QStringLiteral(
"</p>" );
1355 if ( !map.value( QStringLiteral(
"ALG_HELP_CREATOR" ) ).toString().isEmpty() )
1356 s += QStringLiteral(
"<p align=\"right\">" ) + QObject::tr(
"Help author:" ) + QStringLiteral(
" " ) + getText( QStringLiteral(
"ALG_HELP_CREATOR" ) ) + QStringLiteral(
"</p>" );
1357 if ( !map.value( QStringLiteral(
"ALG_VERSION" ) ).toString().isEmpty() )
1358 s += QStringLiteral(
"<p align=\"right\">" ) + QObject::tr(
"Algorithm version:" ) + QStringLiteral(
" " ) + getText( QStringLiteral(
"ALG_VERSION" ) ) + QStringLiteral(
"</p>" );
1360 s += QLatin1String(
"</body></html>" );
1369 if ( def->name().compare( name, Qt::CaseInsensitive ) == 0 )
1377 long long featureLimit,
const QString &filterExpression,
bool renameFid )
1379 bool requiresTranslation =
false;
1383 requiresTranslation = requiresTranslation || selectedFeaturesOnly;
1386 requiresTranslation = requiresTranslation || featureLimit != -1 || !filterExpression.isEmpty();
1391 requiresTranslation = requiresTranslation || vl->
providerType() != QLatin1String(
"ogr" );
1395 requiresTranslation = requiresTranslation || !vl->
subsetString().isEmpty();
1399 requiresTranslation = requiresTranslation || vl->
source().startsWith( QLatin1String(
"/vsi" ) );
1403 if ( !requiresTranslation )
1406 if ( parts.contains( QStringLiteral(
"path" ) ) )
1408 diskPath = parts.value( QStringLiteral(
"path" ) ).toString();
1409 QFileInfo fi( diskPath );
1410 requiresTranslation = !compatibleFormats.contains( fi.suffix(), Qt::CaseInsensitive );
1414 const QString srcLayerName = parts.value( QStringLiteral(
"layerName" ) ).toString();
1418 *layerName = srcLayerName;
1423 requiresTranslation = requiresTranslation || ( !srcLayerName.isEmpty() && srcLayerName != fi.baseName() );
1428 requiresTranslation =
true;
1432 if ( requiresTranslation )
1442 const int fidIndex = fields.
lookupField( QStringLiteral(
"fid" ) );
1443 if ( fidIndex >= 0 )
1444 fields.
rename( fidIndex, QStringLiteral(
"OLD_FID" ) );
1450 if ( featureLimit != -1 )
1454 if ( !filterExpression.isEmpty() )
1459 if ( selectedFeaturesOnly )
1464 constexpr int maxErrors { 10 };
1465 unsigned long errorCounter { 0 };
1473 const QString errorMessage = writer->errorMessage();
1474 if ( !renameFid && saveOptions.
driverName == QLatin1String(
"GPKG" ) && errorMessage.contains(
"fid", Qt::CaseInsensitive ) )
1477 feedback->
reportError( QObject::tr(
"Cannot store existing FID values in temporary GeoPackage layer, these will be moved to \"OLD_FID\" instead." ),
false );
1479 featureLimit, filterExpression,
true );
1483 if ( errorCounter++ < maxErrors )
1485 errorText = QObject::tr(
"Error writing feature # %1 to output layer: %2" ).arg( QString::number( f.
id() ), errorMessage );
1491 if ( errorCounter >= maxErrors )
1493 feedback->
reportError( QObject::tr(
"There were %1 errors writing features, only the first %2 have been reported." ).arg( QString::number( errorCounter ), QString::number( maxErrors ) ) );
1505 return convertToCompatibleFormatInternal( vl, selectedFeaturesOnly, baseName, compatibleFormats, preferredFormat, context, feedback,
nullptr, featureLimit, filterExpression,
false );
1511 return convertToCompatibleFormatInternal( layer, selectedFeaturesOnly, baseName, compatibleFormats, preferredFormat, context, feedback, &layerName, featureLimit, filterExpression,
false );
1517 QSet< QString > usedNames;
1518 for (
const QgsField &f : fieldsA )
1520 usedNames.insert( f.name().toLower() );
1523 for (
const QgsField &f : fieldsB )
1526 newField.
setName( fieldsBPrefix + f.name() );
1527 if ( usedNames.contains( newField.
name().toLower() ) )
1530 QString newName = newField.
name() +
'_' + QString::number( idx );
1531 while ( usedNames.contains( newName.toLower() ) || fieldsB.
indexOf( newName ) != -1 )
1534 newName = newField.
name() +
'_' + QString::number( idx );
1537 outFields.
append( newField );
1541 outFields.
append( newField );
1543 usedNames.insert( newField.
name() );
1553 if ( !fieldNames.isEmpty() )
1555 indices.reserve( fieldNames.count() );
1556 for (
const QString &f : fieldNames )
1560 indices.append( idx );
1565 indices.reserve( fields.
count() );
1566 for (
int i = 0; i < fields.
count(); ++i )
1567 indices.append( i );
1576 for (
int i : indices )
1577 fieldsSubset.
append( fields.
at( i ) );
1578 return fieldsSubset;
1584 if ( setting.isEmpty() )
1585 return QStringLiteral(
"gpkg" );
1587 if ( setting.startsWith(
'.' ) )
1588 setting = setting.mid( 1 );
1591 if ( !supportedFormats.contains( setting, Qt::CaseInsensitive ) )
1592 return QStringLiteral(
"gpkg" );
1600 if ( setting.isEmpty() )
1601 return QStringLiteral(
"tif" );
1603 if ( setting.startsWith(
'.' ) )
1604 setting = setting.mid( 1 );
1607 if ( !supportedFormats.contains( setting, Qt::CaseInsensitive ) )
1608 return QStringLiteral(
"tif" );
1615 return QStringLiteral(
"las" );
1620 return QStringLiteral(
"mbtiles" );
1625 auto layerPointerToString = [](
QgsMapLayer * layer ) -> QString
1627 if ( layer && layer->
providerType() == QLatin1String(
"memory" ) )
1635 auto cleanPointerValues = [&layerPointerToString](
const QVariant & value ) -> QVariant
1637 if (
QgsMapLayer *layer = qobject_cast< QgsMapLayer * >( value.value< QObject * >() ) )
1640 return layerPointerToString( layer );
1642 else if ( value.userType() == QMetaType::type(
"QPointer< QgsMapLayer >" ) )
1645 return layerPointerToString( value.value< QPointer< QgsMapLayer > >().data() );
1654 for (
auto it = map.constBegin(); it != map.constEnd(); ++it )
1656 if ( it->userType() == QMetaType::Type::QVariantMap )
1660 else if ( it->userType() == QMetaType::Type::QVariantList )
1663 const QVariantList source = it.value().toList();
1664 dest.reserve( source.size() );
1665 for (
const QVariant &v : source )
1667 dest.append( cleanPointerValues( v ) );
1669 res.insert( it.key(), dest );
1673 res.insert( it.key(), cleanPointerValues( it.value() ) );
1683 for (
auto it = parameters.constBegin(); it != parameters.constEnd(); ++it )
1685 if ( it.value().userType() == QMetaType::Type::QVariantMap )
1687 const QVariantMap value = it.value().toMap();
1688 if ( value.value( QStringLiteral(
"type" ) ).toString() == QLatin1String(
"data_defined" ) )
1690 const QString expression = value.value( QStringLiteral(
"expression" ) ).toString();
1691 const QString field = value.value( QStringLiteral(
"field" ) ).toString();
1692 if ( !expression.isEmpty() )
1696 else if ( !field.isEmpty() )
1703 error = QObject::tr(
"Invalid data defined parameter for %1, requires 'expression' or 'field' values." ).arg( it.key() );
1708 output.insert( it.key(), it.value() );
1711 else if ( it.value().userType() == QMetaType::Type::QString )
1713 const QString stringValue = it.value().toString();
1715 if ( stringValue.startsWith( QLatin1String(
"field:" ) ) )
1719 else if ( stringValue.startsWith( QLatin1String(
"expression:" ) ) )
1725 output.insert( it.key(), it.value() );
1730 output.insert( it.key(), it.value() );
1738 if ( ! QTextCodec::availableCodecs().contains( defaultEncoding.toLatin1() ) )
1740 const QString systemCodec = QTextCodec::codecForLocale()->name();
1741 if ( ! systemCodec.isEmpty() )
1745 return QString(
"UTF-8" );
1748 return defaultEncoding;
1756 : mSource( originalSource )
1757 , mOwnsSource( ownsOriginalSource )
1758 , mSourceCrs( mSource->sourceCrs() )
1759 , mSourceFields( mSource->fields() )
1760 , mSourceWkbType( mSource->wkbType() )
1761 , mSourceName( mSource->sourceName() )
1762 , mSourceExtent( mSource->sourceExtent() )
1763 , mSourceSpatialIndexPresence( mSource->hasSpatialIndex() )
1764 , mInvalidGeometryCheck(
QgsWkbTypes::geometryType( mSource->wkbType() ) ==
Qgis::GeometryType::Point
1765 ?
Qgis::InvalidGeometryCheck::NoCheck
1766 : context.invalidGeometryCheck() )
1767 , mInvalidGeometryCallback( context.invalidGeometryCallback( originalSource ) )
1768 , mTransformErrorCallback( context.transformErrorCallback() )
1769 , mInvalidGeometryCallbackSkip( context.defaultInvalidGeometryCallbackForCheck(
Qgis::InvalidGeometryCheck::SkipInvalid, originalSource ) )
1770 , mInvalidGeometryCallbackAbort( context.defaultInvalidGeometryCallbackForCheck(
Qgis::InvalidGeometryCheck::AbortOnInvalid, originalSource ) )
1771 , mFeatureLimit( featureLimit )
1772 , mFilterExpression( filterExpression )
1794 if ( mFeatureLimit != -1 && req.
limit() != -1 )
1795 req.
setLimit( std::min(
static_cast< long long >( req.
limit() ), mFeatureLimit ) );
1796 else if ( mFeatureLimit != -1 )
1799 if ( !mFilterExpression.isEmpty() )
1811 return sourceAvailability;
1824 if ( mFeatureLimit != -1 && req.
limit() != -1 )
1825 req.
setLimit( std::min(
static_cast< long long >( req.
limit() ), mFeatureLimit ) );
1826 else if ( mFeatureLimit != -1 )
1829 if ( !mFilterExpression.isEmpty() )
1842 return mSourceFields;
1847 return mSourceWkbType;
1852 if ( !mFilterExpression.isEmpty() )
1855 if ( mFeatureLimit == -1 )
1858 return std::min( mFeatureLimit, mSource->
featureCount() );
1868 if ( mFilterExpression.isEmpty() )
1873 if ( fieldIndex < 0 || fieldIndex >=
fields().count() )
1874 return QSet<QVariant>();
1881 QSet<QVariant> values;
1886 values.insert( f.
attribute( fieldIndex ) );
1887 if ( limit > 0 && values.size() >= limit )
1895 if ( mFilterExpression.isEmpty() )
1900 if ( fieldIndex < 0 || fieldIndex >=
fields().count() )
1912 const QVariant v = f.
attribute( fieldIndex );
1923 if ( mFilterExpression.isEmpty() )
1928 if ( fieldIndex < 0 || fieldIndex >=
fields().count() )
1940 const QVariant v = f.
attribute( fieldIndex );
1951 return mSourceExtent;
1956 if ( mFilterExpression.isEmpty() )
1962 .setFilterExpression( mFilterExpression ) );
1977 return mSourceSpatialIndexPresence;
1988 return expressionContextScope;
1993 mInvalidGeometryCheck = method;
1994 switch ( mInvalidGeometryCheck )
1997 mInvalidGeometryCallback =
nullptr;
2001 mInvalidGeometryCallback = mInvalidGeometryCallbackSkip;
2005 mInvalidGeometryCallback = mInvalidGeometryCallbackAbort;
2013 return mInvalidGeometryCheck;
2022 , mContext( context )
2023 , mSinkName( sinkName )
2024 , mOwnsSink( ownsOriginalSink )
2052 if ( !result && mContext.
feedback() )
2055 if ( !error.isEmpty() )
2056 mContext.
feedback()->
reportError( QObject::tr(
"Feature could not be written to %1: %2" ).arg( mSinkName, error ) );
2058 mContext.
feedback()->
reportError( QObject::tr(
"Feature could not be written to %1" ).arg( mSinkName ) );
2066 if ( !result && mContext.
feedback() )
2069 if ( !error.isEmpty() )
2070 mContext.
feedback()->
reportError( QObject::tr(
"%n feature(s) could not be written to %1: %2",
nullptr, features.count() ).arg( mSinkName, error ) );
2072 mContext.
feedback()->
reportError( QObject::tr(
"%n feature(s) could not be written to %1",
nullptr, features.count() ).arg( mSinkName ) );
2080 if ( !result && mContext.
feedback() )
2083 if ( !error.isEmpty() )
2084 mContext.
feedback()->
reportError( QObject::tr(
"Features could not be written to %1: %2" ).arg( mSinkName, error ) );
2086 mContext.
feedback()->
reportError( QObject::tr(
"Features could not be written to %1" ).arg( mSinkName ) );
Provides global constants and enumerations for use throughout the application.
@ Vector
Tables (i.e. vector layers with or without geometry). When used for a sink this indicates the sink ha...
@ VectorAnyGeometry
Any vector layer with geometry.
@ VectorPoint
Vector point layers.
@ VectorPolygon
Vector polygon layers.
@ VectorLine
Vector line layers.
@ FieldComments
Writer can support field comments.
@ FieldAliases
Writer can support field aliases.
SpatialIndexPresence
Enumeration of spatial index presence states.
@ Success
No errors were encountered.
@ NoGeometry
Geometry is not required. It may still be returned if e.g. required for a filter condition.
FeatureAvailability
Possible return value for QgsFeatureSource::hasFeatures() to determine if a source is empty.
@ FeaturesMaybeAvailable
There may be features available in this source.
@ NoFeaturesAvailable
There are certainly no features available in this source.
@ TiledScene
Tiled scene layer. Added in QGIS 3.34.
@ Annotation
Contains freeform, georeferenced annotations. Added in QGIS 3.16.
@ VectorTile
Vector tile layer. Added in QGIS 3.14.
@ Mesh
Mesh layer. Added in QGIS 3.2.
@ PointCloud
Point cloud layer. Added in QGIS 3.18.
@ EditAlias
Allows editing aliases.
@ EditComment
Allows editing comments.
QFlags< VectorDataProviderAttributeEditCapability > VectorDataProviderAttributeEditCapabilities
Attribute editing capabilities which may be supported by vector data providers.
InvalidGeometryCheck
Methods for handling of features with invalid geometries.
@ NoCheck
No invalid geometry checking.
@ AbortOnInvalid
Close iterator on encountering any features with invalid geometry. This requires a slow geometry vali...
@ SkipInvalid
Skip any features with invalid geometry. This requires a slow geometry validity check for every featu...
@ OverrideDefaultGeometryCheck
If set, the default geometry check method (as dictated by QgsProcessingContext) will be overridden fo...
@ SkipGeometryValidityChecks
Invalid geometry checks should always be skipped. This flag can be useful for algorithms which always...
WkbType
The WKB type describes the number of dimensions a geometry has.
@ Hidden
Parameter is hidden and should not be shown to users.
@ NoSymbology
Export only data.
QFlags< ProcessingFeatureSourceFlag > ProcessingFeatureSourceFlags
Flags which control how QgsProcessingFeatureSource fetches features.
Represents a map layer containing a set of georeferenced annotations, e.g.
Represents a coordinate reference system (CRS).
bool isValid() const
Returns whether this CRS is correctly initialized and usable.
Contains information about the context in which a coordinate transform is executed.
Custom exception class for Coordinate Reference System related exceptions.
Stores the component parts of a data source URI (e.g.
QByteArray encodedUri() const
Returns the complete encoded URI as a byte array.
QString table() const
Returns the table name stored in the URI.
void setParam(const QString &key, const QString &value)
Sets a generic parameter value on the URI.
QString database() const
Returns the database name stored in the URI.
Abstract interface for generating an expression context scope.
virtual QgsExpressionContextScope * createExpressionContextScope() const =0
This method needs to be reimplemented in all classes which implement this interface and return an exp...
Single scope for storing variables and functions for use within a QgsExpressionContext.
void setFields(const QgsFields &fields)
Convenience function for setting a fields for the context.
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
Wraps a request for features to a vector layer (or directly its vector data provider).
QgsFeatureRequest & setFlags(Qgis::FeatureRequestFlags flags)
Sets flags that affect how features will be fetched.
QgsFeatureRequest & setLimit(long long limit)
Set the maximum number of features to request.
long long limit() const
Returns the maximum number of features to request, or -1 if no limit set.
QgsFeatureRequest & combineFilterExpression(const QString &expression)
Modifies the existing filter expression to add an additional expression filter.
QgsFeatureRequest & setSubsetOfAttributes(const QgsAttributeList &attrs)
Set a subset of attributes that will be fetched.
QgsFeatureRequest & setInvalidGeometryCheck(Qgis::InvalidGeometryCheck check)
Sets invalid geometry checking behavior.
QgsFeatureRequest & setFilterExpression(const QString &expression)
Set the filter expression.
QgsFeatureRequest & setInvalidGeometryCallback(const std::function< void(const QgsFeature &)> &callback)
Sets a callback function to use when encountering an invalid geometry and invalidGeometryCheck() is s...
QgsFeatureRequest & setTransformErrorCallback(const std::function< void(const QgsFeature &)> &callback)
Sets a callback function to use when encountering a transform error when iterating features and a des...
An interface for objects which accept features via addFeature(s) methods.
QFlags< SinkFlag > SinkFlags
@ FastInsert
Use faster inserts, at the cost of updating the passed features to reflect changes made at the provid...
@ RegeneratePrimaryKey
This flag indicates, that a primary key field cannot be guaranteed to be unique and the sink should i...
An interface for objects which provide features via a getFeatures method.
virtual QSet< QVariant > uniqueValues(int fieldIndex, int limit=-1) const
Returns the set of unique values contained within the specified fieldIndex from this source.
virtual Qgis::FeatureAvailability hasFeatures() const
Determines if there are any features available in the source.
virtual QVariant minimumValue(int fieldIndex) const
Returns the minimum value for an attribute column or an invalid variant in case of error.
virtual QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest()) const =0
Returns an iterator for the features in the source.
virtual QVariant maximumValue(int fieldIndex) const
Returns the maximum value for an attribute column or an invalid variant in case of error.
virtual long long featureCount() const =0
Returns the number of features contained in the source, or -1 if the feature count is unknown.
virtual QgsFeatureIds allFeatureIds() const
Returns a list of all feature IDs for features present in the source.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Q_INVOKABLE QVariant attribute(const QString &name) const
Lookup attribute value by attribute name.
bool isCanceled() const
Tells whether the operation has been canceled already.
Encapsulate a field in an attribute table or data source.
void setName(const QString &name)
Set the field name.
Container of fields for a vector layer.
bool append(const QgsField &field, Qgis::FieldOrigin origin=Qgis::FieldOrigin::Provider, int originIndex=-1)
Appends a field.
Q_INVOKABLE int indexOf(const QString &fieldName) const
Gets the field index from the field name.
QgsField at(int i) const
Returns the field at particular index (must be in range 0..N-1).
Q_INVOKABLE int lookupField(const QString &fieldName) const
Looks up field's index from the field name.
bool rename(int fieldIdx, const QString &name)
Renames a name of field.
static QString stringToSafeFilename(const QString &string)
Converts a string to a safe filename, replacing characters which are not safe for filenames with an '...
A storage object for map layers, in which the layers are owned by the store and have their lifetime b...
QMap< QString, QgsMapLayer * > mapLayers() const
Returns a map of all layers by layer ID.
QgsMapLayer * addMapLayer(QgsMapLayer *layer, bool takeOwnership=true)
Add a layer to the store.
Base class for all map layer types.
QString source() const
Returns the source for the layer.
QString providerType() const
Returns the provider type (provider key) for this layer.
QgsCoordinateReferenceSystem crs
virtual void setTransformContext(const QgsCoordinateTransformContext &transformContext)=0
Sets the coordinate transform context to transformContext.
static QgsVectorLayer * createMemoryLayer(const QString &name, const QgsFields &fields, Qgis::WkbType geometryType=Qgis::WkbType::NoGeometry, const QgsCoordinateReferenceSystem &crs=QgsCoordinateReferenceSystem(), bool loadDefaultStyle=true) SIP_FACTORY
Creates a new memory layer using the specified parameters.
Represents a mesh layer supporting display of data on structured or unstructured meshes.
QgsMeshDataProvider * dataProvider() override
Returns the layer's data provider, it may be nullptr.
Base class for plugin layers.
Represents a map layer supporting display of point clouds.
Abstract base class for processing algorithms.
QgsProcessingOutputDefinitions outputDefinitions() const
Returns an ordered list of output definitions utilized by the algorithm.
QgsProcessingParameterDefinitions parameterDefinitions() const
Returns an ordered list of parameter definitions utilized by the algorithm.
Contains information about the context in which a processing algorithm is executed.
QString defaultEncoding() const
Returns the default encoding to use for newly created files.
QgsProcessingFeedback * feedback()
Returns the associated feedback object.
QgsExpressionContext & expressionContext()
Returns the expression context.
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform 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.
QString temporaryFolder() const
Returns the (optional) temporary folder to use when running algorithms.
Custom exception class for processing related exceptions.
QgsProxyFeatureSink subclass which reports feature addition errors to a QgsProcessingContext.
void finalize() override
Finalizes the sink, flushing any buffered features to the destination.
~QgsProcessingFeatureSink() override
QgsProcessingFeatureSink(QgsFeatureSink *originalSink, const QString &sinkName, QgsProcessingContext &context, bool ownsOriginalSink=false)
Constructor for QgsProcessingFeatureSink, accepting an original feature sink originalSink and process...
bool addFeatures(QgsFeatureList &features, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags()) override
Adds a list of features to the sink.
bool addFeature(QgsFeature &feature, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags()) override
Adds a single feature to the sink.
Encapsulates settings relating to a feature source input to a processing algorithm.
bool selectedFeaturesOnly
true if only selected features in the source should be used by algorithms.
QgsProperty source
Source definition.
Qgis::InvalidGeometryCheck geometryCheck
Geometry check method to apply to this source.
Qgis::ProcessingFeatureSourceDefinitionFlags flags
Flags which dictate source behavior.
long long featureLimit
If set to a value > 0, places a limit on the maximum number of features which will be read from the s...
QString filterExpression
Optional expression filter to use for filtering features which will be read from the source.
QgsFeatureSource subclass which proxies methods to an underlying QgsFeatureSource,...
QgsRectangle sourceExtent() const override
Returns the extent of all geometries from the source.
QSet< QVariant > uniqueValues(int fieldIndex, int limit=-1) const override
Returns the set of unique values contained within the specified fieldIndex from this source.
QgsExpressionContextScope * createExpressionContextScope() const
Returns an expression context scope suitable for this source.
QgsProcessingFeatureSource(QgsFeatureSource *originalSource, const QgsProcessingContext &context, bool ownsOriginalSource=false, long long featureLimit=-1, const QString &filterExpression=QString())
Constructor for QgsProcessingFeatureSource, accepting an original feature source originalSource and p...
void setInvalidGeometryCheck(Qgis::InvalidGeometryCheck method)
Overrides the default geometry check method for the source.
Qgis::InvalidGeometryCheck invalidGeometryCheck() const
Returns the geometry check method for the source.
QVariant maximumValue(int fieldIndex) const override
Returns the maximum value for an attribute column or an invalid variant in case of error.
~QgsProcessingFeatureSource() override
QgsCoordinateReferenceSystem sourceCrs() const override
Returns the coordinate reference system for features in the source.
Qgis::WkbType wkbType() const override
Returns the geometry type for features returned by this source.
QVariant minimumValue(int fieldIndex) const override
Returns the minimum value for an attribute column or an invalid variant in case of error.
long long featureCount() const override
Returns the number of features contained in the source, or -1 if the feature count is unknown.
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request, Qgis::ProcessingFeatureSourceFlags flags) const
Returns an iterator for the features in the source, respecting the supplied feature flags.
Qgis::FeatureAvailability hasFeatures() const override
Determines if there are any features available in the source.
QString sourceName() const override
Returns a friendly display name for the source.
QgsFeatureIds allFeatureIds() const override
Returns a list of all feature IDs for features present in the source.
Qgis::SpatialIndexPresence hasSpatialIndex() const override
Returns an enum value representing the presence of a valid spatial index on the source,...
QgsFields fields() const override
Returns the fields associated with features in the source.
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.
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.
static QList< QgsTiledSceneLayer * > compatibleTiledSceneLayers(QgsProject *project, bool sort=true)
Returns a list of tiled scene layers from a project which are compatible with the processing framewor...
static QString stringToPythonLiteral(const QString &string)
Converts a string to a Python string literal.
static QString defaultVectorExtension()
Returns the default vector extension to use, in the absence of all other constraints (e....
static QVariant generateIteratingDestination(const QVariant &input, const QVariant &id, QgsProcessingContext &context)
Converts an input parameter value for use in source iterating mode, where one individual sink is crea...
static QgsFields indicesToFields(const QList< int > &indices, const QgsFields &fields)
Returns a subset of fields based on the indices of desired fields.
static QList< int > fieldNamesToIndices(const QStringList &fieldNames, const QgsFields &fields)
Returns a list of field indices parsed from the given list of field names.
static QString layerToStringIdentifier(const QgsMapLayer *layer, const QString &layerName=QString())
Returns a string representation of the source for a layer.
static QVariantMap preprocessQgisProcessParameters(const QVariantMap ¶meters, bool &ok, QString &error)
Pre-processes a set of parameter values for the qgis_process command.
static QList< QgsAnnotationLayer * > compatibleAnnotationLayers(QgsProject *project, bool sort=true)
Returns a list of annotation layers from a project which are compatible with the processing framework...
static QString generateTempFilename(const QString &basename, const QgsProcessingContext *context=nullptr)
Returns a temporary filename for a given file, putting it into a temporary folder (creating that fold...
static QString normalizeLayerSource(const QString &source)
Normalizes a layer source string for safe comparison across different operating system environments.
static QString formatHelpMapAsHtml(const QVariantMap &map, const QgsProcessingAlgorithm *algorithm)
Returns a HTML formatted version of the help text encoded in a variant map for a specified algorithm.
static QgsFields combineFields(const QgsFields &fieldsA, const QgsFields &fieldsB, const QString &fieldsBPrefix=QString())
Combines two field lists, avoiding duplicate field names (in a case-insensitive manner).
static QString encodeProviderKeyAndUri(const QString &providerKey, const QString &uri)
Encodes a provider key and layer uri to a single string, for use with decodeProviderKeyAndUri()
LayerHint
Layer type hints.
@ TiledScene
Tiled scene layer type, since QGIS 3.34.
@ Annotation
Annotation layer type, since QGIS 3.22.
@ Vector
Vector layer type.
@ VectorTile
Vector tile layer type, since QGIS 3.32.
@ Mesh
Mesh layer type, since QGIS 3.6.
@ Raster
Raster layer type.
@ UnknownType
Unknown layer type.
@ PointCloud
Point cloud layer type, since QGIS 3.22.
static QgsProcessingFeatureSource * variantToSource(const QVariant &value, QgsProcessingContext &context, const QVariant &fallbackValue=QVariant())
Converts a variant value to a new feature source.
static QList< QgsRasterLayer * > compatibleRasterLayers(QgsProject *project, bool sort=true)
Returns a list of raster layers from a project which are compatible with the processing framework.
static int outputDefinitionIndex(const QgsProcessingAlgorithm *algorithm, const QString &name)
Returns the index of the output matching name for a specified algorithm.
static QgsRectangle combineLayerExtents(const QList< QgsMapLayer * > &layers, const QgsCoordinateReferenceSystem &crs, QgsProcessingContext &context)
Combines the extent of several map layers.
static QString resolveDefaultEncoding(const QString &defaultEncoding="System")
Returns the default encoding.
static QList< QgsPluginLayer * > compatiblePluginLayers(QgsProject *project, bool sort=true)
Returns a list of plugin layers from a project which are compatible with the processing framework.
static QString variantToPythonLiteral(const QVariant &value)
Converts a variant to a Python literal.
static QgsCoordinateReferenceSystem variantToCrs(const QVariant &value, QgsProcessingContext &context, const QVariant &fallbackValue=QVariant())
Converts a variant value to a coordinate reference system.
static QList< QgsVectorLayer * > compatibleVectorLayers(QgsProject *project, const QList< int > &sourceTypes=QList< int >(), bool sort=true)
Returns a list of vector layers from a project which are compatible with the processing framework.
static QVariantMap removePointerValuesFromMap(const QVariantMap &map)
Removes any raw pointer values from an input map, replacing them with appropriate string values where...
static bool decodeProviderKeyAndUri(const QString &string, QString &providerKey, QString &uri)
Decodes a provider key and layer uri from an encoded string, for use with encodeProviderKeyAndUri()
static void createFeatureSinkPython(QgsFeatureSink **sink, QString &destination, QgsProcessingContext &context, const QgsFields &fields, Qgis::WkbType geometryType, const QgsCoordinateReferenceSystem &crs, const QVariantMap &createOptions=QVariantMap())
Creates a feature sink ready for adding features.
static QList< QgsVectorTileLayer * > compatibleVectorTileLayers(QgsProject *project, bool sort=true)
Returns a list of vector tile layers from a project which are compatible with the processing framewor...
static QString convertToCompatibleFormatAndLayerName(const QgsVectorLayer *layer, bool selectedFeaturesOnly, const QString &baseName, const QStringList &compatibleFormats, const QString &preferredFormat, QgsProcessingContext &context, QgsProcessingFeedback *feedback, QString &layerName, long long featureLimit=-1, const QString &filterExpression=QString())
Converts a source vector layer to a file path and layer name of a vector layer of compatible format.
static QList< QgsMapLayer * > compatibleLayers(QgsProject *project, bool sort=true)
Returns a list of map layers from a project which are compatible with the processing framework.
static QString convertToCompatibleFormat(const QgsVectorLayer *layer, bool selectedFeaturesOnly, const QString &baseName, const QStringList &compatibleFormats, const QString &preferredFormat, QgsProcessingContext &context, QgsProcessingFeedback *feedback, long long featureLimit=-1, const QString &filterExpression=QString())
Converts a source vector layer to a file path of a vector layer of compatible format.
static QgsFeatureSink * createFeatureSink(QString &destination, QgsProcessingContext &context, const QgsFields &fields, Qgis::WkbType geometryType, const QgsCoordinateReferenceSystem &crs, const QVariantMap &createOptions=QVariantMap(), const QStringList &datasourceOptions=QStringList(), const QStringList &layerOptions=QStringList(), QgsFeatureSink::SinkFlags sinkFlags=QgsFeatureSink::SinkFlags(), QgsRemappingSinkDefinition *remappingDefinition=nullptr)
Creates a feature sink ready for adding features.
static QString defaultRasterExtension()
Returns the default raster extension to use, in the absence of all other constraints (e....
static QString defaultVectorTileExtension()
Returns the default vector tile extension to use, in the absence of all other constraints (e....
static QgsMapLayer * mapLayerFromString(const QString &string, QgsProcessingContext &context, bool allowLoadingNewLayers=true, QgsProcessingUtils::LayerHint typeHint=QgsProcessingUtils::LayerHint::UnknownType, QgsProcessing::LayerOptionsFlags flags=QgsProcessing::LayerOptionsFlags())
Interprets a string as a map layer within the supplied context.
static QString defaultPointCloudExtension()
Returns the default point cloud extension to use, in the absence of all other constraints (e....
static QList< QgsPointCloudLayer * > compatiblePointCloudLayers(QgsProject *project, bool sort=true)
Returns a list of point cloud layers from a project which are compatible with the processing framewor...
static QList< QgsMeshLayer * > compatibleMeshLayers(QgsProject *project, bool sort=true)
Returns a list of mesh layers from a project which are compatible with the processing framework.
static QString tempFolder(const QgsProcessingContext *context=nullptr)
Returns a session specific processing temporary folder for use in processing algorithms.
QFlags< LayerOptionsFlag > LayerOptionsFlags
static const QgsSettingsEntryString * settingsTempPath
Settings entry temp path.
static const QString TEMPORARY_OUTPUT
Constant used to indicate that a Processing algorithm output should be a temporary layer/file.
static const QgsSettingsEntryString * settingsDefaultOutputRasterLayerExt
Settings entry default output raster layer ext.
static const QgsSettingsEntryString * settingsDefaultOutputVectorLayerExt
Settings entry default output vector layer ext.
@ SkipIndexGeneration
Do not generate index when creating a layer. Makes sense only for point cloud layers.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
QgsAnnotationLayer * mainAnnotationLayer()
Returns the main annotation layer associated with the project.
QVector< T > layers() const
Returns a list of registered map layers with a specified layer type.
QgsCoordinateReferenceSystem crs
A store for object properties.
QString asExpression() const
Returns an expression string representing the state of the property, or an empty string if the proper...
Qgis::PropertyType propertyType() const
Returns the property type.
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...
static QgsProperty fromExpression(const QString &expression, bool isActive=true)
Returns a new ExpressionBasedProperty created from the specified expression.
static QgsProperty fromField(const QString &fieldName, bool isActive=true)
Returns a new FieldBasedProperty created from the specified field name.
static QgsProperty fromValue(const QVariant &value, bool isActive=true)
Returns a new StaticProperty created from the specified value.
QVariantMap decodeUri(const QString &providerKey, const QString &uri)
Breaks a provider data source URI into its component paths (e.g.
static QgsProviderRegistry * instance(const QString &pluginPath=QString())
Means of accessing canonical single instance.
QList< QgsProviderRegistry::ProviderCandidateDetails > preferredProvidersForUri(const QString &uri) const
Returns the details for the preferred provider(s) for opening the specified uri.
QString encodeUri(const QString &providerKey, const QVariantMap &parts)
Reassembles a provider data source URI from its component paths (e.g.
QgsProviderMetadata * providerMetadata(const QString &providerKey) const
Returns metadata of the provider or nullptr if not found.
A simple feature sink which proxies feature addition onto another feature sink.
bool addFeature(QgsFeature &feature, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags()) override
Adds a single feature to the sink.
bool flushBuffer() override
Flushes any internal buffer which may exist in the sink, causing any buffered features to be added to...
QgsFeatureSink * mSink
Underlying destination sink.
QString lastError() const override
Returns the most recent error encountered by the sink, e.g.
bool addFeatures(QgsFeatureList &features, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags()) override
Adds a list of features to the sink.
static QStringList supportedFormatExtensions(RasterFormatOptions options=SortRecommended)
Returns a list of file extensions for supported formats.
Represents a raster layer.
A rectangle specified with double values.
void combineExtentWith(const QgsRectangle &rect)
Expands the rectangle so that it covers both the original rectangle and the given rectangle.
QgsCoordinateReferenceSystem crs() const
Returns the associated coordinate reference system, or an invalid CRS if no reference system is set.
A QgsPointXY with associated coordinate reference system.
A QgsRectangle with associated coordinate reference system.
Defines the parameters used to remap features when creating a QgsRemappingProxyFeatureSink.
void setDestinationCrs(const QgsCoordinateReferenceSystem &destination)
Sets the destination crs used for reprojecting incoming features to the sink's destination CRS.
void setDestinationWkbType(Qgis::WkbType type)
Sets the WKB geometry type for the destination.
void setDestinationFields(const QgsFields &fields)
Sets the fields for the destination sink.
T value(const QString &dynamicKeyPart=QString()) const
Returns settings value.
Represents a map layer supporting display of tiled scene objects.
static bool isNull(const QVariant &variant, bool silenceNullWarnings=false)
Returns true if the specified variant should be considered a NULL value.
virtual Qgis::VectorDataProviderAttributeEditCapabilities attributeEditCapabilities() const
Returns the provider's supported attribute editing capabilities.
Options to pass to QgsVectorFileWriter::writeAsVectorFormat().
QString fileEncoding
Encoding to use.
QString driverName
OGR driver to use.
QString layerName
Layer name. If let empty, it will be derived from the filename.
QStringList layerOptions
List of OGR layer creation options.
Qgis::FeatureSymbologyExport symbologyExport
Symbology to export.
QgsVectorFileWriter::ActionOnExistingFile actionOnExistingFile
Action on existing file.
QStringList datasourceOptions
List of OGR data source creation options.
static QStringList defaultLayerOptions(const QString &driverName)
Returns a list of the default layer options for a specified driver.
static QString driverForExtension(const QString &extension)
Returns the OGR driver name for a specified file extension.
static QgsVectorFileWriter * create(const QString &fileName, const QgsFields &fields, Qgis::WkbType geometryType, const QgsCoordinateReferenceSystem &srs, const QgsCoordinateTransformContext &transformContext, const QgsVectorFileWriter::SaveVectorOptions &options, QgsFeatureSink::SinkFlags sinkFlags=QgsFeatureSink::SinkFlags(), QString *newFilename=nullptr, QString *newLayer=nullptr)
Create a new vector file writer.
static QStringList defaultDatasetOptions(const QString &driverName)
Returns a list of the default dataset options for a specified driver.
static QStringList supportedFormatExtensions(VectorFormatOptions options=SortRecommended)
Returns a list of file extensions for supported formats, e.g "shp", "gpkg".
@ CreateOrOverwriteFile
Create or overwrite file.
@ AppendToLayerNoNewFields
Append features to existing layer, but do not create new fields.
QgsFeatureSource subclass for the selected features from a QgsVectorLayer.
Represents a vector layer which manages a vector based dataset.
bool isSpatial() const FINAL
Returns true if this is a geometry layer and false in case of NoGeometry (table only) or UnknownGeome...
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest()) const FINAL
Queries the layer for features specified in request.
Q_INVOKABLE Qgis::WkbType wkbType() const FINAL
Returns the WKBType or WKBUnknown in case of error.
QgsFeatureIterator getSelectedFeatures(QgsFeatureRequest request=QgsFeatureRequest()) const
Returns an iterator of the selected features.
QgsVectorDataProvider * dataProvider() FINAL
Returns the layer's data provider, it may be nullptr.
Q_INVOKABLE Qgis::GeometryType geometryType() const
Returns point, line or polygon.
QgsRectangle extent() const FINAL
Returns the extent of the layer.
Implements a map layer that is dedicated to rendering of vector tiles.
Handles storage of information regarding WKB types and their properties.
@ UnknownCount
Provider returned an unknown feature count.
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 allowing algorithms to be written in pure substantial changes are required in order to port existing x Processing algorithms for QGIS x The most significant changes are outlined not GeoAlgorithm For algorithms which operate on features one by consider subclassing the QgsProcessingFeatureBasedAlgorithm class This class allows much of the boilerplate code for looping over features from a vector layer to be bypassed and instead requires implementation of a processFeature method Ensure that your algorithm(or algorithm 's parent class) implements the new pure virtual createInstance(self) call
bool qgsVariantLessThan(const QVariant &lhs, const QVariant &rhs)
Compares two QVariant values and returns whether the first is less than the second.
bool qgsVariantGreaterThan(const QVariant &lhs, const QVariant &rhs)
Compares two QVariant values and returns whether the first is greater than the second.
QString qgsDoubleToString(double a, int precision=17)
Returns a string representation of a double.
QList< QgsFeature > QgsFeatureList
QSet< QgsFeatureId > QgsFeatureIds
QList< int > QgsAttributeList
QString convertToCompatibleFormatInternal(const QgsVectorLayer *vl, bool selectedFeaturesOnly, const QString &baseName, const QStringList &compatibleFormats, const QString &preferredFormat, QgsProcessingContext &context, QgsProcessingFeedback *feedback, QString *layerName, long long featureLimit, const QString &filterExpression, bool renameFid)
const QgsCoordinateReferenceSystem & crs
Setting options for loading mesh layers.
bool skipCrsValidation
Controls whether the layer is allowed to have an invalid/unknown CRS.
Setting options for loading point cloud layers.
bool skipCrsValidation
Controls whether the layer is allowed to have an invalid/unknown CRS.
bool skipIndexGeneration
Set to true if point cloud index generation should be skipped.
Setting options for loading raster layers.
bool skipCrsValidation
Controls whether the layer is allowed to have an invalid/unknown CRS.
bool loadDefaultStyle
Sets to true if the default layer style should be loaded.
Setting options for loading tiled scene layers.
bool skipCrsValidation
Controls whether the layer is allowed to have an invalid/unknown CRS.
Setting options for loading vector layers.