QVariantMap QgsIntersectionAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
std::unique_ptr< QgsFeatureSource > sourceA( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
if ( !sourceA )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
std::unique_ptr< QgsFeatureSource > sourceB( parameterAsSource( parameters, QStringLiteral( "OVERLAY" ), context ) );
if ( !sourceB )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "OVERLAY" ) ) );
QgsWkbTypes::Type geomType = QgsWkbTypes::multiType( sourceA->wkbType() );
const QStringList fieldsA = parameterAsFields( parameters, QStringLiteral( "INPUT_FIELDS" ), context );
const QStringList fieldsB = parameterAsFields( parameters, QStringLiteral( "OVERLAY_FIELDS" ), context );
QList<int> fieldIndicesA = QgsProcessingUtils::fieldNamesToIndices( fieldsA, sourceA->fields() );
QList<int> fieldIndicesB = QgsProcessingUtils::fieldNamesToIndices( fieldsB, sourceB->fields() );
QgsFields outputFields = QgsProcessingUtils::combineFields(
QgsProcessingUtils::indicesToFields( fieldIndicesA, sourceA->fields() ),
QgsProcessingUtils::indicesToFields( fieldIndicesB, sourceB->fields() ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, outputFields, geomType, sourceA->sourceCrs() ) );
if ( !sink )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
QVariantMap outputs;
outputs.insert( QStringLiteral( "OUTPUT" ), dest );
int count = 0;
int total = sourceA->featureCount();
QgsOverlayUtils::intersection( *sourceA.get(), *sourceB.get(), *sink.get(), context, feedback, count, total, fieldIndicesA, fieldIndicesB );
return outputs;
}
QVariantMap QgsJoinWithLinesAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
if ( parameters.value( QStringLiteral( "SPOKES" ) ) == parameters.value( QStringLiteral( "HUBS" ) ) )
throw QgsProcessingException( QObject::tr( "Same layer given for both hubs and spokes" ) );
std::unique_ptr< QgsProcessingFeatureSource > hubSource( parameterAsSource( parameters, QStringLiteral( "HUBS" ), context ) );
if ( !hubSource )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "HUBS" ) ) );
std::unique_ptr< QgsProcessingFeatureSource > spokeSource( parameterAsSource( parameters, QStringLiteral( "SPOKES" ), context ) );
if ( !hubSource || !spokeSource )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "SPOKES" ) ) );
QString fieldHubName = parameterAsString( parameters, QStringLiteral( "HUB_FIELD" ), context );
int fieldHubIndex = hubSource->fields().lookupField( fieldHubName );
const QStringList hubFieldsToCopy = parameterAsFields( parameters, QStringLiteral( "HUB_FIELDS" ), context );
QString fieldSpokeName = parameterAsString( parameters, QStringLiteral( "SPOKE_FIELD" ), context );
int fieldSpokeIndex = spokeSource->fields().lookupField( fieldSpokeName );
const QStringList spokeFieldsToCopy = parameterAsFields( parameters, QStringLiteral( "SPOKE_FIELDS" ), context );
if ( fieldHubIndex < 0 || fieldSpokeIndex < 0 )
throw QgsProcessingException( QObject::tr( "Invalid ID field" ) );
const bool geodesic = parameterAsBool( parameters, QStringLiteral( "GEODESIC" ), context );
const double geodesicDistance = parameterAsDouble( parameters, QStringLiteral( "GEODESIC_DISTANCE" ), context ) * 1000;
bool dynamicGeodesicDistance = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "GEODESIC_DISTANCE" ) );
QgsExpressionContext expressionContext = createExpressionContext( parameters, context, hubSource.get() );
QgsProperty geodesicDistanceProperty;
if ( dynamicGeodesicDistance )
{
geodesicDistanceProperty = parameters.value( QStringLiteral( "GEODESIC_DISTANCE" ) ).value< QgsProperty >();
}
const bool splitAntimeridian = parameterAsBool( parameters, QStringLiteral( "ANTIMERIDIAN_SPLIT" ), context );
QgsDistanceArea da;
da.setSourceCrs( hubSource->sourceCrs(), context.transformContext() );
da.setEllipsoid( context.project()->ellipsoid() );
QgsFields hubOutFields;
QgsAttributeList hubFieldIndices;
if ( hubFieldsToCopy.empty() )
{
hubOutFields = hubSource->fields();
hubFieldIndices.reserve( hubOutFields.count() );
for ( int i = 0; i < hubOutFields.count(); ++i )
{
hubFieldIndices << i;
}
}
else
{
hubFieldIndices.reserve( hubOutFields.count() );
for ( const QString &field : hubFieldsToCopy )
{
int index = hubSource->fields().lookupField( field );
if ( index >= 0 )
{
hubFieldIndices << index;
hubOutFields.append( hubSource->fields().at( index ) );
}
}
}
QgsAttributeList hubFields2Fetch = hubFieldIndices;
hubFields2Fetch << fieldHubIndex;
QgsFields spokeOutFields;
QgsAttributeList spokeFieldIndices;
if ( spokeFieldsToCopy.empty() )
{
spokeOutFields = spokeSource->fields();
spokeFieldIndices.reserve( spokeOutFields.count() );
for ( int i = 0; i < spokeOutFields.count(); ++i )
{
spokeFieldIndices << i;
}
}
else
{
for ( const QString &field : spokeFieldsToCopy )
{
int index = spokeSource->fields().lookupField( field );
if ( index >= 0 )
{
spokeFieldIndices << index;
spokeOutFields.append( spokeSource->fields().at( index ) );
}
}
}
QgsAttributeList spokeFields2Fetch = spokeFieldIndices;
spokeFields2Fetch << fieldSpokeIndex;
QgsFields fields = QgsProcessingUtils::combineFields( hubOutFields, spokeOutFields );
QgsWkbTypes::Type outType = geodesic ? QgsWkbTypes::MultiLineString : QgsWkbTypes::LineString;
bool hasZ = false;
if ( QgsWkbTypes::hasZ( hubSource->wkbType() ) || QgsWkbTypes::hasZ( spokeSource->wkbType() ) )
{
outType = QgsWkbTypes::addZ( outType );
hasZ = true;
}
bool hasM = false;
if ( QgsWkbTypes::hasM( hubSource->wkbType() ) || QgsWkbTypes::hasM( spokeSource->wkbType() ) )
{
outType = QgsWkbTypes::addM( outType );
hasM = true;
}
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields,
outType, hubSource->sourceCrs(), QgsFeatureSink::RegeneratePrimaryKey ) );
if ( !sink )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
auto getPointFromFeature = [hasZ, hasM]( const QgsFeature & feature )->QgsPoint
{
QgsPoint p;
if ( feature.geometry().type() == QgsWkbTypes::PointGeometry && !feature.geometry().isMultipart() )
p = *static_cast< const QgsPoint *>( feature.geometry().constGet() );
else
p = *static_cast< const QgsPoint *>( feature.geometry().pointOnSurface().constGet() );
if ( hasZ && !p.is3D() )
p.addZValue( 0 );
if ( hasM && !p.isMeasure() )
p.addMValue( 0 );
return p;
};
QgsFeatureIterator hubFeatures = hubSource->getFeatures( QgsFeatureRequest().setSubsetOfAttributes( hubFields2Fetch ), QgsProcessingFeatureSource::FlagSkipGeometryValidityChecks );
double step = hubSource->featureCount() > 0 ? 100.0 / hubSource->featureCount() : 1;
int i = 0;
QgsFeature hubFeature;
while ( hubFeatures.nextFeature( hubFeature ) )
{
i++;
if ( feedback->isCanceled() )
{
break;
}
feedback->setProgress( i * step );
if ( !hubFeature.hasGeometry() )
continue;
QgsPoint hubPoint = getPointFromFeature( hubFeature );
// only keep selected attributes
QgsAttributes hubAttributes;
for ( int j = 0; j < hubFeature.attributes().count(); ++j )
{
if ( !hubFieldIndices.contains( j ) )
continue;
hubAttributes << hubFeature.attribute( j );
}
QgsFeatureRequest spokeRequest = QgsFeatureRequest().setDestinationCrs( hubSource->sourceCrs(), context.transformContext() );
spokeRequest.setSubsetOfAttributes( spokeFields2Fetch );
spokeRequest.setFilterExpression( QgsExpression::createFieldEqualityExpression( fieldSpokeName, hubFeature.attribute( fieldHubIndex ) ) );
QgsFeatureIterator spokeFeatures = spokeSource->getFeatures( spokeRequest, QgsProcessingFeatureSource::FlagSkipGeometryValidityChecks );
QgsFeature spokeFeature;
while ( spokeFeatures.nextFeature( spokeFeature ) )
{
if ( feedback->isCanceled() )
{
break;
}
if ( !spokeFeature.hasGeometry() )
continue;
QgsPoint spokePoint = getPointFromFeature( spokeFeature );
QgsGeometry line;
if ( !geodesic )
{
line = QgsGeometry( new QgsLineString( QVector< QgsPoint >() << hubPoint << spokePoint ) );
if ( splitAntimeridian )
line = da.splitGeometryAtAntimeridian( line );
}
else
{
double distance = geodesicDistance;
if ( dynamicGeodesicDistance )
{
expressionContext.setFeature( hubFeature );
distance = geodesicDistanceProperty.valueAsDouble( expressionContext, distance );
}
std::unique_ptr< QgsMultiLineString > ml = qgis::make_unique< QgsMultiLineString >();
std::unique_ptr< QgsLineString > l = qgis::make_unique< QgsLineString >( QVector< QgsPoint >() << hubPoint );
QVector< QVector< QgsPointXY > > points = da.geodesicLine( QgsPointXY( hubPoint ), QgsPointXY( spokePoint ), distance, splitAntimeridian );
QVector< QgsPointXY > points1 = points.at( 0 );
points1.pop_front();
if ( points.count() == 1 )
points1.pop_back();
QgsLineString geodesicPoints( points1 );
l->append( &geodesicPoints );
if ( points.count() == 1 )
l->addVertex( spokePoint );
ml->addGeometry( l.release() );
if ( points.count() > 1 )
{
QVector< QgsPointXY > points2 = points.at( 1 );
points2.pop_back();
l = qgis::make_unique< QgsLineString >( points2 );
if ( hasZ )
l->addZValue( std::numeric_limits<double>::quiet_NaN() );
if ( hasM )
l->addMValue( std::numeric_limits<double>::quiet_NaN() );
l->addVertex( spokePoint );
ml->addGeometry( l.release() );
}
line = QgsGeometry( std::move( ml ) );
}
QgsFeature outFeature;
QgsAttributes outAttributes = hubAttributes;
// only keep selected attributes
QgsAttributes spokeAttributes;
for ( int j = 0; j < spokeFeature.attributes().count(); ++j )
{
if ( !spokeFieldIndices.contains( j ) )
continue;
spokeAttributes << spokeFeature.attribute( j );
}
outAttributes.append( spokeAttributes );
outFeature.setAttributes( outAttributes );
outFeature.setGeometry( line );
sink->addFeature( outFeature, QgsFeatureSink::FastInsert );
}
}
QVariantMap outputs;
outputs.insert( QStringLiteral( "OUTPUT" ), dest );
return outputs;
}
QVariantMap QgsLineIntersectionAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
std::unique_ptr< QgsFeatureSource > sourceA( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
if ( !sourceA )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
std::unique_ptr< QgsFeatureSource > sourceB( parameterAsSource( parameters, QStringLiteral( "INTERSECT" ), context ) );
if ( !sourceB )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INTERSECT" ) ) );
const QStringList fieldsA = parameterAsFields( parameters, QStringLiteral( "INPUT_FIELDS" ), context );
const QStringList fieldsB = parameterAsFields( parameters, QStringLiteral( "INTERSECT_FIELDS" ), context );
QgsAttributeList fieldIndicesA = QgsProcessingUtils::fieldNamesToIndices( fieldsA, sourceA->fields() );
QgsAttributeList fieldIndicesB = QgsProcessingUtils::fieldNamesToIndices( fieldsB, sourceB->fields() );
QString intersectFieldsPrefix = parameterAsString( parameters, QStringLiteral( "INTERSECT_FIELDS_PREFIX" ), context );
QgsFields outFields = QgsProcessingUtils::combineFields(
QgsProcessingUtils::indicesToFields( fieldIndicesA, sourceA->fields() ),
QgsProcessingUtils::indicesToFields( fieldIndicesB, sourceB->fields() ),
intersectFieldsPrefix );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, outFields, QgsWkbTypes::Point, sourceA->sourceCrs(), QgsFeatureSink::RegeneratePrimaryKey ) );
if ( !sink )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
QgsSpatialIndex spatialIndex( sourceB->getFeatures( QgsFeatureRequest().setNoAttributes().setDestinationCrs( sourceA->sourceCrs(), context.transformContext() ) ), feedback );
QgsFeature outFeature;
QgsFeatureIterator features = sourceA->getFeatures( QgsFeatureRequest().setSubsetOfAttributes( fieldIndicesA ) );
double step = sourceA->featureCount() > 0 ? 100.0 / sourceA->featureCount() : 1;
int i = 0;
QgsFeature inFeatureA;
while ( features.nextFeature( inFeatureA ) )
{
i++;
if ( feedback->isCanceled() )
{
break;
}
if ( !inFeatureA.hasGeometry() )
continue;
QgsGeometry inGeom = inFeatureA.geometry();
QgsFeatureIds lines = spatialIndex.intersects( inGeom.boundingBox() ).toSet();
if ( !lines.empty() )
{
// use prepared geometries for faster intersection tests
std::unique_ptr< QgsGeometryEngine > engine( QgsGeometry::createGeometryEngine( inGeom.constGet() ) );
engine->prepareGeometry();
QgsFeatureRequest request = QgsFeatureRequest().setFilterFids( lines );
request.setDestinationCrs( sourceA->sourceCrs(), context.transformContext() );
request.setSubsetOfAttributes( fieldIndicesB );
QgsFeature inFeatureB;
QgsFeatureIterator featuresB = sourceB->getFeatures( request );
while ( featuresB.nextFeature( inFeatureB ) )
{
if ( feedback->isCanceled() )
{
break;
}
QgsGeometry tmpGeom = inFeatureB.geometry();
if ( engine->intersects( tmpGeom.constGet() ) )
{
QgsMultiPointXY points;
QgsGeometry intersectGeom = inGeom.intersection( tmpGeom );
QgsAttributes outAttributes;
for ( int a : qgis::as_const( fieldIndicesA ) )
{
outAttributes.append( inFeatureA.attribute( a ) );
}
for ( int b : qgis::as_const( fieldIndicesB ) )
{
outAttributes.append( inFeatureB.attribute( b ) );
}
if ( QgsWkbTypes::flatType( intersectGeom.wkbType() ) == QgsWkbTypes::GeometryCollection )
{
const QVector<QgsGeometry> geomCollection = intersectGeom.asGeometryCollection();
for ( const QgsGeometry &part : geomCollection )
{
if ( part.type() == QgsWkbTypes::PointGeometry )
{
if ( part.isMultipart() )
{
points = part.asMultiPoint();
}
else
{
points.append( part.asPoint() );
}
}
}
}
else if ( intersectGeom.type() == QgsWkbTypes::PointGeometry )
{
if ( intersectGeom.isMultipart() )
{
points = intersectGeom.asMultiPoint();
}
else
{
points.append( intersectGeom.asPoint() );
}
}
for ( const QgsPointXY &j : qgis::as_const( points ) )
{
outFeature.setGeometry( QgsGeometry::fromPointXY( j ) );
outFeature.setAttributes( outAttributes );
sink->addFeature( outFeature, QgsFeatureSink::FastInsert );
}
}
}
}
feedback->setProgress( i * step );
}
QVariantMap outputs;
outputs.insert( QStringLiteral( "OUTPUT" ), dest );
return outputs;
}
QVariantMap QgsDissolveAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) const
{
std::unique_ptr< QgsFeatureSource > source( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
if ( !source )
return QVariantMap();
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, source->fields(), QgsWkbTypes::multiType( source->wkbType() ), source->sourceCrs(), dest ) );
if ( !sink )
return QVariantMap();
QStringList fields = parameterAsFields( parameters, QStringLiteral( "FIELD" ), context );
long count = source->featureCount();
if ( count <= 0 )
return QVariantMap();
QgsFeature f;
QgsFeatureIterator it = source->getFeatures();
double step = 100.0 / count;
int current = 0;
if ( fields.isEmpty() )
{
// dissolve all - not using fields
bool firstFeature = true;
// we dissolve geometries in blocks using unaryUnion
QList< QgsGeometry > geomQueue;
QgsFeature outputFeature;
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
if ( firstFeature )
{
outputFeature = f;
firstFeature = false;
}
if ( f.hasGeometry() && f.geometry() )
{
geomQueue.append( f.geometry() );
if ( geomQueue.length() > 10000 )
{
// queue too long, combine it
QgsGeometry tempOutputGeometry = QgsGeometry::unaryUnion( geomQueue );
geomQueue.clear();
geomQueue << tempOutputGeometry;
}
}
feedback->setProgress( current * step );
current++;
}
outputFeature.setGeometry( QgsGeometry::unaryUnion( geomQueue ) );
sink->addFeature( outputFeature );
}
else
{
QList< int > fieldIndexes;
Q_FOREACH ( const QString &field, fields )
{
int index = source->fields().lookupField( field );
if ( index >= 0 )
fieldIndexes << index;
}
QHash< QVariant, QgsAttributes > attributeHash;
QHash< QVariant, QList< QgsGeometry > > geometryHash;
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
if ( f.hasGeometry() && f.geometry() )
{
QVariantList indexAttributes;
Q_FOREACH ( int index, fieldIndexes )
{
indexAttributes << f.attribute( index );
}
if ( !attributeHash.contains( indexAttributes ) )
{
// keep attributes of first feature
attributeHash.insert( indexAttributes, f.attributes() );
}
geometryHash[ indexAttributes ].append( f.geometry() );
}
QVariantMap QgsRemoveDuplicatesByAttributeAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
std::unique_ptr< QgsProcessingFeatureSource > source( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
if ( !source )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
const QStringList fieldNames = parameterAsFields( parameters, QStringLiteral( "FIELDS" ), context );
QgsAttributeList attributes;
for ( const QString &field : fieldNames )
{
const int index = source->fields().lookupField( field );
if ( index < 0 )
feedback->reportError( QObject::tr( "Field %1 not found in INPUT layer, skipping" ).arg( field ) );
else
attributes.append( index );
}
if ( attributes.isEmpty() )
throw QgsProcessingException( QObject::tr( "No input fields found" ) );
QString noDupeSinkId;
std::unique_ptr< QgsFeatureSink > noDupeSink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, noDupeSinkId, source->fields(),
source->wkbType(), source->sourceCrs() ) );
if ( !noDupeSink )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
QString dupeSinkId;
std::unique_ptr< QgsFeatureSink > dupesSink( parameterAsSink( parameters, QStringLiteral( "DUPLICATES" ), context, dupeSinkId, source->fields(),
source->wkbType(), source->sourceCrs() ) );
const long count = source->featureCount();
double step = count > 0 ? 100.0 / count : 1;
int current = 0;
long long keptCount = 0;
long long discardedCount = 0;
QSet< QVariantList > matched;
QgsFeatureIterator it = source->getFeatures( QgsFeatureRequest(), QgsProcessingFeatureSource::FlagSkipGeometryValidityChecks );
QgsFeature f;
QVariantList dupeKey;
dupeKey.reserve( attributes.size() );
for ( int i : attributes )
{
( void )i;
dupeKey.append( QVariant() );
}
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
int i = 0;
for ( int attr : attributes )
dupeKey[i++] = f.attribute( attr );
if ( matched.contains( dupeKey ) )
{
// duplicate
discardedCount++;
if ( dupesSink )
dupesSink->addFeature( f, QgsFeatureSink::FastInsert );
}
else
{
// not duplicate
keptCount++;
matched.insert( dupeKey );
noDupeSink->addFeature( f, QgsFeatureSink::FastInsert );
}
feedback->setProgress( current * step );
current++;
}
QVariantMap outputs;
outputs.insert( QStringLiteral( "RETAINED_COUNT" ), keptCount );
outputs.insert( QStringLiteral( "DUPLICATE_COUNT" ), discardedCount );
outputs.insert( QStringLiteral( "OUTPUT" ), noDupeSinkId );
if ( dupesSink )
outputs.insert( QStringLiteral( "DUPLICATES" ), dupeSinkId );
return outputs;
}
QVariantMap QgsCollectorAlgorithm::processCollection( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback,
const std::function<QgsGeometry( const QVector< QgsGeometry >& )> &collector, int maxQueueLength )
{
std::unique_ptr< QgsFeatureSource > source( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
if ( !source )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, source->fields(), QgsWkbTypes::multiType( source->wkbType() ), source->sourceCrs() ) );
if ( !sink )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
QStringList fields = parameterAsFields( parameters, QStringLiteral( "FIELD" ), context );
long count = source->featureCount();
QgsFeature f;
QgsFeatureIterator it = source->getFeatures();
double step = count > 0 ? 100.0 / count : 1;
int current = 0;
if ( fields.isEmpty() )
{
// dissolve all - not using fields
bool firstFeature = true;
// we dissolve geometries in blocks using unaryUnion
QVector< QgsGeometry > geomQueue;
QgsFeature outputFeature;
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
if ( firstFeature )
{
outputFeature = f;
firstFeature = false;
}
if ( f.hasGeometry() && !f.geometry().isNull() )
{
geomQueue.append( f.geometry() );
if ( maxQueueLength > 0 && geomQueue.length() > maxQueueLength )
{
// queue too long, combine it
QgsGeometry tempOutputGeometry = collector( geomQueue );
geomQueue.clear();
geomQueue << tempOutputGeometry;
}
}
feedback->setProgress( current * step );
current++;
}
outputFeature.setGeometry( collector( geomQueue ) );
sink->addFeature( outputFeature, QgsFeatureSink::FastInsert );
}
else
{
QList< int > fieldIndexes;
Q_FOREACH ( const QString &field, fields )
{
int index = source->fields().lookupField( field );
if ( index >= 0 )
fieldIndexes << index;
}
QHash< QVariant, QgsAttributes > attributeHash;
QHash< QVariant, QVector< QgsGeometry > > geometryHash;
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
QVariantList indexAttributes;
Q_FOREACH ( int index, fieldIndexes )
{
indexAttributes << f.attribute( index );
}
if ( !attributeHash.contains( indexAttributes ) )
{
// keep attributes of first feature
attributeHash.insert( indexAttributes, f.attributes() );
}
if ( f.hasGeometry() && !f.geometry().isNull() )
{
geometryHash[ indexAttributes ].append( f.geometry() );
}
}
QVariantMap QgsJoinWithLinesAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
if ( parameters.value( QStringLiteral( "SPOKES" ) ) == parameters.value( QStringLiteral( "HUBS" ) ) )
throw QgsProcessingException( QObject::tr( "Same layer given for both hubs and spokes" ) );
std::unique_ptr< QgsFeatureSource > hubSource( parameterAsSource( parameters, QStringLiteral( "HUBS" ), context ) );
std::unique_ptr< QgsFeatureSource > spokeSource( parameterAsSource( parameters, QStringLiteral( "SPOKES" ), context ) );
if ( !hubSource || !spokeSource )
return QVariantMap();
QString fieldHubName = parameterAsString( parameters, QStringLiteral( "HUB_FIELD" ), context );
int fieldHubIndex = hubSource->fields().lookupField( fieldHubName );
const QStringList hubFieldsToCopy = parameterAsFields( parameters, QStringLiteral( "HUB_FIELDS" ), context );
QString fieldSpokeName = parameterAsString( parameters, QStringLiteral( "SPOKE_FIELD" ), context );
int fieldSpokeIndex = spokeSource->fields().lookupField( fieldSpokeName );
const QStringList spokeFieldsToCopy = parameterAsFields( parameters, QStringLiteral( "SPOKE_FIELDS" ), context );
if ( fieldHubIndex < 0 || fieldSpokeIndex < 0 )
throw QgsProcessingException( QObject::tr( "Invalid ID field" ) );
QgsFields hubOutFields;
QgsAttributeList hubFieldIndices;
if ( hubFieldsToCopy.empty() )
{
hubOutFields = hubSource->fields();
for ( int i = 0; i < hubOutFields.count(); ++i )
{
hubFieldIndices << i;
}
}
else
{
for ( const QString &field : hubFieldsToCopy )
{
int index = hubSource->fields().lookupField( field );
if ( index >= 0 )
{
hubFieldIndices << index;
hubOutFields.append( hubSource->fields().at( index ) );
}
}
}
QgsAttributeList hubFields2Fetch = hubFieldIndices;
hubFields2Fetch << fieldHubIndex;
QgsFields spokeOutFields;
QgsAttributeList spokeFieldIndices;
if ( spokeFieldsToCopy.empty() )
{
spokeOutFields = spokeSource->fields();
for ( int i = 0; i < spokeOutFields.count(); ++i )
{
spokeFieldIndices << i;
}
}
else
{
for ( const QString &field : spokeFieldsToCopy )
{
int index = spokeSource->fields().lookupField( field );
if ( index >= 0 )
{
spokeFieldIndices << index;
spokeOutFields.append( spokeSource->fields().at( index ) );
}
}
}
QgsAttributeList spokeFields2Fetch = spokeFieldIndices;
spokeFields2Fetch << fieldSpokeIndex;
QgsFields fields = QgsProcessingUtils::combineFields( hubOutFields, spokeOutFields );
QgsWkbTypes::Type outType = QgsWkbTypes::LineString;
bool hasZ = false;
if ( QgsWkbTypes::hasZ( hubSource->wkbType() ) || QgsWkbTypes::hasZ( spokeSource->wkbType() ) )
{
outType = QgsWkbTypes::addZ( outType );
hasZ = true;
}
bool hasM = false;
if ( QgsWkbTypes::hasM( hubSource->wkbType() ) || QgsWkbTypes::hasM( spokeSource->wkbType() ) )
{
outType = QgsWkbTypes::addM( outType );
hasM = true;
}
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields,
outType, hubSource->sourceCrs() ) );
if ( !sink )
return QVariantMap();
auto getPointFromFeature = [hasZ, hasM]( const QgsFeature & feature )->QgsPoint
{
QgsPoint p;
if ( feature.geometry().type() == QgsWkbTypes::PointGeometry && !feature.geometry().isMultipart() )
p = *static_cast< const QgsPoint *>( feature.geometry().constGet() );
else
p = *static_cast< const QgsPoint *>( feature.geometry().pointOnSurface().constGet() );
if ( hasZ && !p.is3D() )
p.addZValue( 0 );
if ( hasM && !p.isMeasure() )
p.addMValue( 0 );
return p;
};
QgsFeatureIterator hubFeatures = hubSource->getFeatures( QgsFeatureRequest().setSubsetOfAttributes( hubFields2Fetch ) );
double step = hubSource->featureCount() > 0 ? 100.0 / hubSource->featureCount() : 1;
int i = 0;
QgsFeature hubFeature;
while ( hubFeatures.nextFeature( hubFeature ) )
{
i++;
if ( feedback->isCanceled() )
{
break;
}
feedback->setProgress( i * step );
if ( !hubFeature.hasGeometry() )
continue;
QgsPoint hubPoint = getPointFromFeature( hubFeature );
// only keep selected attributes
QgsAttributes hubAttributes;
for ( int j = 0; j < hubFeature.attributes().count(); ++j )
{
if ( !hubFieldIndices.contains( j ) )
continue;
hubAttributes << hubFeature.attribute( j );
}
QgsFeatureRequest spokeRequest = QgsFeatureRequest().setDestinationCrs( hubSource->sourceCrs(), context.transformContext() );
spokeRequest.setSubsetOfAttributes( spokeFields2Fetch );
spokeRequest.setFilterExpression( QgsExpression::createFieldEqualityExpression( fieldSpokeName, hubFeature.attribute( fieldHubIndex ) ) );
QgsFeatureIterator spokeFeatures = spokeSource->getFeatures( spokeRequest );
QgsFeature spokeFeature;
while ( spokeFeatures.nextFeature( spokeFeature ) )
{
if ( feedback->isCanceled() )
{
break;
}
if ( !spokeFeature.hasGeometry() )
continue;
QgsPoint spokePoint = getPointFromFeature( spokeFeature );
QgsGeometry line( new QgsLineString( QVector< QgsPoint >() << hubPoint << spokePoint ) );
QgsFeature outFeature;
QgsAttributes outAttributes = hubAttributes;
// only keep selected attributes
QgsAttributes spokeAttributes;
for ( int j = 0; j < spokeFeature.attributes().count(); ++j )
{
if ( !spokeFieldIndices.contains( j ) )
continue;
spokeAttributes << spokeFeature.attribute( j );
}
outAttributes.append( spokeAttributes );
outFeature.setAttributes( outAttributes );
outFeature.setGeometry( line );
sink->addFeature( outFeature, QgsFeatureSink::FastInsert );
}
}
QVariantMap outputs;
outputs.insert( QStringLiteral( "OUTPUT" ), dest );
return outputs;
}
