From eb7482b81562350c36eae77340e4ee5338278c3c Mon Sep 17 00:00:00 2001 From: Jacky Volpes Date: Thu, 25 Jul 2024 16:53:04 +0200 Subject: [PATCH] Processing: Add Fix Geometry algorithm and test: Hole Porting hole fix from geometry checker to processings --- src/analysis/CMakeLists.txt | 1 + .../qgsalgorithmfixgeometryhole.cpp | 256 ++++++++++++++++++ .../processing/qgsalgorithmfixgeometryhole.h | 55 ++++ .../processing/qgsnativealgorithms.cpp | 2 + .../analysis/testqgsprocessingfixgeometry.cpp | 47 ++++ tests/testdata/geometry_fix/remove_hole.gpkg | Bin 0 -> 98304 bytes 6 files changed, 361 insertions(+) create mode 100644 src/analysis/processing/qgsalgorithmfixgeometryhole.cpp create mode 100644 src/analysis/processing/qgsalgorithmfixgeometryhole.h create mode 100644 tests/testdata/geometry_fix/remove_hole.gpkg diff --git a/src/analysis/CMakeLists.txt b/src/analysis/CMakeLists.txt index ea46877cbad..1b96e68884b 100644 --- a/src/analysis/CMakeLists.txt +++ b/src/analysis/CMakeLists.txt @@ -64,6 +64,7 @@ set(QGIS_ANALYSIS_SRCS processing/qgsalgorithmcheckgeometryangle.cpp processing/qgsalgorithmfixgeometryangle.cpp processing/qgsalgorithmcheckgeometryhole.cpp + processing/qgsalgorithmfixgeometryhole.cpp processing/qgsalgorithmcheckgeometryarea.cpp processing/qgsalgorithmfixgeometryarea.cpp processing/qgsalgorithmclip.cpp diff --git a/src/analysis/processing/qgsalgorithmfixgeometryhole.cpp b/src/analysis/processing/qgsalgorithmfixgeometryhole.cpp new file mode 100644 index 00000000000..60cccb93866 --- /dev/null +++ b/src/analysis/processing/qgsalgorithmfixgeometryhole.cpp @@ -0,0 +1,256 @@ +/*************************************************************************** + qgsalgorithmfixgeometryhole.cpp + --------------------- + begin : July 2024 + copyright : (C) 2024 by Jacky Volpes + email : jacky dot volpes at oslandia dot com +***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +#include "qgsalgorithmfixgeometryhole.h" +#include "qgsgeometrycheckerror.h" +#include "qgsgeometrycheckerutils.h" +#include "qgsgeometryholecheck.h" +#include "qgsvectordataproviderfeaturepool.h" +#include "qgsvectorlayer.h" +#include "qgsvectorfilewriter.h" + +///@cond PRIVATE + +auto QgsFixGeometryHoleAlgorithm::name() const -> QString +{ + return QStringLiteral( "fixgeometryhole" ); +} + +auto QgsFixGeometryHoleAlgorithm::displayName() const -> QString +{ + return QObject::tr( "Fix geometry (Hole)" ); +} + +auto QgsFixGeometryHoleAlgorithm::tags() const -> QStringList +{ + return QObject::tr( "delete,fix,hole" ).split( ',' ); +} + +auto QgsFixGeometryHoleAlgorithm::group() const -> QString +{ + return QObject::tr( "Fix geometry" ); +} + +auto QgsFixGeometryHoleAlgorithm::groupId() const -> QString +{ + return QStringLiteral( "fixgeometry" ); +} + +auto QgsFixGeometryHoleAlgorithm::shortHelpString() const -> QString +{ + return QObject::tr( "This algorithm deletes holes based on an error layer from the " + "check holes algorithm.\n" ); +} + +auto QgsFixGeometryHoleAlgorithm::createInstance() const -> QgsFixGeometryHoleAlgorithm * +{ + return new QgsFixGeometryHoleAlgorithm(); +} + +void QgsFixGeometryHoleAlgorithm::initAlgorithm( const QVariantMap &configuration ) +{ + Q_UNUSED( configuration ) + + // Inputs + addParameter( new QgsProcessingParameterFeatureSource( QStringLiteral( "INPUT" ), QObject::tr( "Input layer" ), + QList< int >() << static_cast( Qgis::ProcessingSourceType::VectorPolygon ) << static_cast( Qgis::ProcessingSourceType::VectorLine ) ) + ); + addParameter( new QgsProcessingParameterFeatureSource( QStringLiteral( "ERRORS" ), QObject::tr( "Errors layer" ), + QList< int >() << static_cast( Qgis::ProcessingSourceType::VectorPoint ) ) + ); + addParameter( new QgsProcessingParameterField( + QStringLiteral( "UNIQUE_ID" ), QObject::tr( "Field of original feature unique identifier" ), + QStringLiteral( "id" ), QStringLiteral( "ERRORS" ) ) + ); + addParameter( new QgsProcessingParameterField( + QStringLiteral( "PART_IDX" ), QObject::tr( "Field of part index" ), + QStringLiteral( "gc_partidx" ), QStringLiteral( "ERRORS" ), + Qgis::ProcessingFieldParameterDataType::Numeric ) + ); + addParameter( new QgsProcessingParameterField( + QStringLiteral( "RING_IDX" ), QObject::tr( "Field of ring index" ), + QStringLiteral( "gc_ringidx" ), QStringLiteral( "ERRORS" ), + Qgis::ProcessingFieldParameterDataType::Numeric ) + ); + addParameter( new QgsProcessingParameterField( + QStringLiteral( "VERTEX_IDX" ), QObject::tr( "Field of vertex index" ), + QStringLiteral( "gc_vertidx" ), QStringLiteral( "ERRORS" ), + Qgis::ProcessingFieldParameterDataType::Numeric ) + ); + + // Outputs + addParameter( new QgsProcessingParameterFeatureSink( QStringLiteral( "OUTPUT" ), QObject::tr( "Output layer" ), Qgis::ProcessingSourceType::VectorAnyGeometry ) ); + addParameter( new QgsProcessingParameterFeatureSink( QStringLiteral( "REPORT" ), QObject::tr( "Report layer" ), Qgis::ProcessingSourceType::VectorPoint ) ); + + std::unique_ptr< QgsProcessingParameterNumber > tolerance = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "TOLERANCE" ), + QObject::tr( "Tolerance" ), Qgis::ProcessingNumberParameterType::Integer, 8, false, 1, 13 ); + tolerance->setFlags( tolerance->flags() | Qgis::ProcessingParameterFlag::Advanced ); + addParameter( tolerance.release() ); +} + +auto QgsFixGeometryHoleAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) -> QVariantMap +{ + const std::unique_ptr< QgsProcessingFeatureSource > input( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) ); + if ( !input ) + throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) ); + + const std::unique_ptr< QgsProcessingFeatureSource > errors( parameterAsSource( parameters, QStringLiteral( "ERRORS" ), context ) ); + if ( !errors ) + throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "ERRORS" ) ) ); + + QgsProcessingMultiStepFeedback multiStepFeedback( 2, feedback ); + + const QString featIdFieldName = parameterAsString( parameters, QStringLiteral( "UNIQUE_ID" ), context ); + const QString partIdxFieldName = parameterAsString( parameters, QStringLiteral( "PART_IDX" ), context ); + const QString ringIdxFieldName = parameterAsString( parameters, QStringLiteral( "RING_IDX" ), context ); + const QString vertexIdxFieldName = parameterAsString( parameters, QStringLiteral( "VERTEX_IDX" ), context ); + + // Verify that input fields exists + if ( errors->fields().indexFromName( featIdFieldName ) == -1 ) + throw QgsProcessingException( QObject::tr( "Field %1 does not exist in errors layer." ).arg( featIdFieldName ) ); + if ( errors->fields().indexFromName( partIdxFieldName ) == -1 ) + throw QgsProcessingException( QObject::tr( "Field %1 does not exist in errors layer." ).arg( partIdxFieldName ) ); + if ( errors->fields().indexFromName( ringIdxFieldName ) == -1 ) + throw QgsProcessingException( QObject::tr( "Field %1 does not exist in errors layer." ).arg( ringIdxFieldName ) ); + if ( errors->fields().indexFromName( vertexIdxFieldName ) == -1 ) + throw QgsProcessingException( QObject::tr( "Field %1 does not exist in errors layer." ).arg( vertexIdxFieldName ) ); + int inputIdFieldIndex = input->fields().indexFromName( featIdFieldName ); + if ( inputIdFieldIndex == -1 ) + throw QgsProcessingException( QObject::tr( "Field %1 does not exist in input layer." ).arg( featIdFieldName ) ); + + QgsField inputFeatIdField = input->fields().at( inputIdFieldIndex ); + if ( inputFeatIdField.type() != errors->fields().at( errors->fields().indexFromName( featIdFieldName ) ).type() ) + throw QgsProcessingException( QObject::tr( "Field %1 does not have the same type than in errors layer." ).arg( featIdFieldName ) ); + + QString dest_output; + const std::unique_ptr< QgsFeatureSink > sink_output( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest_output, input->fields(), input->wkbType(), input->sourceCrs() ) ); + if ( !sink_output ) + throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) ); + + QString dest_report; + QgsFields reportFields = errors->fields(); + reportFields.append( QgsField( QStringLiteral( "report" ), QMetaType::QString ) ); + reportFields.append( QgsField( QStringLiteral( "error_fixed" ), QMetaType::Bool ) ); + const std::unique_ptr< QgsFeatureSink > sink_report( parameterAsSink( parameters, QStringLiteral( "REPORT" ), context, dest_report, reportFields, errors->wkbType(), errors->sourceCrs() ) ); + if ( !sink_report ) + throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "REPORT" ) ) ); + + const QgsProject *project = QgsProject::instance(); + std::unique_ptr checkContext = std::make_unique( mTolerance, input->sourceCrs(), project->transformContext(), project ); + QStringList messages; + + const QgsGeometryHoleCheck check( checkContext.get(), QVariantMap() ); + + QgsVectorLayer *fixedLayer = input->materialize( QgsFeatureRequest() ); + std::unique_ptr featurePool = std::make_unique( fixedLayer ); + QMap featurePools; + featurePools.insert( fixedLayer->id(), featurePool.get() ); + + QgsFeature errorFeature, inputFeature, testDuplicateIdFeature; + QgsFeatureIterator errorFeaturesIt = errors->getFeatures(); + QList changesList; + QgsFeature reportFeature; + reportFeature.setFields( reportFields ); + long long progression = 0; + long long totalProgression = errors->featureCount(); + multiStepFeedback.setCurrentStep( 1 ); + multiStepFeedback.setProgressText( QObject::tr( "Fixing errors..." ) ); + while ( errorFeaturesIt.nextFeature( errorFeature ) ) + { + progression++; + multiStepFeedback.setProgress( static_cast( static_cast( progression ) / totalProgression ) * 100 ); + reportFeature.setGeometry( errorFeature.geometry() ); + + QString idValue = errorFeature.attribute( featIdFieldName ).toString(); + if ( inputFeatIdField.type() == QMetaType::QString ) + idValue = "'" + idValue + "'"; + + QgsFeatureIterator it = fixedLayer->getFeatures( QgsFeatureRequest().setFilterExpression( "\"" + featIdFieldName + "\" = " + idValue ) ); + if ( !it.nextFeature( inputFeature ) || !inputFeature.isValid() ) + reportFeature.setAttributes( errorFeature.attributes() << QObject::tr( "Source feature not found or invalid" ) << false ); + + else if ( it.nextFeature( testDuplicateIdFeature ) ) + throw QgsProcessingException( QObject::tr( "More than one feature found in input layer with value %1 in unique field %2" ).arg( idValue ).arg( featIdFieldName ) ); + + else if ( inputFeature.geometry().isNull() ) + reportFeature.setAttributes( errorFeature.attributes() << QObject::tr( "Feature geometry is null" ) << false ); + + else if ( QgsGeometryCheckerUtils::getGeomPart( inputFeature.geometry().constGet(), errorFeature.attribute( partIdxFieldName ).toInt() ) == nullptr ) + reportFeature.setAttributes( errorFeature.attributes() << QObject::tr( "Feature geometry part is null" ) << false ); + + else + { + QgsGeometryCheckError checkError = QgsGeometryCheckError( + &check, + QgsGeometryCheckerUtils::LayerFeature( featurePool.get(), inputFeature, checkContext.get(), false ), + errorFeature.geometry().asPoint(), + QgsVertexId( + errorFeature.attribute( partIdxFieldName ).toInt(), + errorFeature.attribute( ringIdxFieldName ).toInt(), + errorFeature.attribute( vertexIdxFieldName ).toInt() + ) + ); + for ( auto changes : changesList ) + checkError.handleChanges( changes ); + + QgsGeometryCheck::Changes changes; + check.fixError( featurePools, &checkError, QgsGeometryHoleCheck::ResolutionMethod::RemoveHoles, QMap(), changes ); + changesList << changes; + reportFeature.setAttributes( errorFeature.attributes() << checkError.resolutionMessage() << ( checkError.status() == QgsGeometryCheckError::StatusFixed ) ); + } + + if ( !sink_report->addFeature( reportFeature, QgsFeatureSink::FastInsert ) ) + throw QgsProcessingException( writeFeatureError( sink_report.get(), parameters, QStringLiteral( "REPORT" ) ) ); + + } + multiStepFeedback.setProgress( 100 ); + + progression = 0; + totalProgression = fixedLayer->featureCount(); + multiStepFeedback.setCurrentStep( 2 ); + multiStepFeedback.setProgressText( QObject::tr( "Exporting fixed layer..." ) ); + QgsFeature fixedFeature; + QgsFeatureIterator fixedFeaturesIt = fixedLayer->getFeatures(); + while ( fixedFeaturesIt.nextFeature( fixedFeature ) ) + { + progression++; + multiStepFeedback.setProgress( static_cast( static_cast( progression ) / totalProgression ) * 100 ); + if ( !sink_output->addFeature( fixedFeature, QgsFeatureSink::FastInsert ) ) + throw QgsProcessingException( writeFeatureError( sink_output.get(), parameters, QStringLiteral( "OUTPUT" ) ) ); + } + multiStepFeedback.setProgress( 100 ); + + QVariantMap outputs; + outputs.insert( QStringLiteral( "OUTPUT" ), dest_output ); + outputs.insert( QStringLiteral( "REPORT" ), dest_report ); + + return outputs; +} + +auto QgsFixGeometryHoleAlgorithm::prepareAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback * ) -> bool +{ + mTolerance = parameterAsInt( parameters, QStringLiteral( "TOLERANCE" ), context ); + + return true; +} + +auto QgsFixGeometryHoleAlgorithm::flags() const -> Qgis::ProcessingAlgorithmFlags +{ + return QgsProcessingAlgorithm::flags() | Qgis::ProcessingAlgorithmFlag::NoThreading; +} + +///@endcond diff --git a/src/analysis/processing/qgsalgorithmfixgeometryhole.h b/src/analysis/processing/qgsalgorithmfixgeometryhole.h new file mode 100644 index 00000000000..8cba99e0a52 --- /dev/null +++ b/src/analysis/processing/qgsalgorithmfixgeometryhole.h @@ -0,0 +1,55 @@ +/*************************************************************************** + qgsalgorithmfixgeometryhole.h + --------------------- + begin : July 2024 + copyright : (C) 2024 by Jacky Volpes + email : jacky dot volpes at oslandia dot com +***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +#ifndef QGSALGORITHMFIXGEOMETRYHOLE_H +#define QGSALGORITHMFIXGEOMETRYHOLE_H + +#define SIP_NO_FILE + +#include "qgis_sip.h" +#include "qgsprocessingalgorithm.h" + +///@cond PRIVATE + +class QgsFixGeometryHoleAlgorithm : public QgsProcessingAlgorithm +{ + public: + + QgsFixGeometryHoleAlgorithm() = default; + void initAlgorithm( const QVariantMap &configuration = QVariantMap() ) override; + QString name() const override; + QString displayName() const override; + QStringList tags() const override; + QString group() const override; + QString groupId() const override; + QString shortHelpString() const override; + Qgis::ProcessingAlgorithmFlags flags() const override; + QgsFixGeometryHoleAlgorithm *createInstance() const override SIP_FACTORY; + + protected: + + bool prepareAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) override; + QVariantMap processAlgorithm( const QVariantMap ¶meters, + QgsProcessingContext &context, QgsProcessingFeedback *feedback ) override; + private: + + int mTolerance{8}; +}; + +///@endcond PRIVATE + +#endif // QGSALGORITHMFIXGEOMETRYHOLE_H diff --git a/src/analysis/processing/qgsnativealgorithms.cpp b/src/analysis/processing/qgsnativealgorithms.cpp index e853f84ef11..e80e1a555d9 100644 --- a/src/analysis/processing/qgsnativealgorithms.cpp +++ b/src/analysis/processing/qgsnativealgorithms.cpp @@ -46,6 +46,7 @@ #include "qgsalgorithmcheckgeometryangle.h" #include "qgsalgorithmcheckgeometryarea.h" #include "qgsalgorithmfixgeometryarea.h" +#include "qgsalgorithmfixgeometryhole.h" #include "qgsalgorithmcheckgeometryhole.h" #include "qgsalgorithmclip.h" #include "qgsalgorithmconcavehull.h" @@ -585,6 +586,7 @@ void QgsNativeAlgorithms::loadAlgorithms() addAlgorithm( new QgsDensifyGeometriesByCountAlgorithm() ); addAlgorithm( new QgsFixGeometryAngleAlgorithm() ); addAlgorithm( new QgsFixGeometryAreaAlgorithm() ); + addAlgorithm( new QgsFixGeometryHoleAlgorithm() ); } ///@endcond diff --git a/tests/src/analysis/testqgsprocessingfixgeometry.cpp b/tests/src/analysis/testqgsprocessingfixgeometry.cpp index 5c7b97de94f..711b5ba83df 100644 --- a/tests/src/analysis/testqgsprocessingfixgeometry.cpp +++ b/tests/src/analysis/testqgsprocessingfixgeometry.cpp @@ -38,6 +38,8 @@ class TestQgsProcessingFixGeometry: public QgsTest void fixAreaAlg_data(); void fixAreaAlg(); + void fixHoleAlg(); + private: const QDir mDataDir{ QDir( TEST_DATA_DIR ).absoluteFilePath( QStringLiteral( "geometry_fix" ) ) }; @@ -272,5 +274,50 @@ void TestQgsProcessingFixGeometry::fixAreaAlg() } } +void TestQgsProcessingFixGeometry::fixHoleAlg() +{ + const QDir testDataDir( QDir( TEST_DATA_DIR ).absoluteFilePath( "geometry_checker" ) ); + QgsVectorLayer sourceLayer = QgsVectorLayer( testDataDir.absoluteFilePath( "polygon_layer.shp" ), QStringLiteral( "polygons" ), QStringLiteral( "ogr" ) ); + QgsVectorLayer errorsLayer = QgsVectorLayer( mDataDir.absoluteFilePath( "remove_hole.gpkg|layername=errors_layer" ), QStringLiteral( "" ), QStringLiteral( "ogr" ) ); + QVERIFY( sourceLayer.isValid() ); + QVERIFY( errorsLayer.isValid() ); + const auto reportList = QStringList() << QStringLiteral( "Remove hole" ); + + const std::unique_ptr< QgsProcessingAlgorithm > alg( + QgsApplication::processingRegistry()->createAlgorithmById( QStringLiteral( "native:fixgeometryhole" ) ) + ); + QVERIFY( alg != nullptr ); + + QVariantMap parameters; + parameters.insert( QStringLiteral( "INPUT" ), QVariant::fromValue( &sourceLayer ) ); + parameters.insert( QStringLiteral( "UNIQUE_ID" ), "id" ); + parameters.insert( QStringLiteral( "ERRORS" ), QVariant::fromValue( &errorsLayer ) ); + parameters.insert( QStringLiteral( "OUTPUT" ), QgsProcessing::TEMPORARY_OUTPUT ); + parameters.insert( QStringLiteral( "REPORT" ), QgsProcessing::TEMPORARY_OUTPUT ); + + bool ok = false; + QgsProcessingFeedback feedback; + std::unique_ptr< QgsProcessingContext > context = std::make_unique< QgsProcessingContext >(); + + QVariantMap results; + results = alg->run( parameters, *context, &feedback, &ok ); + QVERIFY( ok ); + + const std::unique_ptr outputLayer( qobject_cast< QgsVectorLayer * >( context->getMapLayer( results.value( QStringLiteral( "OUTPUT" ) ).toString() ) ) ); + const std::unique_ptr reportLayer( qobject_cast< QgsVectorLayer * >( context->getMapLayer( results.value( QStringLiteral( "REPORT" ) ).toString() ) ) ); + QVERIFY( reportLayer->isValid() ); + QVERIFY( outputLayer->isValid() ); + + QCOMPARE( outputLayer->featureCount(), 25 ); + QCOMPARE( reportLayer->featureCount(), reportList.count() ); + int idx = 1; + for ( QString expectedReport : reportList ) + { + const QgsFeature reportFeature = reportLayer->getFeature( idx ); + QCOMPARE( reportFeature.attribute( "report" ), expectedReport ); + idx++; + } +} + QGSTEST_MAIN( TestQgsProcessingFixGeometry ) #include "testqgsprocessingfixgeometry.moc" diff --git a/tests/testdata/geometry_fix/remove_hole.gpkg b/tests/testdata/geometry_fix/remove_hole.gpkg new file mode 100644 index 0000000000000000000000000000000000000000..7e61686f3a72d0d0eb63162ce3c211dfe2ec0315 GIT binary patch literal 98304 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