Skip to content

Commit 5986444

Browse files
nyalldawsonnyalldawson
committedFeb 26, 2018
[processing] Support dynamic properties for all native c++ algorithms
·
ltr-3_40final-3_2_0
1 parent 7f92743 commit 5986444

13 files changed

+333
-67
lines changed
 

‎src/analysis/processing/qgsalgorithmremoveduplicatevertices.cpp

+32-7
Original file line numberDiff line numberDiff line change
@@ -70,27 +70,52 @@ QgsAlgorithmRemoveDuplicateVertices *QgsAlgorithmRemoveDuplicateVertices::create
7070

7171
void QgsAlgorithmRemoveDuplicateVertices::initParameters( const QVariantMap & )
7272
{
73-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "TOLERANCE" ),
74-
QObject::tr( "Tolerance" ), QgsProcessingParameterNumber::Double,
75-
0.000001, false, 0, 10000000.0 ) );
76-
addParameter( new QgsProcessingParameterBoolean( QStringLiteral( "USE_Z_VALUE" ),
77-
QObject::tr( "Use Z Value" ), false ) );
73+
std::unique_ptr< QgsProcessingParameterNumber> tolerance = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "TOLERANCE" ),
74+
QObject::tr( "Tolerance" ), QgsProcessingParameterNumber::Double,
75+
0.000001, false, 0, 10000000.0 );
76+
tolerance->setIsDynamic( true );
77+
tolerance->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "Tolerance" ), QObject::tr( "Tolerance distance" ), QgsPropertyDefinition::DoublePositive ) );
78+
tolerance->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
79+
addParameter( tolerance.release() );
80+
81+
std::unique_ptr< QgsProcessingParameterBoolean > useZ = qgis::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "USE_Z_VALUE" ),
82+
QObject::tr( "Use Z Value" ), false );
83+
useZ->setIsDynamic( true );
84+
useZ->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "UseZ" ), QObject::tr( "Use Z Value" ), QgsPropertyDefinition::Boolean ) );
85+
useZ->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
86+
addParameter( useZ.release() );
7887
}
7988

8089
bool QgsAlgorithmRemoveDuplicateVertices::prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback * )
8190
{
8291
mTolerance = parameterAsDouble( parameters, QStringLiteral( "TOLERANCE" ), context );
92+
mDynamicTolerance = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "TOLERANCE" ) );
93+
if ( mDynamicTolerance )
94+
mToleranceProperty = parameters.value( QStringLiteral( "TOLERANCE" ) ).value< QgsProperty >();
95+
8396
mUseZValues = parameterAsBool( parameters, QStringLiteral( "USE_Z_VALUE" ), context );
97+
mDynamicUseZ = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "USE_Z_VALUE" ) );
98+
if ( mDynamicUseZ )
99+
mUseZProperty = parameters.value( QStringLiteral( "USE_Z_VALUE" ) ).value< QgsProperty >();
100+
84101
return true;
85102
}
86103

87-
QgsFeatureList QgsAlgorithmRemoveDuplicateVertices::processFeature( const QgsFeature &feature, QgsProcessingContext &, QgsProcessingFeedback * )
104+
QgsFeatureList QgsAlgorithmRemoveDuplicateVertices::processFeature( const QgsFeature &feature, QgsProcessingContext &context, QgsProcessingFeedback * )
88105
{
89106
QgsFeature f = feature;
90107
if ( f.hasGeometry() )
91108
{
92109
QgsGeometry geometry = f.geometry();
93-
geometry.removeDuplicateNodes( mTolerance, mUseZValues );
110+
double tolerance = mTolerance;
111+
if ( mDynamicTolerance )
112+
tolerance = mToleranceProperty.valueAsDouble( context.expressionContext(), tolerance );
113+
114+
bool useZValue = mUseZValues;
115+
if ( mDynamicUseZ )
116+
useZValue = mUseZProperty.valueAsBool( context.expressionContext(), useZValue );
117+
118+
geometry.removeDuplicateNodes( tolerance, useZValue );
94119
f.setGeometry( geometry );
95120
}
96121
return QgsFeatureList() << f;

‎src/analysis/processing/qgsalgorithmremoveduplicatevertices.h

+5-1
Original file line numberDiff line numberDiff line change
@@ -51,8 +51,12 @@ class QgsAlgorithmRemoveDuplicateVertices : public QgsProcessingFeatureBasedAlgo
5151
private:
5252

5353
double mTolerance = 1.0;
54-
bool mUseZValues = false;
54+
bool mDynamicTolerance = false;
55+
QgsProperty mToleranceProperty;
5556

57+
bool mUseZValues = false;
58+
bool mDynamicUseZ = false;
59+
QgsProperty mUseZProperty;
5660
};
5761

5862

‎src/analysis/processing/qgsalgorithmsimplify.cpp

+26-6
Original file line numberDiff line numberDiff line change
@@ -78,22 +78,30 @@ void QgsSimplifyAlgorithm::initParameters( const QVariantMap & )
7878
QStringLiteral( "METHOD" ),
7979
QObject::tr( "Simplification method" ),
8080
methods, false, 0 ) );
81-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "TOLERANCE" ),
82-
QObject::tr( "Tolerance" ), QgsProcessingParameterNumber::Double,
83-
1.0, false, 0, 10000000.0 ) );
81+
std::unique_ptr< QgsProcessingParameterNumber > tolerance = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "TOLERANCE" ),
82+
QObject::tr( "Tolerance" ), QgsProcessingParameterNumber::Double,
83+
1.0, false, 0, 10000000.0 );
84+
tolerance->setIsDynamic( true );
85+
tolerance->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "Tolerance" ), QObject::tr( "Tolerance distance" ), QgsPropertyDefinition::DoublePositive ) );
86+
tolerance->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
87+
addParameter( tolerance.release() );
8488
}
8589

8690
bool QgsSimplifyAlgorithm::prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback * )
8791
{
8892
mTolerance = parameterAsDouble( parameters, QStringLiteral( "TOLERANCE" ), context );
93+
mDynamicTolerance = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "TOLERANCE" ) );
94+
if ( mDynamicTolerance )
95+
mToleranceProperty = parameters.value( QStringLiteral( "TOLERANCE" ) ).value< QgsProperty >();
96+
8997
mMethod = static_cast< QgsMapToPixelSimplifier::SimplifyAlgorithm >( parameterAsEnum( parameters, QStringLiteral( "METHOD" ), context ) );
9098
if ( mMethod != QgsMapToPixelSimplifier::Distance )
9199
mSimplifier.reset( new QgsMapToPixelSimplifier( QgsMapToPixelSimplifier::SimplifyGeometry, mTolerance, mMethod ) );
92100

93101
return true;
94102
}
95103

96-
QgsFeatureList QgsSimplifyAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &, QgsProcessingFeedback * )
104+
QgsFeatureList QgsSimplifyAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &context, QgsProcessingFeedback * )
97105
{
98106
QgsFeature f = feature;
99107
if ( f.hasGeometry() )
@@ -102,11 +110,23 @@ QgsFeatureList QgsSimplifyAlgorithm::processFeature( const QgsFeature &feature,
102110
QgsGeometry outputGeometry;
103111
if ( mMethod == QgsMapToPixelSimplifier::Distance )
104112
{
105-
outputGeometry = inputGeometry.simplify( mTolerance );
113+
double tolerance = mTolerance;
114+
if ( mDynamicTolerance )
115+
tolerance = mToleranceProperty.valueAsDouble( context.expressionContext(), tolerance );
116+
outputGeometry = inputGeometry.simplify( tolerance );
106117
}
107118
else
108119
{
109-
outputGeometry = mSimplifier->simplify( inputGeometry );
120+
if ( !mDynamicTolerance )
121+
{
122+
outputGeometry = mSimplifier->simplify( inputGeometry );
123+
}
124+
else
125+
{
126+
double tolerance = mToleranceProperty.valueAsDouble( context.expressionContext(), mTolerance );
127+
QgsMapToPixelSimplifier simplifier( QgsMapToPixelSimplifier::SimplifyGeometry, tolerance, mMethod );
128+
outputGeometry = simplifier.simplify( inputGeometry );
129+
}
110130
}
111131
f.setGeometry( outputGeometry );
112132
}

‎src/analysis/processing/qgsalgorithmsimplify.h

+2
Original file line numberDiff line numberDiff line change
@@ -53,6 +53,8 @@ class QgsSimplifyAlgorithm : public QgsProcessingFeatureBasedAlgorithm
5353
private:
5454

5555
double mTolerance = 1.0;
56+
bool mDynamicTolerance = false;
57+
QgsProperty mToleranceProperty;
5658
QgsMapToPixelSimplifier::SimplifyAlgorithm mMethod = QgsMapToPixelSimplifier::Distance;
5759
std::unique_ptr< QgsMapToPixelSimplifier > mSimplifier;
5860

‎src/analysis/processing/qgsalgorithmsmooth.cpp

+49-11
Original file line numberDiff line numberDiff line change
@@ -82,31 +82,69 @@ QList<int> QgsSmoothAlgorithm::inputLayerTypes() const
8282

8383
void QgsSmoothAlgorithm::initParameters( const QVariantMap & )
8484
{
85-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "ITERATIONS" ),
86-
QObject::tr( "Iterations" ), QgsProcessingParameterNumber::Integer,
87-
1, false, 1, 10 ) );
88-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "OFFSET" ),
89-
QObject::tr( "Offset" ), QgsProcessingParameterNumber::Double,
90-
0.25, false, 0.0, 0.5 ) );
91-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "MAX_ANGLE" ),
92-
QObject::tr( "Maximum node angle to smooth" ), QgsProcessingParameterNumber::Double,
93-
180.0, false, 0.0, 180.0 ) );
85+
std::unique_ptr< QgsProcessingParameterNumber > iterations = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "ITERATIONS" ),
86+
QObject::tr( "Iterations" ), QgsProcessingParameterNumber::Integer,
87+
1, false, 1, 10 );
88+
iterations->setIsDynamic( true );
89+
iterations->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "ITERATIONS" ), QObject::tr( "Iterations" ), QgsPropertyDefinition::IntegerPositiveGreaterZero ) );
90+
iterations->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
91+
addParameter( iterations.release() );
92+
93+
std::unique_ptr< QgsProcessingParameterNumber > offset = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "OFFSET" ),
94+
QObject::tr( "Offset" ), QgsProcessingParameterNumber::Double,
95+
0.25, false, 0.0, 0.5 );
96+
offset->setIsDynamic( true );
97+
offset->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "OFFSET" ), QObject::tr( "Offset" ), QgsPropertyDefinition::Double0To1 ) );
98+
offset->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
99+
addParameter( offset.release() );
100+
101+
std::unique_ptr< QgsProcessingParameterNumber > maxAngle = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "MAX_ANGLE" ),
102+
QObject::tr( "Maximum node angle to smooth" ), QgsProcessingParameterNumber::Double,
103+
180.0, false, 0.0, 180.0 );
104+
maxAngle->setIsDynamic( true );
105+
maxAngle->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "MAX_ANGLE" ), QObject::tr( "Maximum node angle to smooth" ), QgsPropertyDefinition::Rotation ) );
106+
maxAngle->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
107+
addParameter( maxAngle.release() );
94108
}
95109

96110
bool QgsSmoothAlgorithm::prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback * )
97111
{
98112
mIterations = parameterAsInt( parameters, QStringLiteral( "ITERATIONS" ), context );
113+
mDynamicIterations = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "ITERATIONS" ) );
114+
if ( mDynamicIterations )
115+
mIterationsProperty = parameters.value( QStringLiteral( "ITERATIONS" ) ).value< QgsProperty >();
116+
99117
mOffset = parameterAsDouble( parameters, QStringLiteral( "OFFSET" ), context );
118+
mDynamicOffset = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "OFFSET" ) );
119+
if ( mDynamicOffset )
120+
mOffsetProperty = parameters.value( QStringLiteral( "OFFSET" ) ).value< QgsProperty >();
121+
100122
mMaxAngle = parameterAsDouble( parameters, QStringLiteral( "MAX_ANGLE" ), context );
123+
mDynamicMaxAngle = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "MAX_ANGLE" ) );
124+
if ( mDynamicMaxAngle )
125+
mMaxAngleProperty = parameters.value( QStringLiteral( "MAX_ANGLE" ) ).value< QgsProperty >();
126+
101127
return true;
102128
}
103129

104-
QgsFeatureList QgsSmoothAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &, QgsProcessingFeedback *feedback )
130+
QgsFeatureList QgsSmoothAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
105131
{
106132
QgsFeature f = feature;
107133
if ( f.hasGeometry() )
108134
{
109-
QgsGeometry outputGeometry = f.geometry().smooth( mIterations, mOffset, -1, mMaxAngle );
135+
int iterations = mIterations;
136+
if ( mDynamicIterations )
137+
iterations = mIterationsProperty.valueAsInt( context.expressionContext(), iterations );
138+
139+
double offset = mOffset;
140+
if ( mDynamicOffset )
141+
offset = mOffsetProperty.valueAsDouble( context.expressionContext(), offset );
142+
143+
double maxAngle = mMaxAngle;
144+
if ( mDynamicMaxAngle )
145+
maxAngle = mMaxAngleProperty.valueAsDouble( context.expressionContext(), maxAngle );
146+
147+
QgsGeometry outputGeometry = f.geometry().smooth( iterations, offset, -1, maxAngle );
110148
if ( !outputGeometry )
111149
{
112150
feedback->reportError( QObject::tr( "Error smoothing geometry %1" ).arg( feature.id() ) );

‎src/analysis/processing/qgsalgorithmsmooth.h

+8
Original file line numberDiff line numberDiff line change
@@ -52,8 +52,16 @@ class QgsSmoothAlgorithm : public QgsProcessingFeatureBasedAlgorithm
5252

5353
private:
5454
int mIterations = 1;
55+
bool mDynamicIterations = false;
56+
QgsProperty mIterationsProperty;
57+
5558
double mOffset = 0.25;
59+
bool mDynamicOffset = false;
60+
QgsProperty mOffsetProperty;
61+
5662
double mMaxAngle = 0;
63+
bool mDynamicMaxAngle = false;
64+
QgsProperty mMaxAngleProperty;
5765
};
5866

5967
///@endcond PRIVATE

‎src/analysis/processing/qgsalgorithmsnaptogrid.cpp

+65-14
Original file line numberDiff line numberDiff line change
@@ -67,35 +67,86 @@ QgsSnapToGridAlgorithm *QgsSnapToGridAlgorithm::createInstance() const
6767

6868
void QgsSnapToGridAlgorithm::initParameters( const QVariantMap & )
6969
{
70-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "HSPACING" ),
71-
QObject::tr( "X Grid Spacing" ), QgsProcessingParameterNumber::Double,
72-
1, false, 0 ) );
73-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "VSPACING" ),
74-
QObject::tr( "Y Grid Spacing" ), QgsProcessingParameterNumber::Double,
75-
1, false, 0 ) );
76-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "ZSPACING" ),
77-
QObject::tr( "Z Grid Spacing" ), QgsProcessingParameterNumber::Double,
78-
0, false, 0 ) );
79-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "MSPACING" ),
80-
QObject::tr( "M Grid Spacing" ), QgsProcessingParameterNumber::Double,
81-
0, false, 0 ) );
70+
std::unique_ptr< QgsProcessingParameterNumber> hSpacing = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "HSPACING" ),
71+
QObject::tr( "X Grid Spacing" ), QgsProcessingParameterNumber::Double,
72+
1, false, 0 );
73+
hSpacing->setIsDynamic( true );
74+
hSpacing->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "HSPACING" ), QObject::tr( "X Grid Spacing" ), QgsPropertyDefinition::DoublePositive ) );
75+
hSpacing->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
76+
addParameter( hSpacing.release() );
77+
78+
std::unique_ptr< QgsProcessingParameterNumber> vSpacing = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "VSPACING" ),
79+
QObject::tr( "Y Grid Spacing" ), QgsProcessingParameterNumber::Double,
80+
1, false, 0 );
81+
vSpacing->setIsDynamic( true );
82+
vSpacing->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "VSPACING" ), QObject::tr( "Y Grid Spacing" ), QgsPropertyDefinition::DoublePositive ) );
83+
vSpacing->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
84+
addParameter( vSpacing.release() );
85+
86+
std::unique_ptr< QgsProcessingParameterNumber > zSpacing = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "ZSPACING" ),
87+
QObject::tr( "Z Grid Spacing" ), QgsProcessingParameterNumber::Double,
88+
0, false, 0 );
89+
zSpacing->setIsDynamic( true );
90+
zSpacing->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "ZSPACING" ), QObject::tr( "Z Grid Spacing" ), QgsPropertyDefinition::DoublePositive ) );
91+
zSpacing->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
92+
addParameter( zSpacing.release() );
93+
94+
std::unique_ptr< QgsProcessingParameterNumber > mSpacing = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "MSPACING" ),
95+
QObject::tr( "M Grid Spacing" ), QgsProcessingParameterNumber::Double,
96+
0, false, 0 );
97+
mSpacing->setIsDynamic( true );
98+
mSpacing->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "MSPACING" ), QObject::tr( "M Grid Spacing" ), QgsPropertyDefinition::DoublePositive ) );
99+
mSpacing->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
100+
addParameter( mSpacing.release() );
82101
}
83102

84103
bool QgsSnapToGridAlgorithm::prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback * )
85104
{
86105
mIntervalX = parameterAsDouble( parameters, QStringLiteral( "HSPACING" ), context );
106+
mDynamicIntervalX = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "HSPACING" ) );
107+
if ( mDynamicIntervalX )
108+
mIntervalXProperty = parameters.value( QStringLiteral( "HSPACING" ) ).value< QgsProperty >();
109+
87110
mIntervalY = parameterAsDouble( parameters, QStringLiteral( "VSPACING" ), context );
111+
mDynamicIntervalY = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "VSPACING" ) );
112+
if ( mDynamicIntervalY )
113+
mIntervalYProperty = parameters.value( QStringLiteral( "VSPACING" ) ).value< QgsProperty >();
114+
88115
mIntervalZ = parameterAsDouble( parameters, QStringLiteral( "ZSPACING" ), context );
116+
mDynamicIntervalZ = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "ZSPACING" ) );
117+
if ( mDynamicIntervalZ )
118+
mIntervalZProperty = parameters.value( QStringLiteral( "ZSPACING" ) ).value< QgsProperty >();
119+
89120
mIntervalM = parameterAsDouble( parameters, QStringLiteral( "MSPACING" ), context );
121+
mDynamicIntervalM = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "MSPACING" ) );
122+
if ( mDynamicIntervalM )
123+
mIntervalMProperty = parameters.value( QStringLiteral( "MSPACING" ) ).value< QgsProperty >();
124+
90125
return true;
91126
}
92127

93-
QgsFeatureList QgsSnapToGridAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &, QgsProcessingFeedback *feedback )
128+
QgsFeatureList QgsSnapToGridAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
94129
{
95130
QgsFeature f = feature;
96131
if ( f.hasGeometry() )
97132
{
98-
QgsGeometry outputGeometry = f.geometry().snappedToGrid( mIntervalX, mIntervalY, mIntervalZ, mIntervalM );
133+
double intervalX = mIntervalX;
134+
if ( mDynamicIntervalX )
135+
intervalX = mIntervalXProperty.valueAsDouble( context.expressionContext(), intervalX );
136+
137+
double intervalY = mIntervalY;
138+
if ( mDynamicIntervalY )
139+
intervalY = mIntervalYProperty.valueAsDouble( context.expressionContext(), intervalY );
140+
141+
double intervalZ = mIntervalZ;
142+
if ( mDynamicIntervalZ )
143+
intervalZ = mIntervalZProperty.valueAsDouble( context.expressionContext(), intervalZ );
144+
145+
double intervalM = mIntervalM;
146+
if ( mDynamicIntervalM )
147+
intervalM = mIntervalMProperty.valueAsDouble( context.expressionContext(), intervalM );
148+
149+
QgsGeometry outputGeometry = f.geometry().snappedToGrid( intervalX, intervalY, intervalZ, intervalM );
99150
if ( !outputGeometry )
100151
{
101152
feedback->reportError( QObject::tr( "Error snapping geometry %1" ).arg( feature.id() ) );

‎src/analysis/processing/qgsalgorithmsnaptogrid.h

+12
Original file line numberDiff line numberDiff line change
@@ -50,9 +50,21 @@ class QgsSnapToGridAlgorithm : public QgsProcessingFeatureBasedAlgorithm
5050

5151
private:
5252
double mIntervalX = 0.0;
53+
bool mDynamicIntervalX = false;
54+
QgsProperty mIntervalXProperty;
55+
5356
double mIntervalY = 0.0;
57+
bool mDynamicIntervalY = false;
58+
QgsProperty mIntervalYProperty;
59+
5460
double mIntervalZ = 0.0;
61+
bool mDynamicIntervalZ = false;
62+
QgsProperty mIntervalZProperty;
63+
5564
double mIntervalM = 0.0;
65+
bool mDynamicIntervalM = false;
66+
QgsProperty mIntervalMProperty;
67+
5668
};
5769

5870
///@endcond PRIVATE

‎src/analysis/processing/qgsalgorithmsubdivide.cpp

+17-4
Original file line numberDiff line numberDiff line change
@@ -21,8 +21,13 @@
2121

2222
void QgsSubdivideAlgorithm::initParameters( const QVariantMap & )
2323
{
24-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "MAX_NODES" ), QObject::tr( "Maximum nodes in parts" ), QgsProcessingParameterNumber::Integer,
25-
256, false, 8, 100000 ) );
24+
std::unique_ptr< QgsProcessingParameterNumber> nodes = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "MAX_NODES" ), QObject::tr( "Maximum nodes in parts" ), QgsProcessingParameterNumber::Integer,
25+
256, false, 8, 100000 );
26+
nodes->setIsDynamic( true );
27+
nodes->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "MAX_NODES" ), QObject::tr( "Maximum nodes in parts" ), QgsPropertyDefinition::Integer ) );
28+
nodes->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
29+
30+
addParameter( nodes.release() );
2631
}
2732

2833
QString QgsSubdivideAlgorithm::name() const
@@ -75,12 +80,16 @@ QgsWkbTypes::Type QgsSubdivideAlgorithm::outputWkbType( QgsWkbTypes::Type inputW
7580
return QgsWkbTypes::multiType( inputWkbType );
7681
}
7782

78-
QgsFeatureList QgsSubdivideAlgorithm::processFeature( const QgsFeature &f, QgsProcessingContext &, QgsProcessingFeedback *feedback )
83+
QgsFeatureList QgsSubdivideAlgorithm::processFeature( const QgsFeature &f, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
7984
{
8085
QgsFeature feature = f;
8186
if ( feature.hasGeometry() )
8287
{
83-
feature.setGeometry( feature.geometry().subdivide( mMaxNodes ) );
88+
int maxNodes = mMaxNodes;
89+
if ( mDynamicMaxNodes )
90+
maxNodes = mMaxNodesProperty.valueAsDouble( context.expressionContext(), maxNodes );
91+
92+
feature.setGeometry( feature.geometry().subdivide( maxNodes ) );
8493
if ( !feature.geometry() )
8594
{
8695
feedback->reportError( QObject::tr( "Error calculating subdivision for feature %1" ).arg( feature.id() ) );
@@ -92,6 +101,10 @@ QgsFeatureList QgsSubdivideAlgorithm::processFeature( const QgsFeature &f, QgsPr
92101
bool QgsSubdivideAlgorithm::prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback * )
93102
{
94103
mMaxNodes = parameterAsInt( parameters, QStringLiteral( "MAX_NODES" ), context );
104+
mDynamicMaxNodes = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "MAX_NODES" ) );
105+
if ( mDynamicMaxNodes )
106+
mMaxNodesProperty = parameters.value( QStringLiteral( "MAX_NODES" ) ).value< QgsProperty >();
107+
95108
return true;
96109
}
97110

‎src/analysis/processing/qgsalgorithmsubdivide.h

+2-1
Original file line numberDiff line numberDiff line change
@@ -54,7 +54,8 @@ class QgsSubdivideAlgorithm : public QgsProcessingFeatureBasedAlgorithm
5454
private:
5555

5656
int mMaxNodes = -1;
57-
57+
bool mDynamicMaxNodes = false;
58+
QgsProperty mMaxNodesProperty;
5859
};
5960

6061
///@endcond PRIVATE

‎src/analysis/processing/qgsalgorithmtransect.cpp

+40-7
Original file line numberDiff line numberDiff line change
@@ -50,10 +50,20 @@ void QgsTransectAlgorithm::initAlgorithm( const QVariantMap & )
5050
{
5151
addParameter( new QgsProcessingParameterFeatureSource( QStringLiteral( "INPUT" ),
5252
QObject::tr( "Input layer" ), QList< int >() << QgsProcessing::TypeVectorLine ) );
53-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "LENGTH" ), QObject::tr( "Length of the transect " ), QgsProcessingParameterNumber::Double,
54-
5.0, false, 0 ) );
55-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "ANGLE" ), QObject::tr( "Angle in degrees from the original line at the vertices" ), QgsProcessingParameterNumber::Double,
56-
90.0, false, 0, 360 ) );
53+
std::unique_ptr< QgsProcessingParameterNumber > length = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "LENGTH" ), QObject::tr( "Length of the transect" ), QgsProcessingParameterNumber::Double,
54+
5.0, false, 0 );
55+
length->setIsDynamic( true );
56+
length->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "LENGTH" ), QObject::tr( "Length of the transect" ), QgsPropertyDefinition::DoublePositive ) );
57+
length->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
58+
addParameter( length.release() );
59+
60+
std::unique_ptr< QgsProcessingParameterNumber > angle = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "ANGLE" ), QObject::tr( "Angle in degrees from the original line at the vertices" ), QgsProcessingParameterNumber::Double,
61+
90.0, false, 0, 360 );
62+
angle->setIsDynamic( true );
63+
angle->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "ANGLE" ), QObject::tr( "Angle in degrees" ), QgsPropertyDefinition::Double ) );
64+
angle->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
65+
addParameter( angle.release() );
66+
5767
addParameter( new QgsProcessingParameterEnum( QStringLiteral( "SIDE" ), QObject::tr( "Side to create the transects" ), QStringList() << QObject::tr( "Left" ) << QObject::tr( "Right" ) << QObject::tr( "Both" ), false ) );
5868
addParameter( new QgsProcessingParameterFeatureSink( QStringLiteral( "OUTPUT" ), QObject::tr( "Transect" ), QgsProcessing::TypeVectorLine ) );
5969

@@ -84,7 +94,16 @@ QVariantMap QgsTransectAlgorithm::processAlgorithm( const QVariantMap &parameter
8494
{
8595
Side orientation = static_cast< QgsTransectAlgorithm::Side >( parameterAsInt( parameters, QStringLiteral( "SIDE" ), context ) );
8696
double angle = fabs( parameterAsDouble( parameters, QStringLiteral( "ANGLE" ), context ) );
97+
bool dynamicAngle = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "ANGLE" ) );
98+
QgsProperty angleProperty;
99+
if ( dynamicAngle )
100+
angleProperty = parameters.value( QStringLiteral( "ANGLE" ) ).value< QgsProperty >();
101+
87102
double length = parameterAsDouble( parameters, QStringLiteral( "LENGTH" ), context );
103+
bool dynamicLength = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "LENGTH" ) );
104+
QgsProperty lengthProperty;
105+
if ( dynamicLength )
106+
lengthProperty = parameters.value( QStringLiteral( "LENGTH" ) ).value< QgsProperty >();
88107

89108
if ( orientation == QgsTransectAlgorithm::Both )
90109
length /= 2.0;
@@ -93,6 +112,8 @@ QVariantMap QgsTransectAlgorithm::processAlgorithm( const QVariantMap &parameter
93112
if ( !source )
94113
return QVariantMap();
95114

115+
QgsExpressionContext expressionContext = createExpressionContext( parameters, context, dynamic_cast< QgsProcessingFeatureSource * >( source.get() ) );
116+
96117
QgsFields fields = source->fields();
97118

98119
fields.append( QgsField( QStringLiteral( "TR_FID" ), QVariant::Int, QString(), 20 ) );
@@ -136,6 +157,18 @@ QVariantMap QgsTransectAlgorithm::processAlgorithm( const QVariantMap &parameter
136157

137158
QgsGeometry inputGeometry = feat.geometry();
138159

160+
if ( dynamicLength || dynamicAngle )
161+
{
162+
expressionContext.setFeature( feat );
163+
}
164+
165+
double evaluatedLength = length;
166+
if ( dynamicLength )
167+
evaluatedLength = lengthProperty.valueAsDouble( context.expressionContext(), length );
168+
double evaluatedAngle = angle;
169+
if ( dynamicAngle )
170+
evaluatedAngle = angleProperty.valueAsDouble( context.expressionContext(), angle );
171+
139172
inputGeometry.convertToMultiType();
140173
const QgsMultiLineString *multiLine = static_cast< const QgsMultiLineString * >( inputGeometry.constGet() );
141174
for ( int id = 0; id < multiLine->numGeometries(); ++id )
@@ -148,12 +181,12 @@ QVariantMap QgsTransectAlgorithm::processAlgorithm( const QVariantMap &parameter
148181
int i = vertexId.vertex;
149182
QgsFeature outFeat;
150183
QgsAttributes attrs = feat.attributes();
151-
attrs << current << number << i + 1 << angle <<
152-
( ( orientation == QgsTransectAlgorithm::Both ) ? length * 2 : length ) <<
184+
attrs << current << number << i + 1 << evaluatedAngle <<
185+
( ( orientation == QgsTransectAlgorithm::Both ) ? evaluatedLength * 2 : evaluatedLength ) <<
153186
orientation;
154187
outFeat.setAttributes( attrs );
155188
double angleAtVertex = line->vertexAngle( vertexId );
156-
outFeat.setGeometry( calcTransect( *it, angleAtVertex, length, orientation, angle ) );
189+
outFeat.setGeometry( calcTransect( *it, angleAtVertex, evaluatedLength, orientation, evaluatedAngle ) );
157190
sink->addFeature( outFeat, QgsFeatureSink::FastInsert );
158191
number++;
159192
it++;

‎src/analysis/processing/qgsalgorithmtranslate.cpp

+64-16
Original file line numberDiff line numberDiff line change
@@ -63,42 +63,90 @@ QgsTranslateAlgorithm *QgsTranslateAlgorithm::createInstance() const
6363

6464
void QgsTranslateAlgorithm::initParameters( const QVariantMap & )
6565
{
66-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "DELTA_X" ),
67-
QObject::tr( "Offset distance (x-axis)" ), QgsProcessingParameterNumber::Double,
68-
0.0 ) );
69-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "DELTA_Y" ),
70-
QObject::tr( "Offset distance (y-axis)" ), QgsProcessingParameterNumber::Double,
71-
0.0 ) );
72-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "DELTA_Z" ),
73-
QObject::tr( "Offset distance (z-axis)" ), QgsProcessingParameterNumber::Double,
74-
0.0 ) );
75-
addParameter( new QgsProcessingParameterNumber( QStringLiteral( "DELTA_M" ),
76-
QObject::tr( "Offset distance (m values)" ), QgsProcessingParameterNumber::Double,
77-
0.0 ) );
66+
std::unique_ptr< QgsProcessingParameterNumber > xOffset = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "DELTA_X" ),
67+
QObject::tr( "Offset distance (x-axis)" ), QgsProcessingParameterNumber::Double,
68+
0.0 );
69+
xOffset->setIsDynamic( true );
70+
xOffset->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "DELTA_X" ), QObject::tr( "Offset distance (x-axis)" ), QgsPropertyDefinition::Double ) );
71+
xOffset->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
72+
addParameter( xOffset.release() );
73+
74+
std::unique_ptr< QgsProcessingParameterNumber > yOffset = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "DELTA_Y" ),
75+
QObject::tr( "Offset distance (y-axis)" ), QgsProcessingParameterNumber::Double,
76+
0.0 );
77+
yOffset->setIsDynamic( true );
78+
yOffset->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "DELTA_Y" ), QObject::tr( "Offset distance (y-axis)" ), QgsPropertyDefinition::Double ) );
79+
yOffset->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
80+
addParameter( yOffset.release() );
81+
82+
std::unique_ptr< QgsProcessingParameterNumber > zOffset = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "DELTA_Z" ),
83+
QObject::tr( "Offset distance (z-axis)" ), QgsProcessingParameterNumber::Double,
84+
0.0 );
85+
zOffset->setIsDynamic( true );
86+
zOffset->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "DELTA_Z" ), QObject::tr( "Offset distance (z-axis)" ), QgsPropertyDefinition::Double ) );
87+
zOffset->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
88+
addParameter( zOffset.release() );
89+
90+
std::unique_ptr< QgsProcessingParameterNumber > mOffset = qgis::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "DELTA_M" ),
91+
QObject::tr( "Offset distance (m values)" ), QgsProcessingParameterNumber::Double,
92+
0.0 );
93+
mOffset->setIsDynamic( true );
94+
mOffset->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "DELTA_M" ), QObject::tr( "Offset distance (m values)" ), QgsPropertyDefinition::Double ) );
95+
mOffset->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
96+
addParameter( mOffset.release() );
7897
}
7998

8099
bool QgsTranslateAlgorithm::prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback * )
81100
{
82101
mDeltaX = parameterAsDouble( parameters, QStringLiteral( "DELTA_X" ), context );
102+
mDynamicDeltaX = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "DELTA_X" ) );
103+
if ( mDynamicDeltaX )
104+
mDeltaXProperty = parameters.value( QStringLiteral( "DELTA_X" ) ).value< QgsProperty >();
105+
83106
mDeltaY = parameterAsDouble( parameters, QStringLiteral( "DELTA_Y" ), context );
107+
mDynamicDeltaY = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "DELTA_Y" ) );
108+
if ( mDynamicDeltaY )
109+
mDeltaYProperty = parameters.value( QStringLiteral( "DELTA_Y" ) ).value< QgsProperty >();
110+
84111
mDeltaZ = parameterAsDouble( parameters, QStringLiteral( "DELTA_Z" ), context );
112+
mDynamicDeltaZ = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "DELTA_Z" ) );
113+
if ( mDynamicDeltaZ )
114+
mDeltaZProperty = parameters.value( QStringLiteral( "DELTA_Z" ) ).value< QgsProperty >();
115+
85116
mDeltaM = parameterAsDouble( parameters, QStringLiteral( "DELTA_M" ), context );
117+
mDynamicDeltaM = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "DELTA_M" ) );
118+
if ( mDynamicDeltaM )
119+
mDeltaMProperty = parameters.value( QStringLiteral( "DELTA_M" ) ).value< QgsProperty >();
86120

87121
return true;
88122
}
89123

90-
QgsFeatureList QgsTranslateAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &, QgsProcessingFeedback * )
124+
QgsFeatureList QgsTranslateAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &context, QgsProcessingFeedback * )
91125
{
92126
QgsFeature f = feature;
93127
if ( f.hasGeometry() )
94128
{
95129
QgsGeometry geometry = f.geometry();
96-
if ( mDeltaZ != 0 && !geometry.constGet()->is3D() )
130+
131+
double deltaX = mDeltaX;
132+
if ( mDynamicDeltaX )
133+
deltaX = mDeltaXProperty.valueAsDouble( context.expressionContext(), deltaX );
134+
double deltaY = mDeltaY;
135+
if ( mDynamicDeltaY )
136+
deltaY = mDeltaYProperty.valueAsDouble( context.expressionContext(), deltaY );
137+
double deltaZ = mDeltaZ;
138+
if ( mDynamicDeltaZ )
139+
deltaZ = mDeltaZProperty.valueAsDouble( context.expressionContext(), deltaZ );
140+
double deltaM = mDeltaM;
141+
if ( mDynamicDeltaM )
142+
deltaM = mDeltaMProperty.valueAsDouble( context.expressionContext(), deltaM );
143+
144+
if ( deltaZ != 0 && !geometry.constGet()->is3D() )
97145
geometry.get()->addZValue( 0 );
98-
if ( mDeltaM != 0 && !geometry.constGet()->isMeasure() )
146+
if ( deltaM != 0 && !geometry.constGet()->isMeasure() )
99147
geometry.get()->addMValue( 0 );
100148

101-
geometry.translate( mDeltaX, mDeltaY, mDeltaZ, mDeltaM );
149+
geometry.translate( deltaX, deltaY, deltaZ, deltaM );
102150
f.setGeometry( geometry );
103151
}
104152
return QgsFeatureList() << f;

‎src/analysis/processing/qgsalgorithmtranslate.h

+11
Original file line numberDiff line numberDiff line change
@@ -52,9 +52,20 @@ class QgsTranslateAlgorithm : public QgsProcessingFeatureBasedAlgorithm
5252
private:
5353

5454
double mDeltaX = 0.0;
55+
bool mDynamicDeltaX = false;
56+
QgsProperty mDeltaXProperty;
57+
5558
double mDeltaY = 0.0;
59+
bool mDynamicDeltaY = false;
60+
QgsProperty mDeltaYProperty;
61+
5662
double mDeltaZ = 0.0;
63+
bool mDynamicDeltaZ = false;
64+
QgsProperty mDeltaZProperty;
65+
5766
double mDeltaM = 0.0;
67+
bool mDynamicDeltaM = false;
68+
QgsProperty mDeltaMProperty;
5869

5970
};
6071

0 commit comments

Comments
 (0)
Please sign in to comment.