sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-12-15 00:07:25 -05:00
Code Issues Packages Projects Releases Wiki Activity

[processing] port sum line length algorithm to C++

Browse Source
This commit is contained in:
Alexander Bruy 2019-11-28 14:43:13 +02:00
parent eeaffb9d79
commit 9615306f44
8 changed files with 291 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
python/plugins/processing/algs/help/qgis.yaml
View File

@ -438,11 +438,6 @@ qgis:splitvectorlayer: >
qgis:statisticsbycategories: >
This algorithm calculates statistics of fields depending on a parent class.
qgis:sumlinelengths: >
This algorithm takes a polygon layer and a line layer and measures the total length of lines and the total number of them that cross each polygon.
The resulting layer has the same features as the input polygon layer, but with two additional attributes containing the length and count of the lines across each polygon. The names of these two fields can be configured in the algorithm parameters.
qgis:texttofloat: >
This algorithm modifies the type of a given attribute in a vector layer, converting a text attribute containing numeric strings into a numeric attribute.

2
python/plugins/processing/algs/qgis/QgisAlgorithmProvider.py
View File

@ -98,7 +98,6 @@ from .SpatialiteExecuteSQL import SpatialiteExecuteSQL
from .SpatialJoin import SpatialJoin
from .SpatialJoinSummary import SpatialJoinSummary
from .StatisticsByCategories import StatisticsByCategories
from .SumLines import SumLines
from .TextToFloat import TextToFloat
from .TilesXYZ import TilesXYZAlgorithmDirectory, TilesXYZAlgorithmMBTiles
from .TinInterpolation import TinInterpolation
@ -193,7 +192,6 @@ class QgisAlgorithmProvider(QgsProcessingProvider):
SpatialJoin(),
SpatialJoinSummary(),
StatisticsByCategories(),
SumLines(),
TextToFloat(),
TilesXYZAlgorithmDirectory(),
TilesXYZAlgorithmMBTiles(),

168
python/plugins/processing/algs/qgis/SumLines.py
View File

@ -1,168 +0,0 @@
# -*- coding: utf-8 -*-
"""
***************************************************************************
SumLines.py
---------------------
Date : August 2012
Copyright : (C) 2012 by Victor Olaya
Email : volayaf at gmail 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. *
* *
***************************************************************************
"""
__author__ = 'Victor Olaya'
__date__ = 'August 2012'
__copyright__ = '(C) 2012, Victor Olaya'
import os
from qgis.PyQt.QtGui import QIcon
from qgis.PyQt.QtCore import QVariant
from qgis.core import (QgsApplication,
QgsFeature,
QgsFeatureSink,
QgsField,
QgsGeometry,
QgsFeatureRequest,
QgsDistanceArea,
QgsProject,
QgsProcessing,
QgsProcessingException,
QgsProcessingParameterString,
QgsProcessingParameterFeatureSource,
QgsProcessingParameterFeatureSink,
QgsSpatialIndex)
from processing.algs.qgis.QgisAlgorithm import QgisAlgorithm
pluginPath = os.path.split(os.path.split(os.path.dirname(__file__))[0])[0]
class SumLines(QgisAlgorithm):
LINES = 'LINES'
POLYGONS = 'POLYGONS'
LEN_FIELD = 'LEN_FIELD'
COUNT_FIELD = 'COUNT_FIELD'
OUTPUT = 'OUTPUT'
def icon(self):
return QgsApplication.getThemeIcon("/algorithms/mAlgorithmSumLengthLines.svg")
def svgIconPath(self):
return QgsApplication.iconPath("/algorithms/mAlgorithmSumLengthLines.svg")
def group(self):
return self.tr('Vector analysis')
def groupId(self):
return 'vectoranalysis'
def __init__(self):
super().__init__()
def initAlgorithm(self, config=None):
self.addParameter(QgsProcessingParameterFeatureSource(self.LINES,
self.tr('Lines'), [QgsProcessing.TypeVectorLine]))
self.addParameter(QgsProcessingParameterFeatureSource(self.POLYGONS,
self.tr('Polygons'), [QgsProcessing.TypeVectorPolygon]))
self.addParameter(QgsProcessingParameterString(self.LEN_FIELD,
self.tr('Lines length field name'), defaultValue='LENGTH'))
self.addParameter(QgsProcessingParameterString(self.COUNT_FIELD,
self.tr('Lines count field name'), defaultValue='COUNT'))
self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT, self.tr('Line length'), QgsProcessing.TypeVectorPolygon))
def name(self):
return 'sumlinelengths'
def displayName(self):
return self.tr('Sum line lengths')
def processAlgorithm(self, parameters, context, feedback):
line_source = self.parameterAsSource(parameters, self.LINES, context)
if line_source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.LINES))
poly_source = self.parameterAsSource(parameters, self.POLYGONS, context)
if poly_source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.POLYGONS))
length_field_name = self.parameterAsString(parameters, self.LEN_FIELD, context)
count_field_name = self.parameterAsString(parameters, self.COUNT_FIELD, context)
fields = poly_source.fields()
if fields.lookupField(length_field_name) < 0:
fields.append(QgsField(length_field_name, QVariant.Double))
length_field_index = fields.lookupField(length_field_name)
if fields.lookupField(count_field_name) < 0:
fields.append(QgsField(count_field_name, QVariant.Int))
count_field_index = fields.lookupField(count_field_name)
(sink, dest_id) = self.parameterAsSink(parameters, self.OUTPUT, context,
fields, poly_source.wkbType(), poly_source.sourceCrs())
if sink is None:
raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT))
spatialIndex = QgsSpatialIndex(line_source.getFeatures(
QgsFeatureRequest().setSubsetOfAttributes([]).setDestinationCrs(poly_source.sourceCrs(), context.transformContext())), feedback)
distArea = QgsDistanceArea()
distArea.setSourceCrs(poly_source.sourceCrs(), context.transformContext())
distArea.setEllipsoid(context.project().ellipsoid())
features = poly_source.getFeatures()
total = 100.0 / poly_source.featureCount() if poly_source.featureCount() else 0
for current, poly_feature in enumerate(features):
if feedback.isCanceled():
break
output_feature = QgsFeature()
count = 0
length = 0
if poly_feature.hasGeometry():
poly_geom = poly_feature.geometry()
has_intersections = False
lines = spatialIndex.intersects(poly_geom.boundingBox())
engine = None
if len(lines) > 0:
has_intersections = True
# use prepared geometries for faster intersection tests
engine = QgsGeometry.createGeometryEngine(poly_geom.constGet())
engine.prepareGeometry()
if has_intersections:
request = QgsFeatureRequest().setFilterFids(lines).setSubsetOfAttributes([]).setDestinationCrs(poly_source.sourceCrs(), context.transformContext())
for line_feature in line_source.getFeatures(request):
if feedback.isCanceled():
break
if engine.intersects(line_feature.geometry().constGet()):
outGeom = poly_geom.intersection(line_feature.geometry())
length += distArea.measureLength(outGeom)
count += 1
output_feature.setGeometry(poly_geom)
attrs = poly_feature.attributes()
if length_field_index == len(attrs):
attrs.append(length)
else:
attrs[length_field_index] = length
if count_field_index == len(attrs):
attrs.append(count)
else:
attrs[count_field_index] = count
output_feature.setAttributes(attrs)
sink.addFeature(output_feature, QgsFeatureSink.FastInsert)
feedback.setProgress(int(current * total))
return {self.OUTPUT: dest_id}

2
python/plugins/processing/tests/testdata/qgis_algorithm_tests.yaml vendored
View File

@ -1794,7 +1794,7 @@ tests:
name: expected/line_intersection_collection.gml
type: vector
- algorithm: qgis:sumlinelengths
- algorithm: native:sumlinelengths
name: Sum line lengths
params:
COUNT_FIELD: line_count

1
src/analysis/CMakeLists.txt
View File

@ -133,6 +133,7 @@ SET(QGIS_ANALYSIS_SRCS
processing/qgsalgorithmstringconcatenation.cpp
processing/qgsalgorithmswapxy.cpp
processing/qgsalgorithmsubdivide.cpp
processing/qgsalgorithmsumlinelength.cpp
processing/qgsalgorithmsymmetricaldifference.cpp
processing/qgsalgorithmtaperedbuffer.cpp
processing/qgsalgorithmtransect.cpp

214
src/analysis/processing/qgsalgorithmsumlinelength.cpp Normal file
View File

@ -0,0 +1,214 @@
/***************************************************************************
qgsalgorithmsumlinelength.cpp
---------------------
begin : November 2019
copyright : (C) 2019 by Alexander Bruy
email : alexander dot bruy at gmail 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 "qgsalgorithmsumlinelength.h"
#include "qgsprocessing.h"
#include "qgsgeometryengine.h"
#include "qgsvectorlayer.h"
#include "qgsapplication.h"
///@cond PRIVATE
QString QgsSumLineLengthAlgorithm::name() const
{
return QStringLiteral( "sumlinelengths" );
}
QString QgsSumLineLengthAlgorithm::displayName() const
{
return QObject::tr( "Sum line lengths" );
}
QStringList QgsSumLineLengthAlgorithm::tags() const
{
return QObject::tr( "line,intersects,intersecting,sum,length,count" ).split( ',' );
}
QString QgsSumLineLengthAlgorithm::svgIconPath() const
{
return QgsApplication::iconPath( QStringLiteral( "/algorithms/mAlgorithmSumLengthLines.svg" ) );
}
QIcon QgsSumLineLengthAlgorithm::icon() const
{
return QgsApplication::getThemeIcon( QStringLiteral( "/algorithms/mAlgorithmSumLengthLines.svg" ) );
}
QString QgsSumLineLengthAlgorithm::group() const
{
return QObject::tr( "Vector analysis" );
}
QString QgsSumLineLengthAlgorithm::groupId() const
{
return QStringLiteral( "vectoranalysis" );
}
QString QgsSumLineLengthAlgorithm::shortHelpString() const
{
return QObject::tr( "This algorithm takes a polygon layer and a line layer and "
"measures the total length of lines and the total number of "
"them that cross each polygon.\n\n"
"The resulting layer has the same features as the input polygon "
"layer, but with two additional attributes containing the length "
"and count of the lines across each polygon. The names of these "
"two fields can be configured in the algorithm parameters." );
}
QgsSumLineLengthAlgorithm *QgsSumLineLengthAlgorithm::createInstance() const
{
return new QgsSumLineLengthAlgorithm();
}
QList<int> QgsSumLineLengthAlgorithm::inputLayerTypes() const
{
return QList< int >() << QgsProcessing::TypeVectorPolygon;
}
QgsProcessing::SourceType QgsSumLineLengthAlgorithm::outputLayerType() const
{
return QgsProcessing::TypeVectorPolygon;
}
QgsCoordinateReferenceSystem QgsSumLineLengthAlgorithm::outputCrs( const QgsCoordinateReferenceSystem &inputCrs ) const
{
mCrs = inputCrs;
return mCrs;
}
QString QgsSumLineLengthAlgorithm::inputParameterName() const
{
return QStringLiteral( "POLYGONS" );
}
QString QgsSumLineLengthAlgorithm::inputParameterDescription() const
{
return QObject::tr( "Polygons" );
}
QString QgsSumLineLengthAlgorithm::outputName() const
{
return QObject::tr( "Line length" );
}
void QgsSumLineLengthAlgorithm::initParameters( const QVariantMap & )
{
addParameter( new QgsProcessingParameterFeatureSource( QStringLiteral( "LINES" ),
QObject::tr( "Lines" ), QList< int > () << QgsProcessing::TypeVectorLine ) );
addParameter( new QgsProcessingParameterString( QStringLiteral( "LEN_FIELD" ),
QObject::tr( "Lines length field name" ), QStringLiteral( "LENGTH" ) ) );
addParameter( new QgsProcessingParameterString( QStringLiteral( "COUNT_FIELD" ),
QObject::tr( "Lines count field name" ), QStringLiteral( "COUNT" ) ) );
}
bool QgsSumLineLengthAlgorithm::prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
mLengthFieldName = parameterAsString( parameters, QStringLiteral( "LEN_FIELD" ), context );
mCountFieldName = parameterAsString( parameters, QStringLiteral( "COUNT_FIELD" ), context );
mLinesSource.reset( parameterAsSource( parameters, QStringLiteral( "LINES" ), context ) );
if ( !mLinesSource )
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "LINES" ) ) );
if ( mLinesSource->hasSpatialIndex() == QgsFeatureSource::SpatialIndexNotPresent )
feedback->reportError( QObject::tr( "No spatial index exists for lines layer, performance will be severely degraded" ) );
return true;
}
QgsFields QgsSumLineLengthAlgorithm::outputFields( const QgsFields &inputFields ) const
{
QgsFields outFields = inputFields;
mLengthFieldIndex = inputFields.lookupField( mLengthFieldName );
if ( mLengthFieldIndex < 0 )
outFields.append( QgsField( mLengthFieldName, QVariant::Double ) );
mCountFieldIndex = inputFields.lookupField( mCountFieldName );
if ( mCountFieldIndex < 0 )
outFields.append( QgsField( mCountFieldName, QVariant::Double ) );
mFields = outFields;
return outFields;
}
QgsFeatureList QgsSumLineLengthAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
QgsFeature outputFeature = feature;
if ( !feature.hasGeometry() )
{
QgsAttributes attrs = feature.attributes();
if ( mLengthFieldIndex < 0 )
attrs.append( 0 );
else
attrs[mLengthFieldIndex] = 0;
if ( mCountFieldIndex < 0 )
attrs.append( 0 );
else
attrs[mCountFieldIndex] = 0;
outputFeature.setAttributes( attrs );
return QList< QgsFeature > () << outputFeature;
}
else
{
const QgsGeometry polyGeom = feature.geometry();
std::unique_ptr< QgsGeometryEngine > engine( QgsGeometry::createGeometryEngine( polyGeom.constGet() ) );
engine->prepareGeometry();
QgsDistanceArea da;
da.setSourceCrs( mCrs, context.transformContext() );
da.setEllipsoid( context.project()->ellipsoid() );
QgsFeatureRequest req = QgsFeatureRequest().setFilterRect( polyGeom.boundingBox() ).setDestinationCrs( mCrs, context.transformContext() );
req.setSubsetOfAttributes( QList< int >() );
QgsFeatureIterator it = mLinesSource->getFeatures( req );
double count = 0;
double length = 0;
QgsFeature lineFeature;
while ( it.nextFeature( lineFeature ) )
{
if ( feedback->isCanceled() )
break;
if ( engine->intersects( lineFeature.geometry().constGet() ) )
{
QgsGeometry outGeom = polyGeom.intersection( lineFeature.geometry() );
length += da.measureLength( outGeom );
count++;
}
}
QgsAttributes attrs = feature.attributes();
if ( mLengthFieldIndex < 0 )
attrs.append( length );
else
attrs[mLengthFieldIndex] = length;
if ( mCountFieldIndex < 0 )
attrs.append( count );
else
attrs[mCountFieldIndex] = count;
outputFeature.setAttributes( attrs );
return QList< QgsFeature >() << outputFeature;
}
}
///@endcond

73
src/analysis/processing/qgsalgorithmsumlinelength.h Normal file
View File

@ -0,0 +1,73 @@
/***************************************************************************
qgsalgorithmsumlinelength.h
---------------------
begin : November 2019
copyright : (C) 2019 by Alexander Bruy
email : alexander dot bruy at gmail 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 QGSALGORITHMSUMLINELENGTH_H
#define QGSALGORITHMSUMLINELENGTH_H
#define SIP_NO_FILE
#include "qgis.h"
#include "qgsprocessingalgorithm.h"
///@cond PRIVATE
/**
* Native sum line length algorithm
*/
class QgsSumLineLengthAlgorithm : public QgsProcessingFeatureBasedAlgorithm
{
public:
QgsSumLineLengthAlgorithm() = default;
QString name() const override;
QString displayName() const override;
QStringList tags() const override;
QString svgIconPath() const override;
QIcon icon() const override;
QString group() const override;
QString groupId() const override;
QString shortHelpString() const override;
QgsSumLineLengthAlgorithm *createInstance() const override SIP_FACTORY;
void initParameters( const QVariantMap &configuration = QVariantMap() ) override;
QList<int> inputLayerTypes() const override;
QgsProcessing::SourceType outputLayerType() const override;
QgsCoordinateReferenceSystem outputCrs( const QgsCoordinateReferenceSystem &inputCrs ) const override;
protected:
QString inputParameterName() const override;
QString inputParameterDescription() const override;
QString outputName() const override;
bool prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) override;
QgsFeatureList processFeature( const QgsFeature &feature, QgsProcessingContext &context, QgsProcessingFeedback *feedback ) override;
QgsFields outputFields( const QgsFields &inputFields ) const override;
private:
QString mLengthFieldName;
QString mCountFieldName;
mutable int mLengthFieldIndex = -1;
mutable int mCountFieldIndex = -1;
mutable QgsFields mFields;
mutable QgsCoordinateReferenceSystem mCrs;
std::unique_ptr< QgsProcessingFeatureSource > mLinesSource;
};
///@endcond PRIVATE
#endif // QGSALGORITHMSUMLINELENGTH_H

2
src/analysis/processing/qgsnativealgorithms.cpp
View File

@ -126,6 +126,7 @@
#include "qgsalgorithmsplitfeaturesbyattributecharacter.h"
#include "qgsalgorithmstringconcatenation.h"
#include "qgsalgorithmsubdivide.h"
#include "qgsalgorithmsumlinelength.h"
#include "qgsalgorithmswapxy.h"
#include "qgsalgorithmsymmetricaldifference.h"
#include "qgsalgorithmtaperedbuffer.h"
@ -308,6 +309,7 @@ void QgsNativeAlgorithms::loadAlgorithms()
addAlgorithm( new QgsStringConcatenationAlgorithm() );
addAlgorithm( new QgsStyleFromProjectAlgorithm() );
addAlgorithm( new QgsSubdivideAlgorithm() );
addAlgorithm( new QgsSumLineLengthAlgorithm() );
addAlgorithm( new QgsSwapXYAlgorithm() );
addAlgorithm( new QgsSymmetricalDifferenceAlgorithm() );
addAlgorithm( new QgsTaperedBufferAlgorithm() );