api/qgsalgorithmfixgeometrydeletefeatures_8cpp_source.html

/***************************************************************************

                        qgsalgorithmfixgeometrydeletefeatures.cpp

                        ---------------------

   begin                : April 2025

   copyright            : (C) 2025 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 "qgsalgorithmfixgeometrydeletefeatures.h"


QString QgsFixGeometryDeleteFeaturesAlgorithm::name() const

{

  return QStringLiteral( "fixgeometrydeletefeatures" );

}


QString QgsFixGeometryDeleteFeaturesAlgorithm::displayName() const

{

  return QObject::tr( "Delete features" );

}


QString QgsFixGeometryDeleteFeaturesAlgorithm::shortDescription() const

{

  return QObject::tr( "Deletes features detected with an algorithm from the \"Check geometry\" section." );

}


QStringList QgsFixGeometryDeleteFeaturesAlgorithm::tags() const

{

  return QObject::tr( "fix,delete,features" ).split( ',' );

}


QString QgsFixGeometryDeleteFeaturesAlgorithm::group() const

{

  return QObject::tr( "Fix geometry" );

}


QString QgsFixGeometryDeleteFeaturesAlgorithm::groupId() const

{

  return QStringLiteral( "fixgeometry" );

}


QString QgsFixGeometryDeleteFeaturesAlgorithm::shortHelpString() const

{

  return QObject::tr( "This algorithm deletes error features listed in the errors layer from an algorithm in the \"Check geometry\" section.\n"

                      "The required inputs are the original layer used in the check algorithm, its unique id field, and its corresponding errors layer.\n\n"

                      "For instance, it can be used after the following check algorithms to delete error features:"

                      "<html><ul><li>Feature inside polygon</li>"

                      "<li>Degenerate polygons</li>"

                      "<li>Small segments</li>"

                      "<li>Duplicated geometries</li>"

                      "<li>etc.</li></ul></html>" );

}


QgsFixGeometryDeleteFeaturesAlgorithm *QgsFixGeometryDeleteFeaturesAlgorithm::createInstance() const

{

  return new QgsFixGeometryDeleteFeaturesAlgorithm();

}


void QgsFixGeometryDeleteFeaturesAlgorithm::initAlgorithm( const QVariantMap &configuration )

{

  Q_UNUSED( configuration )


  // Inputs

  addParameter( new QgsProcessingParameterFeatureSource(

    QStringLiteral( "INPUT" ), QObject::tr( "Input layer" ),

    QList<int>()

      << static_cast<int>( Qgis::ProcessingSourceType::VectorPoint )

      << static_cast<int>( Qgis::ProcessingSourceType::VectorLine )

      << static_cast<int>( Qgis::ProcessingSourceType::VectorPolygon )

  ) );

  addParameter( new QgsProcessingParameterFeatureSource(

    QStringLiteral( "ERRORS" ), QObject::tr( "Error layer" ), QList<int>() << static_cast<int>( Qgis::ProcessingSourceType::VectorPoint )

  ) );

  addParameter( new QgsProcessingParameterField(

    QStringLiteral( "UNIQUE_ID" ), QObject::tr( "Field of original feature unique identifier" ),

    QString(), QStringLiteral( "ERRORS" )

  ) );


  // Outputs

  addParameter( new QgsProcessingParameterFeatureSink(

    QStringLiteral( "OUTPUT" ), QObject::tr( "Cleaned layer" ), Qgis::ProcessingSourceType::VectorAnyGeometry

  ) );

  addParameter( new QgsProcessingParameterFeatureSink(

    QStringLiteral( "REPORT" ), QObject::tr( "Report layer from deleting features" ), Qgis::ProcessingSourceType::VectorPoint

  ) );

}


QVariantMap QgsFixGeometryDeleteFeaturesAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )

{

  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" ) ) );


  const QString featIdFieldName = parameterAsString( parameters, QStringLiteral( "UNIQUE_ID" ), context );


  // Verify that input fields exists

  const int errorsIdFieldIndex = errors->fields().indexFromName( featIdFieldName );

  if ( errorsIdFieldIndex == -1 )

    throw QgsProcessingException( QObject::tr( "Field %1 does not exist in the error layer." ).arg( featIdFieldName ) );

  const int inputIdFieldIndex = input->fields().indexFromName( featIdFieldName );

  if ( inputIdFieldIndex == -1 )

    throw QgsProcessingException( QObject::tr( "Field %1 does not exist in input layer." ).arg( featIdFieldName ) );


  const QgsField inputFeatIdField = input->fields().at( inputIdFieldIndex );

  const QMetaType::Type inputFeatIdFieldType = inputFeatIdField.type();

  if ( inputFeatIdFieldType != errors->fields().at( errorsIdFieldIndex ).type() )

    throw QgsProcessingException( QObject::tr( "Input field %1 does not have the same type as in the error 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" ) ) );


  QgsFeature inputFeature, errorFeature, reportFeature;

  reportFeature.setFields( reportFields );

  long long progression = 0;

  long long totalProgression = input->featureCount();

  feedback->setProgressText( QObject::tr( "Fixing errors..." ) );


  QgsFeatureIterator inputFeaturesIt = input->getFeatures();

  while ( inputFeaturesIt.nextFeature( inputFeature ) )

  {

    if ( feedback->isCanceled() )

      break;


    progression++;

    feedback->setProgress( static_cast<double>( static_cast<long double>( progression ) / totalProgression ) * 100 );


    QString idValue = inputFeature.attribute( featIdFieldName ).toString();

    if ( inputFeatIdFieldType == QMetaType::QString )

      idValue = "'" + idValue + "'";


    QgsFeatureIterator errorFeaturesIt = errors->getFeatures(

      QgsFeatureRequest()

        .setFlags( Qgis::FeatureRequestFlag::SubsetOfAttributes ) // the request will select only the fields referenced in the expression

        .setFilterExpression( "\"" + featIdFieldName + "\" = " + idValue )

    );

    if ( errorFeaturesIt.nextFeature( errorFeature ) && errorFeature.isValid() )

    {

      // We found an error feature corresponding to the input feature we are iterating

      // so it means that we want to delete this feature.

      // Just don't add this feature to the output sink, and add a report feature saying

      // that everything went fine.

      reportFeature.setGeometry( errorFeature.geometry() );

      reportFeature.setAttributes( errorFeature.attributes() << QStringLiteral( "Feature deleted" ) << true );

      if ( !sink_report->addFeature( reportFeature, QgsFeatureSink::FastInsert ) )

        throw QgsProcessingException( writeFeatureError( sink_report.get(), parameters, QStringLiteral( "REPORT" ) ) );

    }

    else

    {

      // We didn't find an error corresponding to this feature, so we must keep this feature.

      // Just add it to the output sink.

      if ( !sink_output->addFeature( inputFeature, QgsFeatureSink::FastInsert ) )

        throw QgsProcessingException( writeFeatureError( sink_output.get(), parameters, QStringLiteral( "OUTPUT" ) ) );

    }

  }

  feedback->setProgress( 100 );


  QVariantMap outputs;

  outputs.insert( QStringLiteral( "OUTPUT" ), dest_output );

  outputs.insert( QStringLiteral( "REPORT" ), dest_report );


  return outputs;

}


Qgis::ProcessingAlgorithmFlags QgsFixGeometryDeleteFeaturesAlgorithm::flags() const

{

  return QgsProcessingAlgorithm::flags() | Qgis::ProcessingAlgorithmFlag::NoThreading;

}


Qgis::ProcessingSourceType::VectorAnyGeometry
@ VectorAnyGeometry
Any vector layer with geometry.

Qgis::ProcessingSourceType::VectorPoint
@ VectorPoint
Vector point layers.

Qgis::ProcessingSourceType::VectorPolygon
@ VectorPolygon
Vector polygon layers.

Qgis::ProcessingSourceType::VectorLine
@ VectorLine
Vector line layers.

Qgis::FeatureRequestFlag::SubsetOfAttributes
@ SubsetOfAttributes
Fetch only a subset of attributes (setSubsetOfAttributes sets this flag)

Qgis::ProcessingAlgorithmFlags
QFlags< ProcessingAlgorithmFlag > ProcessingAlgorithmFlags
Flags indicating how and when an algorithm operates and should be exposed to users.
Definition qgis.h:3476

Qgis::ProcessingAlgorithmFlag::NoThreading
@ NoThreading
Algorithm is not thread safe and cannot be run in a background thread, e.g. for algorithms which mani...

QgsFeatureIterator
Wrapper for iterator of features from vector data provider or vector layer.
Definition qgsfeatureiterator.h:290

QgsFeatureIterator::nextFeature
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
Definition qgsfeatureiterator.h:407

QgsFeatureRequest
Wraps a request for features to a vector layer (or directly its vector data provider).
Definition qgsfeaturerequest.h:84

QgsFeatureSink::FastInsert
@ FastInsert
Use faster inserts, at the cost of updating the passed features to reflect changes made at the provid...
Definition qgsfeaturesink.h:69

QgsFeature
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:58

QgsFeature::attributes
QgsAttributes attributes
Definition qgsfeature.h:67

QgsFeature::setAttributes
void setAttributes(const QgsAttributes &attrs)
Sets the feature's attributes.
Definition qgsfeature.cpp:161

QgsFeature::setFields
void setFields(const QgsFields &fields, bool initAttributes=false)
Assigns a field map with the feature to allow attribute access by attribute name.
Definition qgsfeature.cpp:196

QgsFeature::geometry
QgsGeometry geometry
Definition qgsfeature.h:69

QgsFeature::isValid
bool isValid() const
Returns the validity of this feature.
Definition qgsfeature.cpp:217

QgsFeature::attribute
Q_INVOKABLE QVariant attribute(const QString &name) const
Lookup attribute value by attribute name.
Definition qgsfeature.cpp:336

QgsFeature::setGeometry
void setGeometry(const QgsGeometry &geometry)
Set the feature's geometry.
Definition qgsfeature.cpp:168

QgsFeedback::isCanceled
bool isCanceled() const
Tells whether the operation has been canceled already.
Definition qgsfeedback.h:53

QgsFeedback::setProgress
void setProgress(double progress)
Sets the current progress for the feedback object.
Definition qgsfeedback.h:61

QgsField
Encapsulate a field in an attribute table or data source.
Definition qgsfield.h:53

QgsField::type
QMetaType::Type type
Definition qgsfield.h:60

QgsFields
Container of fields for a vector layer.
Definition qgsfields.h:46

QgsFields::append
bool append(const QgsField &field, Qgis::FieldOrigin origin=Qgis::FieldOrigin::Provider, int originIndex=-1)
Appends a field.
Definition qgsfields.cpp:70

QgsProcessingAlgorithm::flags
virtual Qgis::ProcessingAlgorithmFlags flags() const
Returns the flags indicating how and when the algorithm operates and should be exposed to users.
Definition qgsprocessingalgorithm.cpp:95

QgsProcessingContext
Contains information about the context in which a processing algorithm is executed.
Definition qgsprocessingcontext.h:45

QgsProcessingException
Custom exception class for processing related exceptions.
Definition qgsexception.h:83

QgsProcessingFeedback
Base class for providing feedback from a processing algorithm.
Definition qgsprocessingfeedback.h:38

QgsProcessingFeedback::setProgressText
virtual void setProgressText(const QString &text)
Sets a progress report text string.
Definition qgsprocessingfeedback.cpp:37

QgsProcessingParameterFeatureSink
A feature sink output for processing algorithms.
Definition qgsprocessingparameters.h:3456

QgsProcessingParameterFeatureSource
An input feature source (such as vector layers) parameter for processing algorithms.
Definition qgsprocessingparameters.h:3294

QgsProcessingParameterField
A vector layer or feature source field parameter for processing algorithms.
Definition qgsprocessingparameters.h:3187

qgsalgorithmfixgeometrydeletefeatures.h