40#include <QRegularExpression>
46 return compatibleMapLayers< QgsRasterLayer >( project, sort );
52 return QList<QgsVectorLayer *>();
54 QList<QgsVectorLayer *> layers;
58 if ( canUseLayer( l, geometryTypes ) )
66 return QString::localeAwareCompare( a->name(), b->name() ) < 0;
74 return compatibleMapLayers< QgsMeshLayer >( project, sort );
79 return compatibleMapLayers< QgsPluginLayer >( project, sort );
84 return compatibleMapLayers< QgsPointCloudLayer >( project, sort );
90 QList<QgsAnnotationLayer *> res = compatibleMapLayers< QgsAnnotationLayer >( project,
false );
98 return QString::localeAwareCompare( a->name(), b->name() ) < 0;
107 return compatibleMapLayers< QgsVectorTileLayer >( project, sort );
112 return compatibleMapLayers< QgsTiledSceneLayer >( project, sort );
115template<
typename T> QList<T *> QgsProcessingUtils::compatibleMapLayers(
QgsProject *project,
bool sort )
121 const auto projectLayers = project->
layers<T *>();
122 for ( T *l : projectLayers )
124 if ( canUseLayer( l ) )
130 std::sort( layers.begin(), layers.end(), [](
const T * a,
const T * b ) ->
bool
132 return QString::localeAwareCompare( a->name(), b->name() ) < 0;
141 return QList<QgsMapLayer *>();
143 QList<QgsMapLayer *> layers;
145 const auto rasterLayers = compatibleMapLayers< QgsRasterLayer >( project,
false );
153 const auto meshLayers = compatibleMapLayers< QgsMeshLayer >( project,
false );
157 const auto pointCloudLayers = compatibleMapLayers< QgsPointCloudLayer >( project,
false );
161 const auto annotationLayers = compatibleMapLayers< QgsAnnotationLayer >( project,
false );
166 const auto vectorTileLayers = compatibleMapLayers< QgsVectorTileLayer >( project,
false );
170 const auto tiledSceneLayers = compatibleMapLayers< QgsTiledSceneLayer >( project,
false );
174 const auto pluginLayers = compatibleMapLayers< QgsPluginLayer >( project,
false );
182 return QString::localeAwareCompare( a->name(), b->name() ) < 0;
190 return QStringLiteral(
"%1://%2" ).arg( providerKey, uri );
195 const thread_local QRegularExpression re( QStringLiteral(
"^(\\w+?):\\/\\/(.+)$" ) );
196 const QRegularExpressionMatch match = re.match(
string );
197 if ( !match.hasMatch() )
200 providerKey = match.captured( 1 );
201 uri = match.captured( 2 );
209 if ( !store ||
string.isEmpty() )
212 QList< QgsMapLayer * > layers = store->
mapLayers().values();
214 layers.erase( std::remove_if( layers.begin(), layers.end(), [](
QgsMapLayer * layer )
216 switch ( layer->type() )
218 case Qgis::LayerType::Vector:
219 return !canUseLayer( qobject_cast< QgsVectorLayer * >( layer ) );
220 case Qgis::LayerType::Raster:
221 return !canUseLayer( qobject_cast< QgsRasterLayer * >( layer ) );
222 case Qgis::LayerType::Plugin:
223 case Qgis::LayerType::Group:
225 case Qgis::LayerType::Mesh:
226 return !canUseLayer( qobject_cast< QgsMeshLayer * >( layer ) );
227 case Qgis::LayerType::VectorTile:
228 return !canUseLayer( qobject_cast< QgsVectorTileLayer * >( layer ) );
229 case Qgis::LayerType::TiledScene:
230 return !canUseLayer( qobject_cast< QgsTiledSceneLayer * >( layer ) );
231 case Qgis::LayerType::PointCloud:
232 return !canUseLayer( qobject_cast< QgsPointCloudLayer * >( layer ) );
233 case Qgis::LayerType::Annotation:
234 return !canUseLayer( qobject_cast< QgsAnnotationLayer * >( layer ) );
239 auto isCompatibleType = [typeHint](
QgsMapLayer * l ) ->
bool
243 case LayerHint::UnknownType:
246 case LayerHint::Vector:
249 case LayerHint::Raster:
252 case LayerHint::Mesh:
255 case LayerHint::PointCloud:
258 case LayerHint::Annotation:
261 case LayerHint::VectorTile:
264 case LayerHint::TiledScene:
272 if ( isCompatibleType( l ) && l->id() ==
string )
277 if ( isCompatibleType( l ) && l->name() ==
string )
282 if ( isCompatibleType( l ) && normalizeLayerSource( l->source() ) == normalizeLayerSource(
string ) )
299 if ( providerMetadata )
302 const QVariantMap parts = providerMetadata->
decodeUri( uri );
303 const QString layerName = parts.value( QStringLiteral(
"layerName" ) ).toString();
305 if ( !layerName.isEmpty() )
309 else if (
const QString path = parts.value( QStringLiteral(
"path" ) ).toString(); !path.isEmpty() )
311 name = QFileInfo( path ).baseName();
316 const QStringList components = uri.split(
'|' );
317 if ( components.isEmpty() )
320 if ( QFileInfo fi( components.at( 0 ) ); fi.isFile() )
321 name = fi.baseName();
323 name = QFileInfo( uri ).baseName();
326 if ( name.isEmpty() )
330 if ( name.isEmpty() )
335 QList< Qgis::LayerType > candidateTypes;
340 if ( providerMetadata )
374 options.loadDefaultStyle =
false;
375 options.skipCrsValidation =
true;
377 std::unique_ptr< QgsVectorLayer > layer;
378 if ( providerMetadata )
380 layer = std::make_unique<QgsVectorLayer>( uri, name, providerMetadata->
key(), options );
385 layer = std::make_unique<QgsVectorLayer>( uri, name, QStringLiteral(
"ogr" ), options );
387 if ( layer->isValid() )
389 return layer.release();
398 std::unique_ptr< QgsRasterLayer > rasterLayer;
399 if ( providerMetadata )
401 rasterLayer = std::make_unique< QgsRasterLayer >( uri, name, providerMetadata->
key(), rasterOptions );
406 rasterLayer = std::make_unique< QgsRasterLayer >( uri, name, QStringLiteral(
"gdal" ), rasterOptions );
409 if ( rasterLayer->isValid() )
411 return rasterLayer.release();
419 std::unique_ptr< QgsMeshLayer > meshLayer;
420 if ( providerMetadata )
422 meshLayer = std::make_unique< QgsMeshLayer >( uri, name, providerMetadata->
key(), meshOptions );
426 meshLayer = std::make_unique< QgsMeshLayer >( uri, name, QStringLiteral(
"mdal" ), meshOptions );
428 if ( meshLayer->isValid() )
430 return meshLayer.release();
443 std::unique_ptr< QgsPointCloudLayer > pointCloudLayer;
444 if ( providerMetadata )
446 pointCloudLayer = std::make_unique< QgsPointCloudLayer >( uri, name, providerMetadata->
key(), pointCloudOptions );
451 if ( !preferredProviders.empty() )
453 pointCloudLayer = std::make_unique< QgsPointCloudLayer >( uri, name, preferredProviders.at( 0 ).metadata()->key(), pointCloudOptions );
463 pointCloudLayer = std::make_unique< QgsPointCloudLayer >( uri, name, QStringLiteral(
"pdal" ), pointCloudOptions );
467 if ( pointCloudLayer && pointCloudLayer->isValid() )
469 return pointCloudLayer.release();
475 dsUri.
setParam(
"type",
"mbtiles" );
478 std::unique_ptr< QgsVectorTileLayer > tileLayer;
479 tileLayer = std::make_unique< QgsVectorTileLayer >( dsUri.
encodedUri(), name );
481 if ( tileLayer->isValid() )
483 return tileLayer.release();
491 std::unique_ptr< QgsTiledSceneLayer > tiledSceneLayer;
492 if ( providerMetadata )
494 tiledSceneLayer = std::make_unique< QgsTiledSceneLayer >( uri, name, providerMetadata->
key(), tiledSceneOptions );
499 if ( !preferredProviders.empty() )
501 tiledSceneLayer = std::make_unique< QgsTiledSceneLayer >( uri, name, preferredProviders.at( 0 ).metadata()->key(), tiledSceneOptions );
504 if ( tiledSceneLayer && tiledSceneLayer->isValid() )
506 return tiledSceneLayer.release();
514 if (
string.isEmpty() )
522 if (
auto *lProject = context.
project() )
524 QgsMapLayer *layer = mapLayerFromStore(
string, lProject->layerStore(), typeHint );
533 if ( !allowLoadingNewLayers )
536 layer = loadMapLayerFromString(
string, context.
transformContext(), typeHint, flags );
550 QVariant val = value;
551 bool selectedFeaturesOnly =
false;
552 long long featureLimit = -1;
553 QString filterExpression;
554 bool overrideGeometryCheck =
false;
556 if ( val.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
567 else if ( val.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
574 if (
QgsVectorLayer *layer = qobject_cast< QgsVectorLayer * >( qvariant_cast<QObject *>( val ) ) )
576 std::unique_ptr< QgsProcessingFeatureSource> source = std::make_unique< QgsProcessingFeatureSource >( layer, context,
false, featureLimit, filterExpression );
577 if ( overrideGeometryCheck )
578 source->setInvalidGeometryCheck( geometryCheck );
579 return source.release();
583 if ( val.userType() == qMetaTypeId<QgsProperty>() )
587 else if ( !val.isValid() || val.toString().isEmpty() )
590 if (
QgsVectorLayer *layer = qobject_cast< QgsVectorLayer * >( qvariant_cast<QObject *>( fallbackValue ) ) )
592 std::unique_ptr< QgsProcessingFeatureSource> source = std::make_unique< QgsProcessingFeatureSource >( layer, context,
false, featureLimit, filterExpression );
593 if ( overrideGeometryCheck )
594 source->setInvalidGeometryCheck( geometryCheck );
595 return source.release();
598 layerRef = fallbackValue.toString();
602 layerRef = val.toString();
605 if ( layerRef.isEmpty() )
612 std::unique_ptr< QgsProcessingFeatureSource> source;
613 if ( selectedFeaturesOnly )
619 source = std::make_unique< QgsProcessingFeatureSource >( vl, context,
false, featureLimit, filterExpression );
622 if ( overrideGeometryCheck )
623 source->setInvalidGeometryCheck( geometryCheck );
624 return source.release();
629 QVariant val = value;
631 if ( val.userType() == qMetaTypeId<QgsCoordinateReferenceSystem>() )
636 else if ( val.userType() == qMetaTypeId<QgsProcessingFeatureSourceDefinition>() )
642 else if ( val.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
655 if (
QgsMapLayer *layer = qobject_cast< QgsMapLayer * >( qvariant_cast<QObject *>( val ) ) )
658 if ( val.userType() == qMetaTypeId<QgsProperty>() )
661 if ( !val.isValid() )
667 QString crsText = val.toString();
668 if ( crsText.isEmpty() )
669 crsText = fallbackValue.toString();
671 if ( crsText.isEmpty() )
675 if ( context.
project() && crsText.compare( QLatin1String(
"ProjectCrs" ), Qt::CaseInsensitive ) == 0 )
691bool QgsProcessingUtils::canUseLayer(
const QgsMeshLayer *layer )
696bool QgsProcessingUtils::canUseLayer(
const QgsPluginLayer *layer )
698 return layer && layer->
isValid();
703 return layer && layer->
isValid();
706bool QgsProcessingUtils::canUseLayer(
const QgsRasterLayer *layer )
708 return layer && layer->
isValid();
713 return layer && layer->
isValid();
718 return layer && layer->
isValid();
723 return layer && layer->
isValid();
726bool QgsProcessingUtils::canUseLayer(
const QgsVectorLayer *layer,
const QList<int> &sourceTypes )
728 return layer && layer->
isValid() &&
729 ( sourceTypes.isEmpty()
740 QString normalized = source;
741 normalized.replace(
'\\',
'/' );
742 return normalized.trimmed();
751 if ( !source.isEmpty() )
756 if ( provider.compare( QLatin1String(
"gdal" ), Qt::CaseInsensitive ) == 0
757 || provider.compare( QLatin1String(
"ogr" ), Qt::CaseInsensitive ) == 0
758 || provider.compare( QLatin1String(
"mdal" ), Qt::CaseInsensitive ) == 0 )
761 return QStringLiteral(
"%1://%2" ).arg( provider, source );
768 if ( !value.isValid() )
769 return QStringLiteral(
"None" );
771 if ( value.userType() == qMetaTypeId<QgsProperty>() )
772 return QStringLiteral(
"QgsProperty.fromExpression('%1')" ).arg( value.value<
QgsProperty >().
asExpression() );
773 else if ( value.userType() == qMetaTypeId<QgsCoordinateReferenceSystem>() )
776 return QStringLiteral(
"QgsCoordinateReferenceSystem()" );
780 else if ( value.userType() == qMetaTypeId<QgsRectangle>() )
788 else if ( value.userType() == qMetaTypeId<QgsReferencedRectangle>() )
796 else if ( value.userType() == qMetaTypeId<QgsPointXY>() )
802 else if ( value.userType() == qMetaTypeId<QgsReferencedPointXY>() )
810 switch ( value.userType() )
812 case QMetaType::Type::Bool:
813 return value.toBool() ? QStringLiteral(
"True" ) : QStringLiteral(
"False" );
815 case QMetaType::Type::Double:
816 return QString::number( value.toDouble() );
818 case QMetaType::Type::Int:
819 case QMetaType::Type::UInt:
820 return QString::number( value.toInt() );
822 case QMetaType::Type::LongLong:
823 case QMetaType::Type::ULongLong:
824 return QString::number( value.toLongLong() );
826 case QMetaType::Type::QVariantList:
829 const QVariantList vl = value.toList();
830 for (
const QVariant &v : vl )
834 return parts.join(
',' ).prepend(
'[' ).append(
']' );
837 case QMetaType::Type::QVariantMap:
839 const QVariantMap map = value.toMap();
841 parts.reserve( map.size() );
842 for (
auto it = map.constBegin(); it != map.constEnd(); ++it )
846 return parts.join(
',' ).prepend(
'{' ).append(
'}' );
849 case QMetaType::Type::QDateTime:
851 const QDateTime dateTime = value.toDateTime();
852 return QStringLiteral(
"QDateTime(QDate(%1, %2, %3), QTime(%4, %5, %6))" )
853 .arg( dateTime.date().year() )
854 .arg( dateTime.date().month() )
855 .arg( dateTime.date().day() )
856 .arg( dateTime.time().hour() )
857 .arg( dateTime.time().minute() )
858 .arg( dateTime.time().second() );
871 s.replace(
'\\', QLatin1String(
"\\\\" ) );
872 s.replace(
'\n', QLatin1String(
"\\n" ) );
873 s.replace(
'\r', QLatin1String(
"\\r" ) );
874 s.replace(
'\t', QLatin1String(
"\\t" ) );
876 if ( s.contains(
'\'' ) && !s.contains(
'\"' ) )
878 s = s.prepend(
'"' ).append(
'"' );
882 s.replace(
'\'', QLatin1String(
"\\\'" ) );
883 s = s.prepend(
'\'' ).append(
'\'' );
888void QgsProcessingUtils::parseDestinationString( QString &destination, QString &providerKey, QString &uri, QString &layerName, QString &format, QMap<QString, QVariant> &options,
bool &useWriter, QString &extension )
895 const thread_local QRegularExpression splitRx( QStringLiteral(
"^(.{3,}?):(.*)$" ) );
896 QRegularExpressionMatch match = splitRx.match( destination );
897 if ( match.hasMatch() )
899 providerKey = match.captured( 1 );
900 uri = match.captured( 2 );
907 if ( providerKey == QLatin1String(
"postgis" ) )
909 providerKey = QStringLiteral(
"postgres" );
911 if ( providerKey == QLatin1String(
"ogr" ) )
916 if ( !dsUri.
table().isEmpty() )
918 layerName = dsUri.
table();
919 options.insert( QStringLiteral(
"layerName" ), layerName );
922 extension = QFileInfo( uri ).completeSuffix();
924 options.insert( QStringLiteral(
"driverName" ), format );
928 extension = QFileInfo( uri ).completeSuffix();
931 options.insert( QStringLiteral(
"update" ),
true );
938 providerKey = QStringLiteral(
"ogr" );
940 const thread_local QRegularExpression splitRx( QStringLiteral(
"^(.*)\\.(.*?)$" ) );
941 QRegularExpressionMatch match = splitRx.match( destination );
942 if ( match.hasMatch() )
944 extension = match.captured( 2 );
948 if ( format.isEmpty() )
950 format = QStringLiteral(
"GPKG" );
951 destination = destination + QStringLiteral(
".gpkg" );
954 options.insert( QStringLiteral(
"driverName" ), format );
961 QVariantMap options = createOptions;
962 if ( !options.contains( QStringLiteral(
"fileEncoding" ) ) )
968 if ( destination.isEmpty() || destination.startsWith( QLatin1String(
"memory:" ) ) )
971 if ( destination.startsWith( QLatin1String(
"memory:" ) ) )
972 destination = destination.mid( 7 );
974 if ( destination.isEmpty() )
975 destination = QStringLiteral(
"output" );
979 if ( !layer || !layer->isValid() )
986 for (
const QgsField &field : fields )
989 if ( !field.alias().isEmpty() )
990 feedback->pushWarning( QObject::tr(
"%1: Aliases are not compatible with scratch layers" ).arg( field.name() ) );
991 if ( !field.alias().isEmpty() )
992 feedback->pushWarning( QObject::tr(
"%1: Comments are not compatible with scratch layers" ).arg( field.name() ) );
999 destination = layer->id();
1002 std::unique_ptr< QgsProcessingFeatureSink > sink(
new QgsProcessingFeatureSink( layer->dataProvider(), destination, context ) );
1005 return sink.release();
1009 QString providerKey;
1014 bool useWriter =
false;
1015 parseDestinationString( destination, providerKey, uri, layerName, format, options, useWriter, extension );
1018 if ( useWriter && providerKey == QLatin1String(
"ogr" ) )
1022 QString finalFileName;
1023 QString finalLayerName;
1025 saveOptions.
fileEncoding = options.value( QStringLiteral(
"fileEncoding" ) ).toString();
1026 saveOptions.
layerName = !layerName.isEmpty() ? layerName : options.value( QStringLiteral(
"layerName" ) ).toString();
1031 if ( remappingDefinition )
1035 std::unique_ptr< QgsVectorLayer > vl = std::make_unique< QgsVectorLayer >( destination );
1036 if ( vl->isValid() )
1040 newFields = vl->fields();
1050 if ( writer->hasError() )
1052 throw QgsProcessingException( QObject::tr(
"Could not create layer %1: %2" ).arg( destination, writer->errorMessage() ) );
1057 for (
const QgsField &field : fields )
1060 feedback->pushWarning( QObject::tr(
"%1: Aliases are not supported by %2" ).arg( field.name(), writer->driverLongName() ) );
1062 feedback->pushWarning( QObject::tr(
"%1: Comments are not supported by %2" ).arg( field.name(), writer->driverLongName() ) );
1066 destination = finalFileName;
1067 if ( !saveOptions.
layerName.isEmpty() && !finalLayerName.isEmpty() )
1068 destination += QStringLiteral(
"|layername=%1" ).arg( finalLayerName );
1070 if ( remappingDefinition )
1072 std::unique_ptr< QgsRemappingProxyFeatureSink > remapSink = std::make_unique< QgsRemappingProxyFeatureSink >( *remappingDefinition, writer.release(),
true );
1083 if ( remappingDefinition )
1088 if ( !layerName.isEmpty() )
1091 parts.insert( QStringLiteral(
"layerName" ), layerName );
1095 std::unique_ptr< QgsVectorLayer > layer = std::make_unique<QgsVectorLayer>( uri, destination, providerKey, layerOptions );
1097 destination = layer->id();
1098 if ( layer->isValid() )
1108 for (
const QgsField &field : fields )
1111 feedback->pushWarning( QObject::tr(
"%1: Aliases are not supported by the %2 provider" ).arg( field.name(), providerKey ) );
1113 feedback->pushWarning( QObject::tr(
"%1: Comments are not supported by the %2 provider" ).arg( field.name(), providerKey ) );
1117 std::unique_ptr< QgsRemappingProxyFeatureSink > remapSink = std::make_unique< QgsRemappingProxyFeatureSink >( *remappingDefinition, layer->dataProvider(),
false );
1127 std::unique_ptr< QgsVectorLayerExporter > exporter = std::make_unique<QgsVectorLayerExporter>( uri, providerKey, newFields, geometryType,
crs,
true, options, sinkFlags );
1130 throw QgsProcessingException( QObject::tr(
"Could not create layer %1: %2" ).arg( destination, exporter->errorMessage() ) );
1134 if ( !layerName.isEmpty() )
1136 uri += QStringLiteral(
"|layername=%1" ).arg( layerName );
1143 for (
const QgsField &field : fields )
1146 feedback->pushWarning( QObject::tr(
"%1: Aliases are not supported by the %2 provider" ).arg( field.name(), providerKey ) );
1148 feedback->pushWarning( QObject::tr(
"%1: Comments are not supported by the %2 provider" ).arg( field.name(), providerKey ) );
1206 if ( !input.isValid() )
1207 return QStringLiteral(
"memory:%1" ).arg(
id.toString() );
1209 if ( input.userType() == qMetaTypeId<QgsProcessingOutputLayerDefinition>() )
1216 else if ( input.userType() == qMetaTypeId<QgsProperty>() )
1223 QString res = input.toString();
1229 else if ( res.startsWith( QLatin1String(
"memory:" ) ) )
1231 return QString( res +
'_' +
id.toString() );
1237 int lastIndex = res.lastIndexOf(
'.' );
1238 return lastIndex >= 0 ? QString( res.left( lastIndex ) +
'_' +
id.toString() + res.mid( lastIndex ) ) : QString( res +
'_' +
id.toString() );
1249 static std::vector< std::unique_ptr< QTemporaryDir > > sTempFolders;
1250 static QString sFolder;
1251 static QMutex sMutex;
1252 QMutexLocker locker( &sMutex );
1257 if ( basePath.isEmpty() )
1260 if ( basePath.isEmpty() )
1263 if ( sTempFolders.empty() )
1265 const QString templatePath = QStringLiteral(
"%1/processing_XXXXXX" ).arg( QDir::tempPath() );
1266 std::unique_ptr< QTemporaryDir >
tempFolder = std::make_unique< QTemporaryDir >( templatePath );
1268 sTempFolders.emplace_back( std::move(
tempFolder ) );
1271 else if ( sFolder.isEmpty() || !sFolder.startsWith( basePath ) || sTempFolders.empty() )
1273 if ( !QDir().exists( basePath ) )
1274 QDir().mkpath( basePath );
1276 const QString templatePath = QStringLiteral(
"%1/processing_XXXXXX" ).arg( basePath );
1277 std::unique_ptr< QTemporaryDir >
tempFolder = std::make_unique< QTemporaryDir >( templatePath );
1279 sTempFolders.emplace_back( std::move(
tempFolder ) );
1286 QString subPath = QUuid::createUuid().toString().remove(
'-' ).remove(
'{' ).remove(
'}' );
1287 QString path =
tempFolder( context ) +
'/' + subPath;
1288 if ( !QDir( path ).exists() )
1291 tmpDir.mkdir( path );
1298 auto getText = [map](
const QString & key )->QString
1300 if ( map.contains( key ) )
1301 return map.value( key ).toString();
1306 s += QStringLiteral(
"<html><body><p>" ) + getText( QStringLiteral(
"ALG_DESC" ) ) + QStringLiteral(
"</p>\n" );
1315 if ( !getText( def->name() ).isEmpty() )
1317 inputs += QStringLiteral(
"<h3>" ) + def->description() + QStringLiteral(
"</h3>\n" );
1318 inputs += QStringLiteral(
"<p>" ) + getText( def->name() ) + QStringLiteral(
"</p>\n" );
1321 if ( !inputs.isEmpty() )
1322 s += QStringLiteral(
"<h2>" ) + QObject::tr(
"Input parameters" ) + QStringLiteral(
"</h2>\n" ) + inputs;
1328 if ( !getText( def->name() ).isEmpty() )
1330 outputs += QStringLiteral(
"<h3>" ) + def->description() + QStringLiteral(
"</h3>\n" );
1331 outputs += QStringLiteral(
"<p>" ) + getText( def->name() ) + QStringLiteral(
"</p>\n" );
1334 if ( !outputs.isEmpty() )
1335 s += QStringLiteral(
"<h2>" ) + QObject::tr(
"Outputs" ) + QStringLiteral(
"</h2>\n" ) + outputs;
1337 if ( !map.value( QStringLiteral(
"EXAMPLES" ) ).toString().isEmpty() )
1338 s += QStringLiteral(
"<h2>%1</h2>\n<p>%2</p>" ).arg( QObject::tr(
"Examples" ), getText( QStringLiteral(
"EXAMPLES" ) ) );
1340 s += QLatin1String(
"<br>" );
1341 if ( !map.value( QStringLiteral(
"ALG_CREATOR" ) ).toString().isEmpty() )
1342 s += QStringLiteral(
"<p align=\"right\">" ) + QObject::tr(
"Algorithm author:" ) + QStringLiteral(
" " ) + getText( QStringLiteral(
"ALG_CREATOR" ) ) + QStringLiteral(
"</p>" );
1343 if ( !map.value( QStringLiteral(
"ALG_HELP_CREATOR" ) ).toString().isEmpty() )
1344 s += QStringLiteral(
"<p align=\"right\">" ) + QObject::tr(
"Help author:" ) + QStringLiteral(
" " ) + getText( QStringLiteral(
"ALG_HELP_CREATOR" ) ) + QStringLiteral(
"</p>" );
1345 if ( !map.value( QStringLiteral(
"ALG_VERSION" ) ).toString().isEmpty() )
1346 s += QStringLiteral(
"<p align=\"right\">" ) + QObject::tr(
"Algorithm version:" ) + QStringLiteral(
" " ) + getText( QStringLiteral(
"ALG_VERSION" ) ) + QStringLiteral(
"</p>" );
1348 s += QLatin1String(
"</body></html>" );
1353 long long featureLimit,
const QString &filterExpression,
bool renameFid )
1355 bool requiresTranslation =
false;
1359 requiresTranslation = requiresTranslation || selectedFeaturesOnly;
1362 requiresTranslation = requiresTranslation || featureLimit != -1 || !filterExpression.isEmpty();
1367 requiresTranslation = requiresTranslation || vl->
providerType() != QLatin1String(
"ogr" );
1371 requiresTranslation = requiresTranslation || !vl->
subsetString().isEmpty();
1375 requiresTranslation = requiresTranslation || vl->
source().startsWith( QLatin1String(
"/vsi" ) );
1379 if ( !requiresTranslation )
1382 if ( parts.contains( QStringLiteral(
"path" ) ) )
1384 diskPath = parts.value( QStringLiteral(
"path" ) ).toString();
1385 QFileInfo fi( diskPath );
1386 requiresTranslation = !compatibleFormats.contains( fi.suffix(), Qt::CaseInsensitive );
1390 const QString srcLayerName = parts.value( QStringLiteral(
"layerName" ) ).toString();
1394 *layerName = srcLayerName;
1399 requiresTranslation = requiresTranslation || ( !srcLayerName.isEmpty() && srcLayerName != fi.baseName() );
1404 requiresTranslation =
true;
1408 if ( requiresTranslation )
1418 const int fidIndex = fields.
lookupField( QStringLiteral(
"fid" ) );
1419 if ( fidIndex >= 0 )
1420 fields.
rename( fidIndex, QStringLiteral(
"OLD_FID" ) );
1426 if ( featureLimit != -1 )
1430 if ( !filterExpression.isEmpty() )
1435 if ( selectedFeaturesOnly )
1440 constexpr int maxErrors { 10 };
1441 unsigned long errorCounter { 0 };
1449 const QString errorMessage = writer->errorMessage();
1450 if ( !renameFid && saveOptions.
driverName == QLatin1String(
"GPKG" ) && errorMessage.contains(
"fid", Qt::CaseInsensitive ) )
1453 feedback->
reportError( QObject::tr(
"Cannot store existing FID values in temporary GeoPackage layer, these will be moved to \"OLD_FID\" instead." ),
false );
1455 featureLimit, filterExpression,
true );
1459 if ( errorCounter++ < maxErrors )
1461 errorText = QObject::tr(
"Error writing feature # %1 to output layer: %2" ).arg( QString::number( f.
id() ), errorMessage );
1467 if ( errorCounter >= maxErrors )
1469 feedback->
reportError( QObject::tr(
"There were %1 errors writing features, only the first %2 have been reported." ).arg( QString::number( errorCounter ), QString::number( maxErrors ) ) );
1481 return convertToCompatibleFormatInternal( vl, selectedFeaturesOnly, baseName, compatibleFormats, preferredFormat, context, feedback,
nullptr, featureLimit, filterExpression,
false );
1487 return convertToCompatibleFormatInternal( layer, selectedFeaturesOnly, baseName, compatibleFormats, preferredFormat, context, feedback, &layerName, featureLimit, filterExpression,
false );
1493 QSet< QString > usedNames;
1494 for (
const QgsField &f : fieldsA )
1496 usedNames.insert( f.name().toLower() );
1499 for (
const QgsField &f : fieldsB )
1502 newField.
setName( fieldsBPrefix + f.name() );
1503 if ( usedNames.contains( newField.
name().toLower() ) )
1506 QString newName = newField.
name() +
'_' + QString::number( idx );
1507 while ( usedNames.contains( newName.toLower() ) || fieldsB.
indexOf( newName ) != -1 )
1510 newName = newField.
name() +
'_' + QString::number( idx );
1513 outFields.
append( newField );
1517 outFields.
append( newField );
1519 usedNames.insert( newField.
name() );
1529 if ( !fieldNames.isEmpty() )
1531 indices.reserve( fieldNames.count() );
1532 for (
const QString &f : fieldNames )
1536 indices.append( idx );
1541 indices.reserve( fields.
count() );
1542 for (
int i = 0; i < fields.
count(); ++i )
1543 indices.append( i );
1552 for (
int i : indices )
1553 fieldsSubset.
append( fields.
at( i ) );
1554 return fieldsSubset;
1560 if ( setting.isEmpty() )
1561 return QStringLiteral(
"gpkg" );
1563 if ( setting.startsWith(
'.' ) )
1564 setting = setting.mid( 1 );
1567 if ( !supportedFormats.contains( setting, Qt::CaseInsensitive ) )
1568 return QStringLiteral(
"gpkg" );
1576 if ( setting.isEmpty() )
1577 return QStringLiteral(
"tif" );
1579 if ( setting.startsWith(
'.' ) )
1580 setting = setting.mid( 1 );
1583 if ( !supportedFormats.contains( setting, Qt::CaseInsensitive ) )
1584 return QStringLiteral(
"tif" );
1591 return QStringLiteral(
"las" );
1596 return QStringLiteral(
"mbtiles" );
1601 auto layerPointerToString = [](
QgsMapLayer * layer ) -> QString
1603 if ( layer && layer->
providerType() == QLatin1String(
"memory" ) )
1611 auto cleanPointerValues = [&layerPointerToString](
const QVariant & value ) -> QVariant
1613 if (
QgsMapLayer *layer = qobject_cast< QgsMapLayer * >( value.value< QObject * >() ) )
1616 return layerPointerToString( layer );
1618 else if ( value.userType() == QMetaType::type(
"QPointer< QgsMapLayer >" ) )
1621 return layerPointerToString( value.value< QPointer< QgsMapLayer > >().data() );
1630 for (
auto it = map.constBegin(); it != map.constEnd(); ++it )
1632 if ( it->userType() == QMetaType::Type::QVariantMap )
1636 else if ( it->userType() == QMetaType::Type::QVariantList )
1639 const QVariantList source = it.value().toList();
1640 dest.reserve( source.size() );
1641 for (
const QVariant &v : source )
1643 dest.append( cleanPointerValues( v ) );
1645 res.insert( it.key(), dest );
1649 res.insert( it.key(), cleanPointerValues( it.value() ) );
1659 for (
auto it = parameters.constBegin(); it != parameters.constEnd(); ++it )
1661 if ( it.value().userType() == QMetaType::Type::QVariantMap )
1663 const QVariantMap value = it.value().toMap();
1664 if ( value.value( QStringLiteral(
"type" ) ).toString() == QLatin1String(
"data_defined" ) )
1666 const QString expression = value.value( QStringLiteral(
"expression" ) ).toString();
1667 const QString field = value.value( QStringLiteral(
"field" ) ).toString();
1668 if ( !expression.isEmpty() )
1672 else if ( !field.isEmpty() )
1679 error = QObject::tr(
"Invalid data defined parameter for %1, requires 'expression' or 'field' values." ).arg( it.key() );
1684 output.insert( it.key(), it.value() );
1687 else if ( it.value().userType() == QMetaType::Type::QString )
1689 const QString stringValue = it.value().toString();
1691 if ( stringValue.startsWith( QLatin1String(
"field:" ) ) )
1695 else if ( stringValue.startsWith( QLatin1String(
"expression:" ) ) )
1701 output.insert( it.key(), it.value() );
1706 output.insert( it.key(), it.value() );
1714 if ( ! QTextCodec::availableCodecs().contains( defaultEncoding.toLatin1() ) )
1716 const QString systemCodec = QTextCodec::codecForLocale()->name();
1717 if ( ! systemCodec.isEmpty() )
1721 return QString(
"UTF-8" );
1724 return defaultEncoding;
1732 : mSource( originalSource )
1733 , mOwnsSource( ownsOriginalSource )
1734 , mSourceCrs( mSource->sourceCrs() )
1735 , mSourceFields( mSource->fields() )
1736 , mSourceWkbType( mSource->wkbType() )
1737 , mSourceName( mSource->sourceName() )
1738 , mSourceExtent( mSource->sourceExtent() )
1739 , mSourceSpatialIndexPresence( mSource->hasSpatialIndex() )
1740 , mInvalidGeometryCheck(
QgsWkbTypes::geometryType( mSource->wkbType() ) ==
Qgis::GeometryType::Point
1741 ?
Qgis::InvalidGeometryCheck::NoCheck
1742 : context.invalidGeometryCheck() )
1743 , mInvalidGeometryCallback( context.invalidGeometryCallback( originalSource ) )
1744 , mTransformErrorCallback( context.transformErrorCallback() )
1745 , mInvalidGeometryCallbackSkip( context.defaultInvalidGeometryCallbackForCheck(
Qgis::InvalidGeometryCheck::SkipInvalid, originalSource ) )
1746 , mInvalidGeometryCallbackAbort( context.defaultInvalidGeometryCallbackForCheck(
Qgis::InvalidGeometryCheck::AbortOnInvalid, originalSource ) )
1747 , mFeatureLimit( featureLimit )
1748 , mFilterExpression( filterExpression )
1770 if ( mFeatureLimit != -1 && req.
limit() != -1 )
1771 req.
setLimit( std::min(
static_cast< long long >( req.
limit() ), mFeatureLimit ) );
1772 else if ( mFeatureLimit != -1 )
1775 if ( !mFilterExpression.isEmpty() )
1787 return sourceAvailability;
1800 if ( mFeatureLimit != -1 && req.
limit() != -1 )
1801 req.
setLimit( std::min(
static_cast< long long >( req.
limit() ), mFeatureLimit ) );
1802 else if ( mFeatureLimit != -1 )
1805 if ( !mFilterExpression.isEmpty() )
1818 return mSourceFields;
1823 return mSourceWkbType;
1828 if ( !mFilterExpression.isEmpty() )
1831 if ( mFeatureLimit == -1 )
1834 return std::min( mFeatureLimit, mSource->
featureCount() );
1844 if ( mFilterExpression.isEmpty() )
1849 if ( fieldIndex < 0 || fieldIndex >=
fields().count() )
1850 return QSet<QVariant>();
1857 QSet<QVariant> values;
1862 values.insert( f.
attribute( fieldIndex ) );
1863 if ( limit > 0 && values.size() >= limit )
1871 if ( mFilterExpression.isEmpty() )
1876 if ( fieldIndex < 0 || fieldIndex >=
fields().count() )
1888 const QVariant v = f.
attribute( fieldIndex );
1899 if ( mFilterExpression.isEmpty() )
1904 if ( fieldIndex < 0 || fieldIndex >=
fields().count() )
1916 const QVariant v = f.
attribute( fieldIndex );
1927 return mSourceExtent;
1932 if ( mFilterExpression.isEmpty() )
1938 .setFilterExpression( mFilterExpression ) );
1953 return mSourceSpatialIndexPresence;
1964 return expressionContextScope;
1969 mInvalidGeometryCheck = method;
1970 switch ( mInvalidGeometryCheck )
1973 mInvalidGeometryCallback =
nullptr;
1977 mInvalidGeometryCallback = mInvalidGeometryCallbackSkip;
1981 mInvalidGeometryCallback = mInvalidGeometryCallbackAbort;
1989 return mInvalidGeometryCheck;
1998 , mContext( context )
1999 , mSinkName( sinkName )
2000 , mOwnsSink( ownsOriginalSink )
2012 if ( !result && mContext.
feedback() )
2015 if ( !error.isEmpty() )
2016 mContext.
feedback()->
reportError( QObject::tr(
"Feature could not be written to %1: %2" ).arg( mSinkName, error ) );
2018 mContext.
feedback()->
reportError( QObject::tr(
"Feature could not be written to %1" ).arg( mSinkName ) );
2026 if ( !result && mContext.
feedback() )
2029 if ( !error.isEmpty() )
2030 mContext.
feedback()->
reportError( QObject::tr(
"%n feature(s) could not be written to %1: %2",
nullptr, features.count() ).arg( mSinkName, error ) );
2032 mContext.
feedback()->
reportError( QObject::tr(
"%n feature(s) could not be written to %1",
nullptr, features.count() ).arg( mSinkName ) );
2040 if ( !result && mContext.
feedback() )
2043 if ( !error.isEmpty() )
2044 mContext.
feedback()->
reportError( QObject::tr(
"Features could not be written to %1: %2" ).arg( mSinkName, error ) );
2046 mContext.
feedback()->
reportError( QObject::tr(
"Features could not be written to %1" ).arg( mSinkName ) );
The Qgis class provides global constants 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.
This class 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.
Class for storing the component parts of a RDBMS 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.
This class 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.
A class to represent a 2D point.
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.
~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 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 QString layerToStringIdentifier(const QgsMapLayer *layer)
Returns a string representation of the source for a layer.
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 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 on to another feature sink.
bool addFeature(QgsFeature &feature, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags()) override
Adds a single feature to the sink.
QString lastError() const override
Returns the most recent error encountered by the sink, e.g.
QgsFeatureSink * destinationSink()
Returns the destination QgsFeatureSink which the proxy will forward features to.
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.
double xMinimum() const
Returns the x minimum value (left side of rectangle).
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
double xMaximum() const
Returns the x maximum value (right side of rectangle).
double yMaximum() const
Returns the y maximum value (top side of rectangle).
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.
Options to pass to 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 data sets.
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.
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.