Skip to content

Commit be3b2c8

Browse files
alexbruyalexbruy
committedJul 30, 2018
[processing] base class for network analysis algorithms
·
ltr-3_40final-3_4_0
1 parent a6901ed commit be3b2c8

File tree

5 files changed

+249
-109
lines changed

5 files changed

+249
-109
lines changed
 

‎src/analysis/CMakeLists.txt

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -95,6 +95,7 @@ SET(QGIS_ANALYSIS_SRCS
9595
processing/qgsalgorithmvectorize.cpp
9696
processing/qgsalgorithmwedgebuffers.cpp
9797
processing/qgsalgorithmzonalhistogram.cpp
98+
processing/qgsalgorithmnetworkanalysisbase.cpp
9899

99100
processing/qgsnativealgorithms.cpp
100101
processing/qgsoverlayutils.cpp

‎src/analysis/processing/qgsalgorithmnetworkanalysisbase.cpp

Lines changed: 166 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,166 @@
1+
/***************************************************************************
2+
qgsalgorithmnetworkanalysisbase.cpp
3+
---------------------
4+
begin : July 2018
5+
copyright : (C) 2018 by Alexander Bruy
6+
email : alexander dot bruy at gmail dot com
7+
***************************************************************************/
8+
9+
/***************************************************************************
10+
* *
11+
* This program is free software; you can redistribute it and/or modify *
12+
* it under the terms of the GNU General Public License as published by *
13+
* the Free Software Foundation; either version 2 of the License, or *
14+
* (at your option) any later version. *
15+
* *
16+
***************************************************************************/
17+
18+
#include "qgsalgorithmnetworkanalysisbase.h"
19+
20+
#include "qgsgraphanalyzer.h"
21+
#include "qgsnetworkspeedstrategy.h"
22+
#include "qgsnetworkdistancestrategy.h"
23+
24+
///@cond PRIVATE
25+
26+
//
27+
// QgsNetworkAnalysisAlgorithmBase
28+
//
29+
30+
31+
QString QgsNetworkAnalysisAlgorithmBase::group() const
32+
{
33+
return QObject::tr( "Network analysis" );
34+
}
35+
36+
QString QgsNetworkAnalysisAlgorithmBase::groupId() const
37+
{
38+
return QStringLiteral( "networkanalysis" );
39+
}
40+
41+
void QgsNetworkAnalysisAlgorithmBase::addCommonParams()
42+
{
43+
addParameter( new QgsProcessingParameterFeatureSource( QStringLiteral( "INPUT" ), QObject::tr( "Vector layer representing network" ), QList< int >() << QgsProcessing::TypeVectorLine ) );
44+
addParameter( new QgsProcessingParameterEnum( QStringLiteral( "STRATEGY" ), QObject::tr( "Path type to calculate" ), QStringList() << QObject::tr( "Shortest" ) << QObject::tr( "Fastest" ), false, 0 ) );
45+
46+
std::unique_ptr< QgsProcessingParameterField > directionField = qgis::make_unique< QgsProcessingParameterField >( QStringLiteral( "DIRECTION_FIELD" ),
47+
QObject::tr( "Direction field" ), QVariant(), QStringLiteral( "INPUT" ), QgsProcessingParameterField::Any, false, true );
48+
directionField->setFlags( directionField->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
49+
addParameter( directionField.release() );
50+
51+
std::unique_ptr< QgsProcessingParameterString > forwardValue = qgis::make_unique< QgsProcessingParameterString >( QStringLiteral( "VALUE_FORWARD" ),
52+
QObject::tr( "Value for forward direction" ), QVariant(), false, true );
53+
forwardValue->setFlags( forwardValue->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
54+
addParameter( forwardValue.release() );
55+
56+
std::unique_ptr< QgsProcessingParameterString > backwardValue = qgis::make_unique< QgsProcessingParameterString >( QStringLiteral( "VALUE_BACKWARD" ),
57+
QObject::tr( "Value for backward direction" ), QVariant(), false, true );
58+
backwardValue->setFlags( backwardValue->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
59+
addParameter( backwardValue.release() );
60+
61+
std::unique_ptr< QgsProcessingParameterString > bothValue = qgis::make_unique< QgsProcessingParameterString >( QStringLiteral( "VALUE_BOTH" ),
62+
QObject::tr( "Value for both directions" ), QVariant(), false, true );
63+
bothValue->setFlags( bothValue->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
64+
addParameter( bothValue.release() );
65+
66+
std::unique_ptr< QgsProcessingParameterEnum > directionValue = qgis::make_unique< QgsProcessingParameterEnum >( QStringLiteral( "DEFAULT_DIRECTION" ),
67+
QObject::tr( "Default direction" ), QStringList() << QObject::tr( "Forward direction" ) << QObject::tr( "Backward direction" ) << QObject::tr( "Both directions" ), false, 2 );
68+
directionValue->setFlags( directionValue->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
69+
addParameter( directionValue.release() );
70+
71+
std::unique_ptr< QgsProcessingParameterField > speedField = qgis::make_unique< QgsProcessingParameterField >( QStringLiteral( "SPEED_FIELD" ),
72+
QObject::tr( "Speed field" ), QVariant(), QStringLiteral( "INPUT" ), QgsProcessingParameterField::Numeric, false, true );
73+
speedField->setFlags( speedField->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
74+
addParameter( speedField.release() );
75+
76+
std::unique_ptr< QgsProcessingParameterNumber > speed = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "DEFAULT_SPEED" ), QObject::tr( "Default speed (km/h)" ), QgsProcessingParameterNumber::Double, 50, false, 0 );
77+
speed->setFlags( speed->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
78+
addParameter( speed.release() );
79+
80+
std::unique_ptr< QgsProcessingParameterNumber > tolerance = qgis::make_unique < QgsProcessingParameterDistance >( QStringLiteral( "TOLERANCE" ), QObject::tr( "Topology tolerance" ), 0, QStringLiteral( "INPUT" ), false, 0 );
81+
tolerance->setFlags( tolerance->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
82+
addParameter( tolerance.release() );
83+
}
84+
85+
void QgsNetworkAnalysisAlgorithmBase::loadCommonParams( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
86+
{
87+
Q_UNUSED( feedback );
88+
89+
mNetwork.reset( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
90+
if ( !mNetwork )
91+
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
92+
93+
int strategy = parameterAsInt( parameters, QStringLiteral( "STRATEGY" ), context );
94+
QString directionFieldName = parameterAsString( parameters, QStringLiteral( "DIRECTION_FIELD" ), context );
95+
QString forwardValue = parameterAsString( parameters, QStringLiteral( "VALUE_FORWARD" ), context );
96+
QString backwardValue = parameterAsString( parameters, QStringLiteral( "VALUE_BACKWARD" ), context );
97+
QString bothValue = parameterAsString( parameters, QStringLiteral( "VALUE_BOTH" ), context );
98+
QgsVectorLayerDirector::Direction defaultDirection = static_cast< QgsVectorLayerDirector::Direction>( parameterAsInt( parameters, QStringLiteral( "DEFAULT_DIRECTION" ), context ) );
99+
QString speedFieldName = parameterAsString( parameters, QStringLiteral( "SPEED_FIELD" ), context );
100+
double defaultSpeed = parameterAsDouble( parameters, QStringLiteral( "DEFAULT_SPEED" ), context );
101+
double tolerance = parameterAsDouble( parameters, QStringLiteral( "TOLERANCE" ), context );
102+
103+
int directionField = -1;
104+
if ( !directionFieldName.isEmpty() )
105+
{
106+
directionField = mNetwork->fields().lookupField( directionFieldName );
107+
}
108+
109+
int speedField = -1;
110+
if ( !speedFieldName.isEmpty() )
111+
{
112+
speedField = mNetwork->fields().lookupField( speedFieldName );
113+
}
114+
115+
mDirector = new QgsVectorLayerDirector( mNetwork.get(), directionField, forwardValue, backwardValue, bothValue, defaultDirection );
116+
117+
QgsUnitTypes::DistanceUnit distanceUnits = context.project()->crs().mapUnits();
118+
mMultiplier = QgsUnitTypes::fromUnitToUnitFactor( distanceUnits, QgsUnitTypes::DistanceMeters );
119+
120+
if ( strategy )
121+
{
122+
mDirector->addStrategy( new QgsNetworkSpeedStrategy( speedField, defaultSpeed, mMultiplier * 1000.0 / 3600.0 ) );
123+
mMultiplier = 3600;
124+
}
125+
else
126+
{
127+
mDirector->addStrategy( new QgsNetworkDistanceStrategy() );
128+
}
129+
130+
mBuilder = qgis::make_unique< QgsGraphBuilder >( mNetwork->sourceCrs(), true, tolerance );
131+
}
132+
133+
//~ QVector< QgsPointXY > QgsNetworkAnalysisAlgorithmBase::loadPoints( QgsFeatureSource *source, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
134+
//~ {
135+
//~ feedback.pushInfo( QObject::tr( "Loading points…" ) );
136+
137+
//~ QVector< QgsPointXY > points;
138+
//~ QgsFeature feat;
139+
//~ int i = 0;
140+
//~ double step = source->featureCount() > 0 ? 100.0 / source->featureCount() : 0;
141+
//~ QgsFeatureIterator features = source->getFeatures( QgsFeatureRequest().setDestinationCrs( mNetwork->sourceCrs(), context.transformContext() ) );
142+
143+
//~ while ( features.nextFeature( feat ) )
144+
//~ {
145+
//~ i++;
146+
//~ if ( feedback->isCanceled() )
147+
//~ {
148+
//~ break;
149+
//~ }
150+
151+
//~ feedback->setProgress( i * step );
152+
//~ if ( !feat.hasGeometry() )
153+
//~ continue;
154+
155+
//~ QgsGeometry geom = feat.geometry();
156+
//~ QgsAbstractGeometry::vertex_iterator it = geom.vertices_begin();
157+
//~ while ( it != geom.vertices_end() )
158+
//~ {
159+
//~ points.push_back( QgsPointXY( it ) )
160+
//~ }
161+
//~ }
162+
163+
//~ return points
164+
//~ }
165+
166+
///@endcond

‎src/analysis/processing/qgsalgorithmnetworkanalysisbase.h

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
/***************************************************************************
2+
qgsalgorithmnetworkanalysisbase.h
3+
---------------------
4+
begin : July 2018
5+
copyright : (C) 2018 by Alexander Bruy
6+
email : alexander dot bruy at gmail dot com
7+
***************************************************************************/
8+
9+
/***************************************************************************
10+
* *
11+
* This program is free software; you can redistribute it and/or modify *
12+
* it under the terms of the GNU General Public License as published by *
13+
* the Free Software Foundation; either version 2 of the License, or *
14+
* (at your option) any later version. *
15+
* *
16+
***************************************************************************/
17+
18+
#ifndef QGSALGORITHMNETWORKANALYSISBASE_H
19+
#define QGSALGORITHMNETWORKANALYSISBASE_H
20+
21+
#define SIP_NO_FILE
22+
23+
#include "qgis.h"
24+
#include "qgsprocessingalgorithm.h"
25+
26+
#include "qgsgraph.h"
27+
#include "qgsgraphbuilder.h"
28+
#include "qgsvectorlayerdirector.h"
29+
30+
///@cond PRIVATE
31+
32+
/**
33+
* Base class for networkanalysis algorithms.
34+
*/
35+
class QgsNetworkAnalysisAlgorithmBase : public QgsProcessingAlgorithm
36+
{
37+
public:
38+
39+
QString group() const final;
40+
QString groupId() const final;
41+
QIcon icon() const override { return QgsApplication::getThemeIcon( QStringLiteral( "/algorithms/mAlgorithmNetworkAnalysis.svg" ) ); }
42+
QString svgIconPath() const override { return QgsApplication::iconPath( QStringLiteral( "/algorithms/mAlgorithmNetworkAnalysis.svg" ) ); }
43+
44+
protected:
45+
46+
/**
47+
* Adds common algorithm parameters.
48+
*/
49+
void addCommonParams();
50+
51+
/**
52+
* Populates common parameters with values.
53+
*/
54+
void loadCommonParams( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback );
55+
56+
/**
57+
* Loads point from the feature source for further processing.
58+
*/
59+
//~ void loadPoints( QgsFeatureSource *source, QgsProcessingContext &context, QgsProcessingFeedback *feedback );
60+
61+
std::unique_ptr< QgsFeatureSource > mNetwork;
62+
QgsVectorLayerDirector *mDirector = nullptr;
63+
std::unique_ptr< QgsGraphBuilder > mBuilder;
64+
std::unique_ptr< QgsGraph > mGraph;
65+
double mMultiplier = 1;
66+
};
67+
68+
///@endcond PRIVATE
69+
70+
#endif // QGSALGORITHMNETWORKANALYSISBASE_H
71+

‎src/analysis/processing/qgsalgorithmshortestpathpointtopoint.cpp

Lines changed: 9 additions & 103 deletions
Original file line numberDiff line numberDiff line change
@@ -17,12 +17,7 @@
1717

1818
#include "qgsalgorithmshortestpathpointtopoint.h"
1919

20-
#include "qgsgraph.h"
21-
#include "qgsgraphbuilder.h"
2220
#include "qgsgraphanalyzer.h"
23-
#include "qgsvectorlayerdirector.h"
24-
#include "qgsnetworkspeedstrategy.h"
25-
#include "qgsnetworkdistancestrategy.h"
2621

2722
///@cond PRIVATE
2823

@@ -41,16 +36,6 @@ QStringList QgsShortestPathPointToPointAlgorithm::tags() const
4136
return QObject::tr( "network,path,shortest,fastest" ).split( ',' );
4237
}
4338

44-
QString QgsShortestPathPointToPointAlgorithm::group() const
45-
{
46-
return QObject::tr( "Network analysis" );
47-
}
48-
49-
QString QgsShortestPathPointToPointAlgorithm::groupId() const
50-
{
51-
return QStringLiteral( "networkanalysis" );
52-
}
53-
5439
QString QgsShortestPathPointToPointAlgorithm::shortHelpString() const
5540
{
5641
return QObject::tr( "This algorithm computes optimal (shortest or fastest) route between given start and end points." );
@@ -63,118 +48,39 @@ QgsShortestPathPointToPointAlgorithm *QgsShortestPathPointToPointAlgorithm::crea
6348

6449
void QgsShortestPathPointToPointAlgorithm::initAlgorithm( const QVariantMap & )
6550
{
66-
addParameter( new QgsProcessingParameterFeatureSource( QStringLiteral( "INPUT" ), QObject::tr( "Vector layer representing network" ), QList< int >() << QgsProcessing::TypeVectorLine ) );
51+
addCommonParams();
6752
addParameter( new QgsProcessingParameterPoint( QStringLiteral( "START_POINT" ), QObject::tr( "Start point" ) ) );
6853
addParameter( new QgsProcessingParameterPoint( QStringLiteral( "END_POINT" ), QObject::tr( "End point" ) ) );
69-
addParameter( new QgsProcessingParameterEnum( QStringLiteral( "STRATEGY" ), QObject::tr( "Path type to calculate" ), QStringList() << QObject::tr( "Shortest" ) << QObject::tr( "Fastest" ), false, 0 ) );
70-
71-
std::unique_ptr< QgsProcessingParameterField > directionField = qgis::make_unique< QgsProcessingParameterField >( QStringLiteral( "DIRECTION_FIELD" ),
72-
QObject::tr( "Direction field" ), QVariant(), QStringLiteral( "INPUT" ), QgsProcessingParameterField::Any, false, true );
73-
directionField->setFlags( directionField->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
74-
addParameter( directionField.release() );
75-
76-
std::unique_ptr< QgsProcessingParameterString > forwardValue = qgis::make_unique< QgsProcessingParameterString >( QStringLiteral( "VALUE_FORWARD" ),
77-
QObject::tr( "Value for forward direction" ), QVariant(), false, true );
78-
forwardValue->setFlags( forwardValue->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
79-
addParameter( forwardValue.release() );
80-
81-
std::unique_ptr< QgsProcessingParameterString > backwardValue = qgis::make_unique< QgsProcessingParameterString >( QStringLiteral( "VALUE_BACKWARD" ),
82-
QObject::tr( "Value for backward direction" ), QVariant(), false, true );
83-
backwardValue->setFlags( backwardValue->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
84-
addParameter( backwardValue.release() );
85-
86-
std::unique_ptr< QgsProcessingParameterString > bothValue = qgis::make_unique< QgsProcessingParameterString >( QStringLiteral( "VALUE_BOTH" ),
87-
QObject::tr( "Value for both directions" ), QVariant(), false, true );
88-
bothValue->setFlags( bothValue->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
89-
addParameter( bothValue.release() );
90-
91-
std::unique_ptr< QgsProcessingParameterEnum > directionValue = qgis::make_unique< QgsProcessingParameterEnum >( QStringLiteral( "DEFAULT_DIRECTION" ),
92-
QObject::tr( "Default direction" ), QStringList() << QObject::tr( "Forward direction" ) << QObject::tr( "Backward direction" ) << QObject::tr( "Both directions" ), false, 2 );
93-
directionValue->setFlags( directionValue->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
94-
addParameter( directionValue.release() );
95-
96-
std::unique_ptr< QgsProcessingParameterField > speedField = qgis::make_unique< QgsProcessingParameterField >( QStringLiteral( "SPEED_FIELD" ),
97-
QObject::tr( "Speed field" ), QVariant(), QStringLiteral( "INPUT" ), QgsProcessingParameterField::Numeric, false, true );
98-
speedField->setFlags( speedField->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
99-
addParameter( speedField.release() );
100-
101-
std::unique_ptr< QgsProcessingParameterNumber > speed = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "DEFAULT_SPEED" ), QObject::tr( "Default speed (km/h)" ), QgsProcessingParameterNumber::Double, 50, false, 0 );
102-
speed->setFlags( speed->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
103-
addParameter( speed.release() );
104-
105-
std::unique_ptr< QgsProcessingParameterNumber > tolerance = qgis::make_unique < QgsProcessingParameterDistance >( QStringLiteral( "TOLERANCE" ), QObject::tr( "Topology tolerance" ), 0, QStringLiteral( "INPUT" ), false, 0 );
106-
tolerance->setFlags( tolerance->flags() | QgsProcessingParameterDefinition::FlagAdvanced );
107-
addParameter( tolerance.release() );
10854

10955
addParameter( new QgsProcessingParameterFeatureSink( QStringLiteral( "OUTPUT" ), QObject::tr( "Shortest path" ), QgsProcessing::TypeVectorLine ) );
11056
addOutput( new QgsProcessingOutputNumber( QStringLiteral( "TRAVEL_COST" ), QObject::tr( "Travel cost" ) ) );
11157
}
11258

11359
QVariantMap QgsShortestPathPointToPointAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
11460
{
115-
std::unique_ptr< QgsFeatureSource > source( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
116-
if ( !source )
117-
throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
61+
loadCommonParams( parameters, context, feedback );
11862

11963
QgsFields fields;
12064
fields.append( QgsField( QStringLiteral( "start" ), QVariant::String ) );
12165
fields.append( QgsField( QStringLiteral( "end" ), QVariant::String ) );
12266
fields.append( QgsField( QStringLiteral( "cost" ), QVariant::Double ) );
12367

12468
QString dest;
125-
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, QgsWkbTypes::LineString, source->sourceCrs() ) );
69+
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, QgsWkbTypes::LineString, mNetwork->sourceCrs() ) );
12670
if ( !sink )
12771
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
12872

129-
QgsPointXY startPoint = parameterAsPoint( parameters, QStringLiteral( "START_POINT" ), context, source->sourceCrs() );
130-
QgsPointXY endPoint = parameterAsPoint( parameters, QStringLiteral( "END_POINT" ), context, source->sourceCrs() );
131-
int strategy = parameterAsInt( parameters, QStringLiteral( "STRATEGY" ), context );
132-
QString directionFieldName = parameterAsString( parameters, QStringLiteral( "DIRECTION_FIELD" ), context );
133-
QString forwardValue = parameterAsString( parameters, QStringLiteral( "VALUE_FORWARD" ), context );
134-
QString backwardValue = parameterAsString( parameters, QStringLiteral( "VALUE_BACKWARD" ), context );
135-
QString bothValue = parameterAsString( parameters, QStringLiteral( "VALUE_BOTH" ), context );
136-
QgsVectorLayerDirector::Direction defaultDirection = static_cast< QgsVectorLayerDirector::Direction>( parameterAsInt( parameters, QStringLiteral( "DEFAULT_DIRECTION" ), context ) );
137-
QString speedFieldName = parameterAsString( parameters, QStringLiteral( "SPEED_FIELD" ), context );
138-
double defaultSpeed = parameterAsDouble( parameters, QStringLiteral( "DEFAULT_SPEED" ), context );
139-
double tolerance = parameterAsDouble( parameters, QStringLiteral( "TOLERANCE" ), context );
140-
141-
int directionIndex = -1;
142-
if ( !directionFieldName.isEmpty() )
143-
{
144-
directionIndex = source->fields().lookupField( directionFieldName );
145-
}
146-
147-
int speedIndex = -1;
148-
if ( !speedFieldName.isEmpty() )
149-
{
150-
speedIndex = source->fields().lookupField( speedFieldName );
151-
}
152-
153-
QgsVectorLayerDirector *director = new QgsVectorLayerDirector( source.get(), directionIndex, forwardValue, backwardValue, bothValue, defaultDirection );
154-
155-
QgsUnitTypes::DistanceUnit distanceUnits = context.project()->crs().mapUnits();
156-
double multiplier = QgsUnitTypes::fromUnitToUnitFactor( distanceUnits, QgsUnitTypes::DistanceMeters );
157-
158-
if ( strategy )
159-
{
160-
director->addStrategy( new QgsNetworkSpeedStrategy( speedIndex, defaultSpeed, multiplier * 1000.0 / 3600.0 ) );
161-
multiplier = 3600;
162-
}
163-
else
164-
{
165-
director->addStrategy( new QgsNetworkDistanceStrategy() );
166-
}
167-
168-
QgsGraphBuilder builder( source->sourceCrs(), true, tolerance );
73+
QgsPointXY startPoint = parameterAsPoint( parameters, QStringLiteral( "START_POINT" ), context, mNetwork->sourceCrs() );
74+
QgsPointXY endPoint = parameterAsPoint( parameters, QStringLiteral( "END_POINT" ), context, mNetwork->sourceCrs() );
16975

17076
feedback->pushInfo( QObject::tr( "Building graph…" ) );
17177
QVector< QgsPointXY > points;
17278
points << startPoint << endPoint;
17379
QVector< QgsPointXY > snappedPoints;
174-
director->makeGraph( &builder, points, snappedPoints, feedback );
80+
mDirector->makeGraph( mBuilder.get(), points, snappedPoints, feedback );
17581

17682
feedback->pushInfo( QObject::tr( "Calculating shortest path…" ) );
177-
QgsGraph *graph = builder.graph();
83+
QgsGraph *graph = mBuilder->graph();
17884
int idxStart = graph->findVertex( snappedPoints[0] );
17985
int idxEnd = graph->findVertex( snappedPoints[1] );
18086

@@ -201,14 +107,14 @@ QVariantMap QgsShortestPathPointToPointAlgorithm::processAlgorithm( const QVaria
201107
QgsFeature feat;
202108
feat.setFields( fields );
203109
QgsAttributes attributes;
204-
attributes << startPoint.toString() << endPoint.toString() << cost / multiplier;
110+
attributes << startPoint.toString() << endPoint.toString() << cost / mMultiplier;
205111
feat.setGeometry( geom );
206112
feat.setAttributes( attributes );
207113
sink->addFeature( feat, QgsFeatureSink::FastInsert );
208114

209115
QVariantMap outputs;
210116
outputs.insert( QStringLiteral( "OUTPUT" ), dest );
211-
outputs.insert( QStringLiteral( "TRAVEL_COST" ), cost / multiplier );
117+
outputs.insert( QStringLiteral( "TRAVEL_COST" ), cost / mMultiplier );
212118
return outputs;
213119
}
214120

‎src/analysis/processing/qgsalgorithmshortestpathpointtopoint.h

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -21,27 +21,23 @@
2121
#define SIP_NO_FILE
2222

2323
#include "qgis.h"
24-
#include "qgsprocessingalgorithm.h"
24+
#include "qgsalgorithmnetworkanalysisbase.h"
2525

2626
///@cond PRIVATE
2727

2828
/**
2929
* Native shortest path (point to point) algorithm.
3030
*/
31-
class QgsShortestPathPointToPointAlgorithm : public QgsProcessingAlgorithm
31+
class QgsShortestPathPointToPointAlgorithm : public QgsNetworkAnalysisAlgorithmBase
3232
{
3333

3434
public:
3535

3636
QgsShortestPathPointToPointAlgorithm() = default;
3737
void initAlgorithm( const QVariantMap &configuration = QVariantMap() ) override;
38-
QIcon icon() const override { return QgsApplication::getThemeIcon( QStringLiteral( "/algorithms/mAlgorithmNetworkAnalysis.svg" ) ); }
39-
QString svgIconPath() const override { return QgsApplication::iconPath( QStringLiteral( "/algorithms/mAlgorithmNetworkAnalysis.svg" ) ); }
4038
QString name() const override;
4139
QString displayName() const override;
4240
QStringList tags() const override;
43-
QString group() const override;
44-
QString groupId() const override;
4541
QString shortHelpString() const override;
4642
QgsShortestPathPointToPointAlgorithm *createInstance() const override SIP_FACTORY;
4743

0 commit comments

Comments
 (0)
Please sign in to comment.