QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgsalgorithmintersection.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsalgorithmintersection.cpp
3 ---------------------
4 Date : April 2018
5 Copyright : (C) 2018 by Martin Dobias
6 Email : wonder dot sk at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
17
19#include "qgsgeometryengine.h"
20#include "qgsoverlayutils.h"
21
23
24
25QString QgsIntersectionAlgorithm::name() const
26{
27 return QStringLiteral( "intersection" );
28}
29
30QString QgsIntersectionAlgorithm::displayName() const
31{
32 return QObject::tr( "Intersection" );
33}
34
35QString QgsIntersectionAlgorithm::group() const
36{
37 return QObject::tr( "Vector overlay" );
38}
39
40QString QgsIntersectionAlgorithm::groupId() const
41{
42 return QStringLiteral( "vectoroverlay" );
43}
44
45QString QgsIntersectionAlgorithm::shortHelpString() const
46{
47 return QObject::tr( "This algorithm extracts the overlapping portions of features in the Input and Overlay layers. "
48 "Features in the output Intersection layer are assigned the attributes of the overlapping features "
49 "from both the Input and Overlay layers." );
50}
51
52Qgis::ProcessingAlgorithmDocumentationFlags QgsIntersectionAlgorithm::documentationFlags() const
53{
55}
56
57QgsProcessingAlgorithm *QgsIntersectionAlgorithm::createInstance() const
58{
59 return new QgsIntersectionAlgorithm();
60}
61
62void QgsIntersectionAlgorithm::initAlgorithm( const QVariantMap & )
63{
64 addParameter( new QgsProcessingParameterFeatureSource( QStringLiteral( "INPUT" ), QObject::tr( "Input layer" ) ) );
65 addParameter( new QgsProcessingParameterFeatureSource( QStringLiteral( "OVERLAY" ), QObject::tr( "Overlay layer" ) ) );
66
67 addParameter( new QgsProcessingParameterField(
68 QStringLiteral( "INPUT_FIELDS" ),
69 QObject::tr( "Input fields to keep (leave empty to keep all fields)" ), QVariant(),
70 QStringLiteral( "INPUT" ), Qgis::ProcessingFieldParameterDataType::Any, true, true ) );
71 addParameter( new QgsProcessingParameterField(
72 QStringLiteral( "OVERLAY_FIELDS" ),
73 QObject::tr( "Overlay fields to keep (leave empty to keep all fields)" ), QVariant(),
74 QStringLiteral( "OVERLAY" ), Qgis::ProcessingFieldParameterDataType::Any, true, true ) );
75
76 std::unique_ptr< QgsProcessingParameterString > prefix = std::make_unique< QgsProcessingParameterString >( QStringLiteral( "OVERLAY_FIELDS_PREFIX" ), QObject::tr( "Overlay fields prefix" ), QString(), false, true );
77 prefix->setFlags( prefix->flags() | Qgis::ProcessingParameterFlag::Advanced );
78 addParameter( prefix.release() );
79
80 addParameter( new QgsProcessingParameterFeatureSink( QStringLiteral( "OUTPUT" ), QObject::tr( "Intersection" ) ) );
81
82 std::unique_ptr< QgsProcessingParameterNumber > gridSize = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "GRID_SIZE" ),
83 QObject::tr( "Grid size" ), Qgis::ProcessingNumberParameterType::Double, QVariant(), true, 0 );
84 gridSize->setFlags( gridSize->flags() | Qgis::ProcessingParameterFlag::Advanced );
85 addParameter( gridSize.release() );
86}
87
88
89QVariantMap QgsIntersectionAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
90{
91 std::unique_ptr< QgsFeatureSource > sourceA( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
92 if ( !sourceA )
93 throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
94
95 std::unique_ptr< QgsFeatureSource > sourceB( parameterAsSource( parameters, QStringLiteral( "OVERLAY" ), context ) );
96 if ( !sourceB )
97 throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "OVERLAY" ) ) );
98
99 const Qgis::WkbType geomType = QgsWkbTypes::multiType( sourceA->wkbType() );
100
101 const QStringList fieldsA = parameterAsStrings( parameters, QStringLiteral( "INPUT_FIELDS" ), context );
102 const QStringList fieldsB = parameterAsStrings( parameters, QStringLiteral( "OVERLAY_FIELDS" ), context );
103
104 const QList<int> fieldIndicesA = QgsProcessingUtils::fieldNamesToIndices( fieldsA, sourceA->fields() );
105 const QList<int> fieldIndicesB = QgsProcessingUtils::fieldNamesToIndices( fieldsB, sourceB->fields() );
106
107 const QString overlayFieldsPrefix = parameterAsString( parameters, QStringLiteral( "OVERLAY_FIELDS_PREFIX" ), context );
108 const QgsFields outputFields = QgsProcessingUtils::combineFields(
109 QgsProcessingUtils::indicesToFields( fieldIndicesA, sourceA->fields() ),
110 QgsProcessingUtils::indicesToFields( fieldIndicesB, sourceB->fields() ),
111 overlayFieldsPrefix );
112
113 QString dest;
114 std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, outputFields, geomType, sourceA->sourceCrs(), QgsFeatureSink::RegeneratePrimaryKey ) );
115 if ( !sink )
116 throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
117
118 QVariantMap outputs;
119 outputs.insert( QStringLiteral( "OUTPUT" ), dest );
120
121 long count = 0;
122 const long total = sourceA->featureCount();
123
124 QgsGeometryParameters geometryParameters;
125 if ( parameters.value( QStringLiteral( "GRID_SIZE" ) ).isValid() )
126 {
127 geometryParameters.setGridSize( parameterAsDouble( parameters, QStringLiteral( "GRID_SIZE" ), context ) );
128 }
129
130 QgsOverlayUtils::intersection( *sourceA, *sourceB, *sink, context, feedback, count, total, fieldIndicesA, fieldIndicesB, geometryParameters );
131
132 return outputs;
133}
134
@ RegeneratesPrimaryKey
Algorithm always drops any existing primary keys or FID values and regenerates them in outputs.
QFlags< ProcessingAlgorithmDocumentationFlag > ProcessingAlgorithmDocumentationFlags
Flags describing algorithm behavior for documentation purposes.
Definition qgis.h:3359
WkbType
The WKB type describes the number of dimensions a geometry has.
Definition qgis.h:256
@ Advanced
Parameter is an advanced parameter which should be hidden from users by default.
@ RegeneratePrimaryKey
This flag indicates, that a primary key field cannot be guaranteed to be unique and the sink should i...
Container of fields for a vector layer.
Definition qgsfields.h:46
Encapsulates parameters under which a geometry operation is performed.
void setGridSize(double size)
Sets the grid size which will be used to snap vertices of a geometry.
Abstract base class for processing algorithms.
Contains information about the context in which a processing algorithm is executed.
Custom exception class for processing related exceptions.
Base class for providing feedback from a processing algorithm.
A feature sink output for processing algorithms.
An input feature source (such as vector layers) parameter for processing algorithms.
A vector layer or feature source field parameter for processing algorithms.
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 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 Qgis::WkbType multiType(Qgis::WkbType type)
Returns the multi type for a WKB type.