[Geometry checker] Add multi-layer support to gap check

src/plugins/geometry_checker/checks/qgsgeometrygapcheck.cpp

@@ -24,6 +24,8 @@ void QgsGeometryGapCheck::collectErrors( QList<QgsGeometryCheckError *> &errors,
 {
   if ( progressCounter ) progressCounter->fetchAndAddRelaxed( 1 );
 
+  QList<QgsAbstractGeometry *> geomList;
+
   QMap<QString, QgsFeatureIds> featureIds = ids.isEmpty() ? allLayerFeatureIds() : ids;
   // Collect geometries, build spatial index
   for ( const QString &layerId : featureIds.keys() )
@@ -34,15 +36,15 @@ void QgsGeometryGapCheck::collectErrors( QList<QgsGeometryCheckError *> &errors,
     {
       continue;
     }
-    double mapToLayerUnits = featurePool->getMapToLayerUnits();
-    double gapAreaThreshold = mThresholdMapUnits * mapToLayerUnits * mapToLayerUnits;
-    QList<QgsAbstractGeometry *> geomList;
     for ( QgsFeatureId id : featureIds[layerId] )
     {
       QgsFeature feature;
       if ( featurePool->get( id, feature ) )
       {
-        geomList.append( feature.geometry().geometry()->clone() );
+        QgsAbstractGeometry *geometry = feature.geometry().geometry()->clone();
+        geometry->transform( t );
+        geomList.append( geometry );
+      }
     }
   }
 
@@ -97,23 +99,32 @@ void QgsGeometryGapCheck::collectErrors( QList<QgsGeometryCheckError *> &errors,
   // For each gap polygon which does not lie on the boundary, get neighboring polygons and add error
   for ( int iPart = 0, nParts = diffGeom->partCount(); iPart < nParts; ++iPart )
   {
-      QgsAbstractGeometry *geom = QgsGeometryCheckerUtils::getGeomPart( diffGeom, iPart )->clone();
+    QgsAbstractGeometry *gapGeom = QgsGeometryCheckerUtils::getGeomPart( diffGeom, iPart )->clone();
     // Skip the gap between features and boundingbox
-      if ( geom->boundingBox() == envelope->boundingBox() )
+    if ( gapGeom->boundingBox() == envelope->boundingBox() )
     {
       continue;
     }
 
     // Skip gaps above threshold
-      if ( geom->area() > gapAreaThreshold || geom->area() < mContext->reducedTolerance )
+    if ( gapGeom->area() > mThresholdMapUnits || gapGeom->area() < mContext->reducedTolerance )
     {
       continue;
     }
 
+    QgsRectangle gapAreaBBox = gapGeom->boundingBox();
+
     // Get neighboring polygons
-      QgsFeatureIds neighboringIds;
+    QMap<QString, QgsFeatureIds> neighboringIds;
-      QgsRectangle gapAreaBBox = t.transform( geom->boundingBox() );
+    for ( const QString &layerId : featureIds.keys() )
-      QgsFeatureIds intersectIds = featurePool->getIntersects( geom->boundingBox() );
+    {
+      QgsFeaturePool *featurePool = mContext->featurePools[ layerId ];
+      QgsCoordinateTransform t = QgsCoordinateTransformCache::instance()->transform( mContext->mapCrs, featurePool->getLayer()->crs().authid() );
+      QgsRectangle gapAreaLayerBBox = t.transform( gapGeom->boundingBox() ); // Don't use gapAreaBBox since it is updated below
+
+      QgsFeatureIds intersectIds = featurePool->getIntersects( gapAreaLayerBBox );
+      QgsAbstractGeometry *gapLayerGeom = gapGeom->clone();
+      gapLayerGeom->transform( t );
 
       for ( QgsFeatureId id : intersectIds )
       {
@@ -122,23 +133,24 @@ void QgsGeometryGapCheck::collectErrors( QList<QgsGeometryCheckError *> &errors,
         {
           continue;
         }
-        QgsGeometry featureGeom = feature.geometry();
+        QgsAbstractGeometry *featureGeom = feature.geometry().geometry();
-        QgsAbstractGeometry *geom2 = featureGeom.geometry();
+        if ( QgsGeometryCheckerUtils::sharedEdgeLength( gapLayerGeom, featureGeom, mContext->reducedTolerance ) > 0 )
-        if ( QgsGeometryCheckerUtils::sharedEdgeLength( geom, geom2, mContext->reducedTolerance ) > 0 )
         {
-          neighboringIds.insert( feature.id() );
+          neighboringIds[layerId].insert( feature.id() );
-          gapAreaBBox.unionRect( t.transform( geom2->boundingBox() ) );
+          gapAreaLayerBBox.unionRect( featureGeom->boundingBox() );
         }
+        gapAreaBBox.unionRect( t.transform( gapAreaLayerBBox, QgsCoordinateTransform::ReverseTransform ) );
+      }
+      delete gapLayerGeom;
     }
     if ( neighboringIds.isEmpty() )
     {
-        delete geom;
+      delete gapGeom;
       continue;
     }
 
     // Add error
-      errors.append( new QgsGeometryGapCheckError( this, layerId, geom, neighboringIds, geom->area(), gapAreaBBox ) );
+    errors.append( new QgsGeometryGapCheckError( this, "", gapGeom, neighboringIds, gapGeom->area(), gapAreaBBox ) );
-    }
 
     delete unionGeom;
     delete envelope;
@@ -172,15 +184,22 @@ void QgsGeometryGapCheck::fixError( QgsGeometryCheckError *error, int method, co
 
 bool QgsGeometryGapCheck::mergeWithNeighbor( QgsGeometryGapCheckError *err, Changes &changes, QString &errMsg ) const
 {
-  QgsFeaturePool *featurePool = mContext->featurePools[ err->layerId() ];
   double maxVal = 0.;
+  QString mergeLayerId;
   QgsFeature mergeFeature;
   int mergePartIdx = -1;
 
   QgsAbstractGeometry *errGeometry = QgsGeometryCheckerUtils::getGeomPart( err->geometry(), 0 );
 
   // Search for touching neighboring geometries
-  for ( QgsFeatureId testId : err->neighbors() )
+  for ( const QString &layerId : err->neighbors().keys() )
+  {
+    QgsFeaturePool *featurePool = mContext->featurePools[ err->layerId() ];
+    QgsCoordinateTransform t = QgsCoordinateTransformCache::instance()->transform( mContext->mapCrs, featurePool->getLayer()->crs().authid() );
+    QgsAbstractGeometry *errLayerGeom = errGeometry->clone();
+    errLayerGeom->transform( t );
+
+    for ( QgsFeatureId testId : err->neighbors()[layerId] )
     {
       QgsFeature testFeature;
       if ( !featurePool->get( testId, testFeature ) )
@@ -191,15 +210,18 @@ bool QgsGeometryGapCheck::mergeWithNeighbor( QgsGeometryGapCheckError *err, Chan
       QgsAbstractGeometry *testGeom = featureGeom.geometry();
       for ( int iPart = 0, nParts = testGeom->partCount(); iPart < nParts; ++iPart )
       {
-      double len = QgsGeometryCheckerUtils::sharedEdgeLength( errGeometry, QgsGeometryCheckerUtils::getGeomPart( testGeom, iPart ), mContext->reducedTolerance );
+        double len = QgsGeometryCheckerUtils::sharedEdgeLength( errLayerGeom, QgsGeometryCheckerUtils::getGeomPart( testGeom, iPart ), mContext->reducedTolerance );
         if ( len > maxVal )
         {
           maxVal = len;
           mergeFeature = testFeature;
           mergePartIdx = iPart;
+          mergeLayerId = layerId;
         }
       }
     }
+    delete errLayerGeom;
+  }
 
   if ( maxVal == 0. )
   {
@@ -207,11 +229,16 @@ bool QgsGeometryGapCheck::mergeWithNeighbor( QgsGeometryGapCheckError *err, Chan
   }
 
   // Merge geometries
+  QgsFeaturePool *featurePool = mContext->featurePools[ mergeLayerId ];
+  QgsCoordinateTransform t = QgsCoordinateTransformCache::instance()->transform( mContext->mapCrs, featurePool->getLayer()->crs().authid() );
+  QgsAbstractGeometry *errLayerGeom = errGeometry->clone();
+  errLayerGeom->transform( t );
   QgsGeometry mergeFeatureGeom = mergeFeature.geometry();
   QgsAbstractGeometry *mergeGeom = mergeFeatureGeom.geometry();
-  QgsGeometryEngine *geomEngine = QgsGeometryCheckerUtils::createGeomEngine( errGeometry, mContext->tolerance );
+  QgsGeometryEngine *geomEngine = QgsGeometryCheckerUtils::createGeomEngine( errLayerGeom, mContext->tolerance );
   QgsAbstractGeometry *combinedGeom = geomEngine->combine( *QgsGeometryCheckerUtils::getGeomPart( mergeGeom, mergePartIdx ), &errMsg );
   delete geomEngine;
+  delete errLayerGeom;
   if ( !combinedGeom || combinedGeom->isEmpty() )
   {
     delete combinedGeom;

src/plugins/geometry_checker/checks/qgsgeometrygapcheck.h

@@ -25,7 +25,7 @@ class QgsGeometryGapCheckError : public QgsGeometryCheckError
     QgsGeometryGapCheckError( const QgsGeometryCheck *check,
                               const QString &layerId,
                               QgsAbstractGeometry *geometry,
-                              const QgsFeatureIds &neighbors,
+                              const QMap<QString, QgsFeatureIds> &neighbors,
                               double area,
                               const QgsRectangle &gapAreaBBox )
       : QgsGeometryCheckError( check, layerId, FEATUREID_NULL, geometry->centroid(), QgsVertexId(), area, ValueArea )
@@ -40,7 +40,7 @@ class QgsGeometryGapCheckError : public QgsGeometryCheckError
     }
 
     QgsAbstractGeometry *geometry() const override { return mGeometry->clone(); }
-    const QgsFeatureIds &neighbors() const { return mNeighbors; }
+    const QMap<QString, QgsFeatureIds> &neighbors() const { return mNeighbors; }
 
     bool isEqual( QgsGeometryCheckError *other ) const override
     {
@@ -76,7 +76,7 @@ class QgsGeometryGapCheckError : public QgsGeometryCheckError
     }
 
   private:
-    QgsFeatureIds mNeighbors;
+    QMap<QString, QgsFeatureIds> mNeighbors;
     QgsRectangle mGapAreaBBox;
     QgsAbstractGeometry *mGeometry = nullptr;
 };

src/plugins/geometry_checker/ui/qgsgeometrycheckerresulttab.cpp

@@ -324,7 +324,7 @@ void QgsGeometryCheckerResultTab::highlightErrors( bool current )
   for ( QTableWidgetItem *item : items )
   {
     QgsGeometryCheckError *error = ui.tableWidgetErrors->item( item->row(), 0 )->data( Qt::UserRole ).value<QgsGeometryCheckError *>();
-    QgsVectorLayer *layer = mChecker->getContext()->featurePools[error->layerId()]->getLayer();
+    QgsVectorLayer *layer = !error->layerId().isEmpty() ? mChecker->getContext()->featurePools[error->layerId()]->getLayer() : nullptr;
 
     QgsAbstractGeometry *geometry = error->geometry();
     if ( ui.checkBoxHighlight->isChecked() && geometry )