QGIS API Documentation  3.26.3-Buenos Aires (65e4edfdad)
qgsalgorithmclip.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsalgorithmclip.cpp
3  ---------------------
4  begin : April 2017
5  copyright : (C) 2017 by Nyall Dawson
6  email : nyall dot dawson at gmail dot com
7  ***************************************************************************/
8 
9 /***************************************************************************
10  * *
11  * This program is free software; you can redistribute it and/or modify *
12  * it under the terms of the GNU General Public License as published by *
13  * the Free Software Foundation; either version 2 of the License, or *
14  * (at your option) any later version. *
15  * *
16  ***************************************************************************/
17 
18 #include "qgsalgorithmclip.h"
19 #include "qgsgeometryengine.h"
20 #include "qgsoverlayutils.h"
21 #include "qgsvectorlayer.h"
22 
24 
25 QString QgsClipAlgorithm::name() const
26 {
27  return QStringLiteral( "clip" );
28 }
29 
30 QgsProcessingAlgorithm::Flags QgsClipAlgorithm::flags() const
31 {
34  return f;
35 }
36 
37 QString QgsClipAlgorithm::displayName() const
38 {
39  return QObject::tr( "Clip" );
40 }
41 
42 QStringList QgsClipAlgorithm::tags() const
43 {
44  return QObject::tr( "clip,intersect,intersection,mask" ).split( ',' );
45 }
46 
47 QString QgsClipAlgorithm::group() const
48 {
49  return QObject::tr( "Vector overlay" );
50 }
51 
52 QString QgsClipAlgorithm::groupId() const
53 {
54  return QStringLiteral( "vectoroverlay" );
55 }
56 
57 void QgsClipAlgorithm::initAlgorithm( const QVariantMap & )
58 {
59  addParameter( new QgsProcessingParameterFeatureSource( QStringLiteral( "INPUT" ), QObject::tr( "Input layer" ) ) );
60  addParameter( new QgsProcessingParameterFeatureSource( QStringLiteral( "OVERLAY" ), QObject::tr( "Overlay layer" ), QList< int >() << QgsProcessing::TypeVectorPolygon ) );
61 
62  addParameter( new QgsProcessingParameterFeatureSink( QStringLiteral( "OUTPUT" ), QObject::tr( "Clipped" ) ) );
63 }
64 
65 QString QgsClipAlgorithm::shortHelpString() const
66 {
67  return QObject::tr( "This algorithm clips a vector layer using the features of an additional polygon layer. Only the parts of the features "
68  "in the Input layer that fall within the polygons of the Overlay layer will be added to the resulting layer." )
69  + QStringLiteral( "\n\n" )
70  + QObject::tr( "The attributes of the features are not modified, although properties such as area or length of the features will "
71  "be modified by the clipping operation. If such properties are stored as attributes, those attributes will have to "
72  "be manually updated." );
73 }
74 
75 QgsClipAlgorithm *QgsClipAlgorithm::createInstance() const
76 {
77  return new QgsClipAlgorithm();
78 }
79 
80 bool QgsClipAlgorithm::supportInPlaceEdit( const QgsMapLayer *l ) const
81 {
82  const QgsVectorLayer *layer = qobject_cast< const QgsVectorLayer * >( l );
83  if ( !layer )
84  return false;
85 
86  return layer->isSpatial();
87 }
88 
89 QVariantMap QgsClipAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
90 {
91  std::unique_ptr< QgsFeatureSource > featureSource( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
92  if ( !featureSource )
93  throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
94 
95  std::unique_ptr< QgsFeatureSource > maskSource( parameterAsSource( parameters, QStringLiteral( "OVERLAY" ), context ) );
96  if ( !maskSource )
97  throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "OVERLAY" ) ) );
98 
99  if ( featureSource->hasSpatialIndex() == QgsFeatureSource::SpatialIndexNotPresent )
100  feedback->pushWarning( QObject::tr( "No spatial index exists for input layer, performance will be severely degraded" ) );
101 
102  QString dest;
103  const QgsWkbTypes::GeometryType sinkType = QgsWkbTypes::geometryType( featureSource->wkbType() );
104  std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, featureSource->fields(), QgsWkbTypes::promoteNonPointTypesToMulti( featureSource->wkbType() ), featureSource->sourceCrs() ) );
105 
106  if ( !sink )
107  throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
108 
109  // first build up a list of clip geometries
110  QVector< QgsGeometry > clipGeoms;
111  QgsFeatureIterator it = maskSource->getFeatures( QgsFeatureRequest().setSubsetOfAttributes( QList< int >() ).setDestinationCrs( featureSource->sourceCrs(), context.transformContext() ) );
112  QgsFeature f;
113  while ( it.nextFeature( f ) )
114  {
115  if ( f.hasGeometry() )
116  clipGeoms << f.geometry();
117  }
118 
119  QVariantMap outputs;
120  outputs.insert( QStringLiteral( "OUTPUT" ), dest );
121 
122  if ( clipGeoms.isEmpty() )
123  return outputs;
124 
125  // are we clipping against a single feature? if so, we can show finer progress reports
126  bool singleClipFeature = false;
127  QgsGeometry combinedClipGeom;
128  if ( clipGeoms.length() > 1 )
129  {
130  combinedClipGeom = QgsGeometry::unaryUnion( clipGeoms );
131  if ( combinedClipGeom.isEmpty() )
132  {
133  throw QgsProcessingException( QObject::tr( "Could not create the combined clip geometry: %1" ).arg( combinedClipGeom.lastError() ) );
134  }
135  singleClipFeature = false;
136  }
137  else
138  {
139  combinedClipGeom = clipGeoms.at( 0 );
140  singleClipFeature = true;
141  }
142 
143  // use prepared geometries for faster intersection tests
144  std::unique_ptr< QgsGeometryEngine > engine( QgsGeometry::createGeometryEngine( combinedClipGeom.constGet() ) );
145  engine->prepareGeometry();
146 
147  QgsFeatureIds testedFeatureIds;
148 
149  int i = -1;
150  const auto constClipGeoms = clipGeoms;
151  for ( const QgsGeometry &clipGeom : constClipGeoms )
152  {
153  i++;
154  if ( feedback->isCanceled() )
155  {
156  break;
157  }
158  QgsFeatureIterator inputIt = featureSource->getFeatures( QgsFeatureRequest().setFilterRect( clipGeom.boundingBox() ) );
159  QgsFeatureList inputFeatures;
160  QgsFeature f;
161  while ( inputIt.nextFeature( f ) )
162  inputFeatures << f;
163 
164  if ( inputFeatures.isEmpty() )
165  continue;
166 
167  double step = 0;
168  if ( singleClipFeature )
169  step = 100.0 / inputFeatures.length();
170 
171  const int current = 0;
172  const auto constInputFeatures = inputFeatures;
173  for ( const QgsFeature &inputFeature : constInputFeatures )
174  {
175  if ( feedback->isCanceled() )
176  {
177  break;
178  }
179 
180  if ( !inputFeature.hasGeometry() )
181  continue;
182 
183  if ( testedFeatureIds.contains( inputFeature.id() ) )
184  {
185  // don't retest a feature we have already checked
186  continue;
187  }
188  testedFeatureIds.insert( inputFeature.id() );
189 
190  if ( !engine->intersects( inputFeature.geometry().constGet() ) )
191  continue;
192 
193  QgsGeometry newGeometry;
194  if ( !engine->contains( inputFeature.geometry().constGet() ) )
195  {
196  const QgsGeometry currentGeometry = inputFeature.geometry();
197  newGeometry = combinedClipGeom.intersection( currentGeometry );
198  if ( newGeometry.wkbType() == QgsWkbTypes::Unknown || QgsWkbTypes::flatType( newGeometry.wkbType() ) == QgsWkbTypes::GeometryCollection )
199  {
200  const QgsGeometry intCom = inputFeature.geometry().combine( newGeometry );
201  const QgsGeometry intSym = inputFeature.geometry().symDifference( newGeometry );
202  newGeometry = intCom.difference( intSym );
203  }
204  }
205  else
206  {
207  // clip geometry totally contains feature geometry, so no need to perform intersection
208  newGeometry = inputFeature.geometry();
209  }
210 
211  if ( !QgsOverlayUtils::sanitizeIntersectionResult( newGeometry, sinkType ) )
212  continue;
213 
214  QgsFeature outputFeature;
215  outputFeature.setGeometry( newGeometry );
216  outputFeature.setAttributes( inputFeature.attributes() );
217  if ( !sink->addFeature( outputFeature, QgsFeatureSink::FastInsert ) )
218  throw QgsProcessingException( writeFeatureError( sink.get(), parameters, QStringLiteral( "OUTPUT" ) ) );
219 
220 
221  if ( singleClipFeature )
222  feedback->setProgress( current * step );
223  }
224 
225  if ( !singleClipFeature )
226  {
227  // coarse progress report for multiple clip geometries
228  feedback->setProgress( 100.0 * static_cast< double >( i ) / clipGeoms.length() );
229  }
230  }
231 
232  return outputs;
233 }
234 
QgsGeometry::combine
QgsGeometry combine(const QgsGeometry &geometry) const
Returns a geometry representing all the points in this geometry and other (a union geometry operation...
Definition: qgsgeometry.cpp:2638
QgsGeometry::lastError
QString lastError() const SIP_HOLDGIL
Returns an error string referring to the last error encountered either when this geometry was created...
Definition: qgsgeometry.cpp:3308
QgsFeedback::setProgress
void setProgress(double progress)
Sets the current progress for the feedback object.
Definition: qgsfeedback.h:76
QgsProcessingFeedback
Base class for providing feedback from a processing algorithm.
Definition: qgsprocessingfeedback.h:37
QgsWkbTypes::promoteNonPointTypesToMulti
static Type promoteNonPointTypesToMulti(Type type) SIP_HOLDGIL
Promotes a WKB geometry type to its multi-type equivalent, with the exception of point geometry types...
Definition: qgswkbtypes.h:451
qgsalgorithmclip.h
QgsFeatureSource::SpatialIndexNotPresent
@ SpatialIndexNotPresent
No spatial index exists for the source.
Definition: qgsfeaturesource.h:190
QgsWkbTypes::flatType
static Type flatType(Type type) SIP_HOLDGIL
Returns the flat type for a WKB type.
Definition: qgswkbtypes.h:732
QgsProcessing::TypeVectorPolygon
@ TypeVectorPolygon
Vector polygon layers.
Definition: qgsprocessing.h:51
QgsFeature::geometry
QgsGeometry geometry
Definition: qgsfeature.h:71
QgsFeedback::isCanceled
bool isCanceled() const SIP_HOLDGIL
Tells whether the operation has been canceled already.
Definition: qgsfeedback.h:67
QgsVectorLayer::isSpatial
bool isSpatial() const FINAL
Returns true if this is a geometry layer and false in case of NoGeometry (table only) or UnknownGeome...
Definition: qgsvectorlayer.cpp:3733
QgsProcessingParameterFeatureSource
An input feature source (such as vector layers) parameter for processing algorithms.
Definition: qgsprocessingparameters.h:3057
QgsGeometry::intersection
QgsGeometry intersection(const QgsGeometry &geometry) const
Returns a geometry representing the points shared by this geometry and other.
Definition: qgsgeometry.cpp:2616
QgsProcessingParameterFeatureSink
A feature sink output for processing algorithms.
Definition: qgsprocessingparameters.h:3219
QgsFeatureRequest
This class wraps a request for features to a vector layer (or directly its vector data provider).
Definition: qgsfeaturerequest.h:83
qgsgeometryengine.h
QgsWkbTypes::Unknown
@ Unknown
Definition: qgswkbtypes.h:71
QgsFeature::setGeometry
void setGeometry(const QgsGeometry &geometry)
Set the feature's geometry.
Definition: qgsfeature.cpp:170
QgsProcessingContext
Contains information about the context in which a processing algorithm is executed.
Definition: qgsprocessingcontext.h:46
QgsWkbTypes::GeometryCollection
@ GeometryCollection
Definition: qgswkbtypes.h:79
QgsFeatureList
QList< QgsFeature > QgsFeatureList
Definition: qgsfeature.h:882
QgsGeometry::isEmpty
bool isEmpty() const
Returns true if the geometry is empty (eg a linestring with no vertices, or a collection with no geom...
Definition: qgsgeometry.cpp:379
QgsProcessingContext::transformContext
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context.
Definition: qgsprocessingcontext.h:165
QgsGeometry::constGet
const QgsAbstractGeometry * constGet() const SIP_HOLDGIL
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
Definition: qgsgeometry.cpp:136
QgsFeatureIds
QSet< QgsFeatureId > QgsFeatureIds
Definition: qgsfeatureid.h:37
qgsvectorlayer.h
QgsGeometry::createGeometryEngine
static QgsGeometryEngine * createGeometryEngine(const QgsAbstractGeometry *geometry)
Creates and returns a new geometry engine representing the specified geometry.
Definition: qgsgeometry.cpp:3972
QgsWkbTypes::GeometryType
GeometryType
The geometry types are used to group QgsWkbTypes::Type in a coarse way.
Definition: qgswkbtypes.h:140
QgsFeatureIterator::nextFeature
bool nextFeature(QgsFeature &f)
Definition: qgsfeatureiterator.h:399
QgsGeometry
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:124
QgsVectorLayer
Represents a vector layer which manages a vector based data sets.
Definition: qgsvectorlayer.h:391
QgsFeature::hasGeometry
bool hasGeometry() const
Returns true if the feature has an associated geometry.
Definition: qgsfeature.cpp:230
QgsMapLayer
Base class for all map layer types. This is the base class for all map layer types (vector,...
Definition: qgsmaplayer.h:72
QgsWkbTypes::geometryType
static GeometryType geometryType(Type type) SIP_HOLDGIL
Returns the geometry type for a WKB type, e.g., both MultiPolygon and CurvePolygon would have a Polyg...
Definition: qgswkbtypes.h:968
QgsFeature
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition: qgsfeature.h:55
QgsGeometry::symDifference
QgsGeometry symDifference(const QgsGeometry &geometry) const
Returns a geometry representing the points making up this geometry that do not make up other.
Definition: qgsgeometry.cpp:2697
qgsoverlayutils.h
QgsFeature::setAttributes
void setAttributes(const QgsAttributes &attrs)
Sets the feature's attributes.
Definition: qgsfeature.cpp:160
QgsProcessingAlgorithm::flags
virtual Flags flags() const
Returns the flags indicating how and when the algorithm operates and should be exposed to users.
Definition: qgsprocessingalgorithm.cpp:90
QgsFeatureIterator
Wrapper for iterator of features from vector data provider or vector layer.
Definition: qgsfeatureiterator.h:289
QgsProcessingException
Custom exception class for processing related exceptions.
Definition: qgsexception.h:82
QgsGeometry::difference
QgsGeometry difference(const QgsGeometry &geometry) const
Returns a geometry representing the points making up this geometry that do not make up other.
Definition: qgsgeometry.cpp:2677
QgsGeometry::wkbType
QgsWkbTypes::Type wkbType() const SIP_HOLDGIL
Returns type of the geometry as a WKB type (point / linestring / polygon etc.)
Definition: qgsgeometry.cpp:357
QgsProcessingAlgorithm::FlagSupportsInPlaceEdits
@ FlagSupportsInPlaceEdits
Algorithm supports in-place editing.
Definition: qgsprocessingalgorithm.h:78
QgsProcessingFeedback::pushWarning
virtual void pushWarning(const QString &warning)
Pushes a warning informational message from the algorithm.
Definition: qgsprocessingfeedback.cpp:68
QgsGeometry::unaryUnion
static QgsGeometry unaryUnion(const QVector< QgsGeometry > &geometries)
Compute the unary union on a list of geometries.
Definition: qgsgeometry.cpp:3079
QgsFeatureSink::FastInsert
@ FastInsert
Use faster inserts, at the cost of updating the passed features to reflect changes made at the provid...
Definition: qgsfeaturesink.h:70