QGIS API Documentation 3.27.0-Master (9c08adf5ef)
qgsgeometryoverlapcheck.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsgeometryoverlapcheck.cpp
3 ---------------------
4 begin : September 2015
5 copyright : (C) 2014 by Sandro Mani / Sourcepole AG
6 email : smani at sourcepole dot ch
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#include "qgsgeometryengine.h"
19#include "qgsfeaturepool.h"
20#include "qgsvectorlayer.h"
21#include "qgsfeedback.h"
22#include "qgsapplication.h"
23
24QgsGeometryOverlapCheck::QgsGeometryOverlapCheck( const QgsGeometryCheckContext *context, const QVariantMap &configuration )
25 : QgsGeometryCheck( context, configuration )
26 , mOverlapThresholdMapUnits( configurationValue<double>( QStringLiteral( "maxOverlapArea" ) ) )
27
28{
29
30}
31
32void QgsGeometryOverlapCheck::collectErrors( const QMap<QString, QgsFeaturePool *> &featurePools, QList<QgsGeometryCheckError *> &errors, QStringList &messages, QgsFeedback *feedback, const LayerFeatureIds &ids ) const
33{
34 const QMap<QString, QgsFeatureIds> featureIds = ids.isEmpty() ? allLayerFeatureIds( featurePools ) : ids.toMap();
35 const QgsGeometryCheckerUtils::LayerFeatures layerFeaturesA( featurePools, featureIds, compatibleGeometryTypes(), feedback, mContext, true );
36 QList<QString> layerIds = featureIds.keys();
37 for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeatureA : layerFeaturesA )
38 {
39 if ( feedback && feedback->isCanceled() )
40 break;
41
42 // Ensure each pair of layers only gets compared once: remove the current layer from the layerIds, but add it to the layerList for layerFeaturesB
43 layerIds.removeOne( layerFeatureA.layer()->id() );
44
45 const QgsGeometry geomA = layerFeatureA.geometry();
46 const QgsRectangle bboxA = geomA.boundingBox();
47 std::unique_ptr< QgsGeometryEngine > geomEngineA = QgsGeometryCheckerUtils::createGeomEngine( geomA.constGet(), mContext->tolerance );
48 geomEngineA->prepareGeometry();
49 if ( !geomEngineA->isValid() )
50 {
51 messages.append( tr( "Overlap check failed for (%1): the geometry is invalid" ).arg( layerFeatureA.id() ) );
52 continue;
53 }
54
55 const QgsGeometryCheckerUtils::LayerFeatures layerFeaturesB( featurePools, QList<QString>() << layerFeatureA.layer()->id() << layerIds, bboxA, compatibleGeometryTypes(), mContext );
56 for ( const QgsGeometryCheckerUtils::LayerFeature &layerFeatureB : layerFeaturesB )
57 {
58 if ( feedback && feedback->isCanceled() )
59 break;
60
61 // > : only report overlaps within same layer once
62 if ( layerFeatureA.layerId() == layerFeatureB.layerId() && layerFeatureB.feature().id() >= layerFeatureA.feature().id() )
63 {
64 continue;
65 }
66
67 QString errMsg;
68 const QgsGeometry geometryB = layerFeatureB.geometry();
69 const QgsAbstractGeometry *geomB = geometryB.constGet();
70 if ( geomEngineA->overlaps( geomB, &errMsg ) )
71 {
72 std::unique_ptr<QgsAbstractGeometry> interGeom( geomEngineA->intersection( geomB ) );
73 if ( interGeom && !interGeom->isEmpty() )
74 {
76 for ( int iPart = 0, nParts = interGeom->partCount(); iPart < nParts; ++iPart )
77 {
78 QgsAbstractGeometry *interPart = QgsGeometryCheckerUtils::getGeomPart( interGeom.get(), iPart );
79 const double area = interPart->area();
80 if ( area > mContext->reducedTolerance && ( area < mOverlapThresholdMapUnits || mOverlapThresholdMapUnits == 0.0 ) )
81 {
82 errors.append( new QgsGeometryOverlapCheckError( this, layerFeatureA, QgsGeometry( interPart->clone() ), interPart->centroid(), area, layerFeatureB ) );
83 }
84 }
85 }
86 else if ( !errMsg.isEmpty() )
87 {
88 messages.append( tr( "Overlap check between features %1 and %2 %3" ).arg( layerFeatureA.id(), layerFeatureB.id(), errMsg ) );
89 }
90 }
91 }
92 }
93}
94
95void QgsGeometryOverlapCheck::fixError( const QMap<QString, QgsFeaturePool *> &featurePools, QgsGeometryCheckError *error, int method, const QMap<QString, int> & /*mergeAttributeIndices*/, Changes &changes ) const
96{
97 QString errMsg;
98 QgsGeometryOverlapCheckError *overlapError = static_cast<QgsGeometryOverlapCheckError *>( error );
99
100 QgsFeaturePool *featurePoolA = featurePools[ overlapError->layerId() ];
101 QgsFeaturePool *featurePoolB = featurePools[ overlapError->overlappedFeature().layerId() ];
102 QgsFeature featureA;
103 QgsFeature featureB;
104 if ( !featurePoolA->getFeature( overlapError->featureId(), featureA ) ||
105 !featurePoolB->getFeature( overlapError->overlappedFeature().featureId(), featureB ) )
106 {
107 error->setObsolete();
108 return;
109 }
110
111 // Check if error still applies
112 const QgsGeometryCheckerUtils::LayerFeature layerFeatureA( featurePoolA, featureA, mContext, true );
113 const QgsGeometryCheckerUtils::LayerFeature layerFeatureB( featurePoolB, featureB, mContext, true );
114 const QgsGeometry geometryA = layerFeatureA.geometry();
115 std::unique_ptr< QgsGeometryEngine > geomEngineA = QgsGeometryCheckerUtils::createGeomEngine( geometryA.constGet(), mContext->tolerance );
116 geomEngineA->prepareGeometry();
117
118 const QgsGeometry geometryB = layerFeatureB.geometry();
119 if ( !geomEngineA->overlaps( geometryB.constGet() ) )
120 {
121 error->setObsolete();
122 return;
123 }
124 std::unique_ptr< QgsAbstractGeometry > interGeom( geomEngineA->intersection( geometryB.constGet(), &errMsg ) );
125 if ( !interGeom )
126 {
127 error->setFixFailed( tr( "Failed to compute intersection between overlapping features: %1" ).arg( errMsg ) );
128 return;
129 }
130
131 // Search which overlap part this error parametrizes (using fuzzy-matching of the area and centroid...)
132 QgsAbstractGeometry *interPart = nullptr;
133 for ( int iPart = 0, nParts = interGeom->partCount(); iPart < nParts; ++iPart )
134 {
135 QgsAbstractGeometry *part = QgsGeometryCheckerUtils::getGeomPart( interGeom.get(), iPart );
136 if ( std::fabs( part->area() - overlapError->value().toDouble() ) < mContext->reducedTolerance &&
138 {
139 interPart = part;
140 break;
141 }
142 }
143 if ( !interPart || interPart->isEmpty() )
144 {
145 error->setObsolete();
146 return;
147 }
148
149 // Fix error
150 if ( method == NoChange )
151 {
152 error->setFixed( method );
153 }
154 else if ( method == Subtract )
155 {
156 std::unique_ptr< QgsGeometryEngine > geomEngineDiffA = QgsGeometryCheckerUtils::createGeomEngine( geometryA.constGet(), 0 );
157 std::unique_ptr< QgsAbstractGeometry > diff1( geomEngineDiffA->difference( interPart, &errMsg ) );
158 if ( !diff1 || diff1->isEmpty() )
159 {
160 diff1.reset();
161 }
162 else
163 {
165 }
166 std::unique_ptr< QgsGeometryEngine > geomEngineDiffB = QgsGeometryCheckerUtils::createGeomEngine( geometryB.constGet(), 0 );
167 std::unique_ptr< QgsAbstractGeometry > diff2( geomEngineDiffB->difference( interPart, &errMsg ) );
168 if ( !diff2 || diff2->isEmpty() )
169 {
170 diff2.reset();
171 }
172 else
173 {
175 }
176 const double shared1 = diff1 ? QgsGeometryCheckerUtils::sharedEdgeLength( diff1.get(), interPart, mContext->reducedTolerance ) : 0;
177 const double shared2 = diff2 ? QgsGeometryCheckerUtils::sharedEdgeLength( diff2.get(), interPart, mContext->reducedTolerance ) : 0;
178 if ( !diff1 || !diff2 || shared1 == 0. || shared2 == 0. )
179 {
180 error->setFixFailed( tr( "Could not find shared edges between intersection and overlapping features" ) );
181 }
182 else
183 {
184 if ( shared1 < shared2 )
185 {
186 const QgsCoordinateTransform ct( featurePoolA->crs(), mContext->mapCrs, mContext->transformContext );
187 diff1->transform( ct, Qgis::TransformDirection::Reverse );
188 featureA.setGeometry( QgsGeometry( std::move( diff1 ) ) );
189
190 changes[error->layerId()][featureA.id()].append( Change( ChangeFeature, ChangeChanged ) );
191 featurePoolA->updateFeature( featureA );
192 }
193 else
194 {
195 const QgsCoordinateTransform ct( featurePoolB->crs(), mContext->mapCrs, mContext->transformContext );
196 diff2->transform( ct, Qgis::TransformDirection::Reverse );
197 featureB.setGeometry( QgsGeometry( std::move( diff2 ) ) );
198
199 changes[overlapError->overlappedFeature().layerId()][featureB.id()].append( Change( ChangeFeature, ChangeChanged ) );
200 featurePoolB->updateFeature( featureB );
201 }
202
203 error->setFixed( method );
204 }
205 }
206 else
207 {
208 error->setFixFailed( tr( "Unknown method" ) );
209 }
210}
211
213{
214 static const QStringList methods = QStringList()
215 << tr( "Remove overlapping area from neighboring polygon with shortest shared edge" )
216 << tr( "No action" );
217 return methods;
218}
219
221{
222 return factoryDescription();
223}
224
226{
227 return factoryId();
228}
229
230QgsGeometryCheck::Flags QgsGeometryOverlapCheck::flags() const
231{
232 return factoryFlags();
233}
234
236QString QgsGeometryOverlapCheck::factoryDescription()
237{
238 return tr( "Overlap" );
239}
240
241QgsGeometryCheck::CheckType QgsGeometryOverlapCheck::factoryCheckType()
242{
244}
245
246QString QgsGeometryOverlapCheck::factoryId()
247{
248 return QStringLiteral( "QgsGeometryOverlapCheck" );
249}
250
251QgsGeometryCheck::Flags QgsGeometryOverlapCheck::factoryFlags()
252{
254}
255
256QList<QgsWkbTypes::GeometryType> QgsGeometryOverlapCheck::factoryCompatibleGeometryTypes()
257{
259}
260
261bool QgsGeometryOverlapCheck::factoryIsCompatible( QgsVectorLayer *layer ) SIP_SKIP
262{
263 return factoryCompatibleGeometryTypes().contains( layer->geometryType() );
264}
265
267QgsGeometryOverlapCheckError::QgsGeometryOverlapCheckError( const QgsGeometryCheck *check, const QgsGeometryCheckerUtils::LayerFeature &layerFeature, const QgsGeometry &geometry, const QgsPointXY &errorLocation, const QVariant &value, const QgsGeometryCheckerUtils::LayerFeature &overlappedFeature )
268 : QgsGeometryCheckError( check, layerFeature.layer()->id(), layerFeature.feature().id(), geometry, errorLocation, QgsVertexId(), value, ValueArea )
269 , mOverlappedFeature( OverlappedFeature( overlappedFeature.layer(), overlappedFeature.feature().id() ) )
270{
271
272}
273
275{
276 QgsGeometryOverlapCheckError *err = dynamic_cast<QgsGeometryOverlapCheckError *>( other );
277 return err &&
278 other->layerId() == layerId() &&
279 other->featureId() == featureId() &&
282 std::fabs( value().toDouble() - other->value().toDouble() ) < mCheck->context()->reducedTolerance;
283}
284
286{
287 QgsGeometryOverlapCheckError *err = dynamic_cast<QgsGeometryOverlapCheckError *>( other );
288 return err && other->layerId() == layerId() && other->featureId() == featureId() && err->overlappedFeature() == overlappedFeature();
289}
290
292{
293 if ( !QgsGeometryCheckError::handleChanges( changes ) )
294 {
295 return false;
296 }
297 if ( changes.value( mOverlappedFeature.layerId() ).contains( mOverlappedFeature.featureId() ) )
298 {
299 return false;
300 }
301 return true;
302}
303
305{
306 return QCoreApplication::translate( "QgsGeometryTypeCheckError", "Overlap with %1 at feature %2" ).arg( mOverlappedFeature.layerName(), QString::number( mOverlappedFeature.featureId() ) );
307}
308
309QMap<QString, QgsFeatureIds> QgsGeometryOverlapCheckError::involvedFeatures() const
310{
311 QMap<QString, QgsFeatureIds> features;
312 features[layerId()].insert( featureId() );
313 features[mOverlappedFeature.layerId()].insert( mOverlappedFeature.featureId() );
314 return features;
315}
316
318{
319
321 return QgsApplication::getThemeIcon( QStringLiteral( "/algorithms/mAlgorithmCheckGeometry.svg" ) );
322 else
323 return QgsApplication::getThemeIcon( QStringLiteral( "/checks/Overlap.svg" ) );
324}
Abstract base class for all geometries.
virtual bool isEmpty() const
Returns true if the geometry is empty.
virtual QgsPoint centroid() const
Returns the centroid of the geometry.
virtual double area() const
Returns the planar, 2-dimensional area of the geometry.
virtual QgsAbstractGeometry * clone() const =0
Clones the geometry by performing a deep copy.
static QIcon getThemeIcon(const QString &name, const QColor &fillColor=QColor(), const QColor &strokeColor=QColor())
Helper to get a theme icon.
Class for doing transforms between two map coordinate systems.
A feature pool is based on a vector layer and caches features.
virtual void updateFeature(QgsFeature &feature)=0
Updates a feature in this pool.
QgsCoordinateReferenceSystem crs() const
The coordinate reference system of this layer.
bool getFeature(QgsFeatureId id, QgsFeature &feature)
Retrieves the feature with the specified id into feature.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition: qgsfeature.h:56
void setGeometry(const QgsGeometry &geometry)
Set the feature's geometry.
Definition: qgsfeature.cpp:170
Q_GADGET QgsFeatureId id
Definition: qgsfeature.h:64
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition: qgsfeedback.h:45
bool isCanceled() const SIP_HOLDGIL
Tells whether the operation has been canceled already.
Definition: qgsfeedback.h:54
Base configuration for geometry checks.
const double reducedTolerance
The tolerance to allow for in geometry checks.
const QgsCoordinateTransformContext transformContext
The coordinate transform context with which transformations will be done.
const QgsCoordinateReferenceSystem mapCrs
The coordinate system in which calculations should be done.
const double tolerance
The tolerance to allow for in geometry checks.
This represents an error reported by a geometry check.
@ StatusFixed
The error is fixed.
Status status() const
The status of the error.
QgsFeatureId featureId() const
The id of the feature on which this error has been detected.
const QgsGeometryCheck * mCheck
void setFixed(int method)
Set the status to fixed and specify the method that has been used to fix the error.
void setFixFailed(const QString &reason)
Set the error status to failed and specify the reason for failure.
QVariant value() const
An additional value for the error.
void setObsolete()
Set the error status to obsolete.
const QString & layerId() const
The id of the layer on which this error has been detected.
virtual bool handleChanges(const QgsGeometryCheck::Changes &changes)
Apply a list of changes.
const QgsPointXY & location() const
The location of the error in map units.
This class implements a geometry check.
QMap< QString, QMap< QgsFeatureId, QList< QgsGeometryCheck::Change > > > Changes
A collection of changes.
const QgsGeometryCheckContext * mContext
@ ChangeFeature
This change happens on feature level.
@ AvailableInValidation
This geometry check should be available in layer validation on the vector layer peroperties.
CheckType
The type of a check.
@ LayerCheck
The check controls a whole layer (topology checks)
QMap< QString, QgsFeatureIds > allLayerFeatureIds(const QMap< QString, QgsFeaturePool * > &featurePools) const
Returns all layers and feature ids.
@ ChangeChanged
Something has been updated.
const QgsGeometryCheckContext * context() const
Returns the context.
A layer feature combination to uniquely identify and access a feature in a set of layers.
QgsGeometry geometry() const
Returns the geometry of this feature.
Contains a set of layers and feature ids in those layers to pass to a geometry check.
static void filter1DTypes(QgsAbstractGeometry *geom)
static std::unique_ptr< QgsGeometryEngine > createGeomEngine(const QgsAbstractGeometry *geometry, double tolerance)
static QgsAbstractGeometry * getGeomPart(QgsAbstractGeometry *geom, int partIdx)
static double sharedEdgeLength(const QgsAbstractGeometry *geom1, const QgsAbstractGeometry *geom2, double tol)
static bool pointsFuzzyEqual(const QgsPointXY &p1, const QgsPointXY &p2, double tol)
Determine whether two points are equal up to the specified tolerance.
An error of a QgsGeometryOverlapCheck.
QMap< QString, QgsFeatureIds > involvedFeatures() const override
Returns a list of involved features.
QString description() const override
The error description.
QgsGeometryOverlapCheckError(const QgsGeometryCheck *check, const QgsGeometryCheckerUtils::LayerFeature &layerFeature, const QgsGeometry &geometry, const QgsPointXY &errorLocation, const QVariant &value, const QgsGeometryCheckerUtils::LayerFeature &overlappedFeature)
Creates a new overlap check error for check and the layerFeature combination.
const OverlappedFeature & overlappedFeature() const
Returns the overlapped feature.
QIcon icon() const override
Returns an icon that should be shown for this kind of error.
bool closeMatch(QgsGeometryCheckError *other) const override
Check if this error is almost equal to other.
bool isEqual(QgsGeometryCheckError *other) const override
Check if this error is equal to other.
bool handleChanges(const QgsGeometryCheck::Changes &changes) override
Apply a list of changes.
void collectErrors(const QMap< QString, QgsFeaturePool * > &featurePools, QList< QgsGeometryCheckError * > &errors, QStringList &messages, QgsFeedback *feedback, const LayerFeatureIds &ids=LayerFeatureIds()) const override
The main worker method.
QList< QgsWkbTypes::GeometryType > compatibleGeometryTypes() const override
A list of geometry types for which this check can be performed.
void fixError(const QMap< QString, QgsFeaturePool * > &featurePools, QgsGeometryCheckError *error, int method, const QMap< QString, int > &mergeAttributeIndices, Changes &changes) const override
Fixes the error error with the specified method.
Q_DECL_DEPRECATED QStringList resolutionMethods() const override
Returns a list of descriptions for available resolutions for errors.
QgsGeometryCheck::Flags flags() const override
Flags for this geometry check.
@ Subtract
Subtract the overlap region from the polygon.
@ NoChange
Do not change anything.
QgsGeometryOverlapCheck(const QgsGeometryCheckContext *context, const QVariantMap &configuration)
Checks for overlapping polygons.
QString id() const override
Returns an id for this check.
QString description() const override
Returns a human readable description for this check.
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:125
const QgsAbstractGeometry * constGet() const SIP_HOLDGIL
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
QgsRectangle boundingBox() const
Returns the bounding box of the geometry.
A class to represent a 2D point.
Definition: qgspointxy.h:59
A rectangle specified with double values.
Definition: qgsrectangle.h:42
Represents a vector layer which manages a vector based data sets.
#define SIP_SKIP
Definition: qgis_sip.h:126
Descripts a change to fix a geometry.
A list of layers and feature ids for each of these layers.
QMap< QString, QgsFeatureIds > toMap() const
Utility class for identifying a unique vertex within a geometry.
Definition: qgsvertexid.h:31