QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgsalgorithmtransect.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsalgorithmtransect.cpp
3 -------------------------
4 begin : October 2017
5 copyright : (C) 2017 by Loïc Bartoletti
6 email : lbartoletti at tuxfamily dot org
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
19#include "qgsmultilinestring.h"
20#include "qgslinestring.h"
21
23
24QString QgsTransectAlgorithm::name() const
25{
26 return QStringLiteral( "transect" );
27}
28
29QString QgsTransectAlgorithm::displayName() const
30{
31 return QObject::tr( "Transect" );
32}
33
34QStringList QgsTransectAlgorithm::tags() const
35{
36 return QObject::tr( "transect,station,lines,extend," ).split( ',' );
37}
38
39QString QgsTransectAlgorithm::group() const
40{
41 return QObject::tr( "Vector geometry" );
42}
43
44QString QgsTransectAlgorithm::groupId() const
45{
46 return QStringLiteral( "vectorgeometry" );
47}
48
49void QgsTransectAlgorithm::initAlgorithm( const QVariantMap & )
50{
51 addParameter( new QgsProcessingParameterFeatureSource( QStringLiteral( "INPUT" ),
52 QObject::tr( "Input layer" ), QList< int >() << static_cast< int >( Qgis::ProcessingSourceType::VectorLine ) ) );
53 std::unique_ptr< QgsProcessingParameterDistance > length = std::make_unique< QgsProcessingParameterDistance >( QStringLiteral( "LENGTH" ), QObject::tr( "Length of the transect" ),
54 5.0, QStringLiteral( "INPUT" ), 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 = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "ANGLE" ), QObject::tr( "Angle in degrees from the original line at the vertices" ), Qgis::ProcessingNumberParameterType::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
67 addParameter( new QgsProcessingParameterEnum( QStringLiteral( "SIDE" ), QObject::tr( "Side to create the transects" ), QStringList() << QObject::tr( "Left" ) << QObject::tr( "Right" ) << QObject::tr( "Both" ), false ) );
68 addParameter( new QgsProcessingParameterFeatureSink( QStringLiteral( "OUTPUT" ), QObject::tr( "Transect" ), Qgis::ProcessingSourceType::VectorLine ) );
69
70}
71
72QString QgsTransectAlgorithm::shortHelpString() const
73{
74
75 return QObject::tr( "This algorithm creates transects on vertices for (multi)linestring.\n" ) +
76 QObject::tr( "A transect is a line oriented from an angle (by default perpendicular) to the input polylines (at vertices)." ) +
77 QStringLiteral( "\n\n" ) +
78 QObject::tr( "Field(s) from feature(s) are returned in the transect with these new fields:\n" ) +
79 QObject::tr( "- TR_FID: ID of the original feature\n" ) +
80 QObject::tr( "- TR_ID: ID of the transect. Each transect have an unique ID\n" ) +
81 QObject::tr( "- TR_SEGMENT: ID of the segment of the linestring\n" ) +
82 QObject::tr( "- TR_ANGLE: Angle in degrees from the original line at the vertex\n" ) +
83 QObject::tr( "- TR_LENGTH: Total length of the transect returned\n" ) +
84 QObject::tr( "- TR_ORIENT: Side of the transect (only on the left or right of the line, or both side)\n" );
85
86}
87
88Qgis::ProcessingAlgorithmDocumentationFlags QgsTransectAlgorithm::documentationFlags() const
89{
91}
92
93QgsTransectAlgorithm *QgsTransectAlgorithm::createInstance() const
94{
95 return new QgsTransectAlgorithm();
96}
97
98QVariantMap QgsTransectAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
99{
100 const Side orientation = static_cast< QgsTransectAlgorithm::Side >( parameterAsInt( parameters, QStringLiteral( "SIDE" ), context ) );
101 const double angle = fabs( parameterAsDouble( parameters, QStringLiteral( "ANGLE" ), context ) );
102 const bool dynamicAngle = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "ANGLE" ) );
103 QgsProperty angleProperty;
104 if ( dynamicAngle )
105 angleProperty = parameters.value( QStringLiteral( "ANGLE" ) ).value< QgsProperty >();
106
107 double length = parameterAsDouble( parameters, QStringLiteral( "LENGTH" ), context );
108 const bool dynamicLength = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "LENGTH" ) );
109 QgsProperty lengthProperty;
110 if ( dynamicLength )
111 lengthProperty = parameters.value( QStringLiteral( "LENGTH" ) ).value< QgsProperty >();
112
113 if ( orientation == QgsTransectAlgorithm::Both )
114 length /= 2.0;
115
116 std::unique_ptr< QgsFeatureSource > source( parameterAsSource( parameters, QStringLiteral( "INPUT" ), context ) );
117 if ( !source )
118 throw QgsProcessingException( invalidSourceError( parameters, QStringLiteral( "INPUT" ) ) );
119
120 QgsExpressionContext expressionContext = createExpressionContext( parameters, context, dynamic_cast< QgsProcessingFeatureSource * >( source.get() ) );
121
122 QgsFields fields = source->fields();
123
124 fields.append( QgsField( QStringLiteral( "TR_FID" ), QMetaType::Type::Int, QString(), 20 ) );
125 fields.append( QgsField( QStringLiteral( "TR_ID" ), QMetaType::Type::Int, QString(), 20 ) );
126 fields.append( QgsField( QStringLiteral( "TR_SEGMENT" ), QMetaType::Type::Int, QString(), 20 ) );
127 fields.append( QgsField( QStringLiteral( "TR_ANGLE" ), QMetaType::Type::Double, QString(), 5, 2 ) );
128 fields.append( QgsField( QStringLiteral( "TR_LENGTH" ), QMetaType::Type::Double, QString(), 20, 6 ) );
129 fields.append( QgsField( QStringLiteral( "TR_ORIENT" ), QMetaType::Type::Int, QString(), 1 ) );
130
132 if ( QgsWkbTypes::hasZ( source->wkbType() ) )
133 outputWkb = QgsWkbTypes::addZ( outputWkb );
134 if ( QgsWkbTypes::hasM( source->wkbType() ) )
135 outputWkb = QgsWkbTypes::addM( outputWkb );
136
137 QString dest;
138 std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields,
139 outputWkb, source->sourceCrs(), QgsFeatureSink::RegeneratePrimaryKey ) );
140 if ( !sink )
141 throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
142
143 QgsFeatureIterator features = source->getFeatures( );
144
145 int current = -1;
146 int number = 0;
147 const double step = source->featureCount() > 0 ? 100.0 / source->featureCount() : 1;
148 QgsFeature feat;
149
150
151 while ( features.nextFeature( feat ) )
152 {
153 current++;
154 if ( feedback->isCanceled() )
155 {
156 break;
157 }
158
159 feedback->setProgress( current * step );
160 if ( !feat.hasGeometry() )
161 continue;
162
163 QgsGeometry inputGeometry = feat.geometry();
164
165 if ( dynamicLength || dynamicAngle )
166 {
167 expressionContext.setFeature( feat );
168 }
169
170 double evaluatedLength = length;
171 if ( dynamicLength )
172 evaluatedLength = lengthProperty.valueAsDouble( context.expressionContext(), length );
173 double evaluatedAngle = angle;
174 if ( dynamicAngle )
175 evaluatedAngle = angleProperty.valueAsDouble( context.expressionContext(), angle );
176
177 inputGeometry.convertToMultiType();
178 const QgsMultiLineString *multiLine = static_cast< const QgsMultiLineString * >( inputGeometry.constGet() );
179 for ( int id = 0; id < multiLine->numGeometries(); ++id )
180 {
181 const QgsLineString *line = multiLine->lineStringN( id );
183 while ( it != line->vertices_end() )
184 {
185 const QgsVertexId vertexId = it.vertexId();
186 const int i = vertexId.vertex;
187 QgsFeature outFeat;
188 QgsAttributes attrs = feat.attributes();
189 attrs << current << number << i + 1 << evaluatedAngle <<
190 ( ( orientation == QgsTransectAlgorithm::Both ) ? evaluatedLength * 2 : evaluatedLength ) <<
191 orientation;
192 outFeat.setAttributes( attrs );
193 const double angleAtVertex = line->vertexAngle( vertexId );
194 outFeat.setGeometry( calcTransect( *it, angleAtVertex, evaluatedLength, orientation, evaluatedAngle ) );
195 if ( !sink->addFeature( outFeat, QgsFeatureSink::FastInsert ) )
196 throw QgsProcessingException( writeFeatureError( sink.get(), parameters, QStringLiteral( "OUTPUT" ) ) );
197 number++;
198 it++;
199 }
200 }
201 }
202
203 QVariantMap outputs;
204 outputs.insert( QStringLiteral( "OUTPUT" ), dest );
205 return outputs;
206}
207
208
209QgsGeometry QgsTransectAlgorithm::calcTransect( const QgsPoint &point, const double angleAtVertex, const double length, const QgsTransectAlgorithm::Side orientation, const double angle )
210{
211 QgsPoint pLeft; // left point of the line
212 QgsPoint pRight; // right point of the line
213
214 QgsPolyline line;
215
216 if ( ( orientation == QgsTransectAlgorithm::Right ) || ( orientation == QgsTransectAlgorithm::Both ) )
217 {
218 pLeft = point.project( length, angle + 180.0 / M_PI * angleAtVertex );
219 if ( orientation != QgsTransectAlgorithm::Both )
220 pRight = point;
221 }
222
223 if ( ( orientation == QgsTransectAlgorithm::Left ) || ( orientation == QgsTransectAlgorithm::Both ) )
224 {
225 pRight = point.project( -length, angle + 180.0 / M_PI * angleAtVertex );
226 if ( orientation != QgsTransectAlgorithm::Both )
227 pLeft = point;
228 }
229
230 line.append( pLeft );
231 line.append( pRight );
232
233 return QgsGeometry::fromPolyline( line );
234}
235
@ VectorLine
Vector line layers.
@ RegeneratesPrimaryKey
Algorithm always drops any existing primary keys or FID values and regenerates them in outputs.
QFlags< ProcessingAlgorithmDocumentationFlag > ProcessingAlgorithmDocumentationFlags
Flags describing algorithm behavior for documentation purposes.
Definition qgis.h:3359
WkbType
The WKB type describes the number of dimensions a geometry has.
Definition qgis.h:256
@ LineString
LineString.
The vertex_iterator class provides STL-style iterator for vertices.
QgsVertexId vertexId() const
Returns vertex ID of the current item.
vertex_iterator vertices_end() const
Returns STL-style iterator pointing to the imaginary vertex after the last vertex of the geometry.
vertex_iterator vertices_begin() const
Returns STL-style iterator pointing to the first vertex of the geometry.
A vector of attributes.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
@ FastInsert
Use faster inserts, at the cost of updating the passed features to reflect changes made at the provid...
@ RegeneratePrimaryKey
This flag indicates, that a primary key field cannot be guaranteed to be unique and the sink should i...
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:58
QgsAttributes attributes
Definition qgsfeature.h:67
void setAttributes(const QgsAttributes &attrs)
Sets the feature's attributes.
QgsGeometry geometry
Definition qgsfeature.h:69
bool hasGeometry() const
Returns true if the feature has an associated geometry.
void setGeometry(const QgsGeometry &geometry)
Set the feature's geometry.
bool isCanceled() const
Tells whether the operation has been canceled already.
Definition qgsfeedback.h:53
void setProgress(double progress)
Sets the current progress for the feedback object.
Definition qgsfeedback.h:61
Encapsulate a field in an attribute table or data source.
Definition qgsfield.h:53
Container of fields for a vector layer.
Definition qgsfields.h:46
bool append(const QgsField &field, Qgis::FieldOrigin origin=Qgis::FieldOrigin::Provider, int originIndex=-1)
Appends a field.
Definition qgsfields.cpp:69
int numGeometries() const
Returns the number of geometries within the collection.
A geometry is the spatial representation of a feature.
const QgsAbstractGeometry * constGet() const
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
static QgsGeometry fromPolyline(const QgsPolyline &polyline)
Creates a new LineString geometry from a list of QgsPoint points.
bool convertToMultiType()
Converts single type geometry into multitype geometry e.g.
Line string geometry type, with support for z-dimension and m-values.
double vertexAngle(QgsVertexId vertex) const override
Returns approximate angle at a vertex.
Multi line string geometry collection.
QgsLineString * lineStringN(int index)
Returns the line string with the specified index.
Point geometry type, with support for z-dimension and m-values.
Definition qgspoint.h:49
QgsPoint project(double distance, double azimuth, double inclination=90.0) const
Returns a new point which corresponds to this point projected by a specified distance with specified ...
Definition qgspoint.cpp:705
Contains information about the context in which a processing algorithm is executed.
QgsExpressionContext & expressionContext()
Returns the expression context.
Custom exception class for processing related exceptions.
QgsFeatureSource subclass which proxies methods to an underlying QgsFeatureSource,...
Base class for providing feedback from a processing algorithm.
An enum based parameter for processing algorithms, allowing for selection from predefined values.
A feature sink output for processing algorithms.
An input feature source (such as vector layers) parameter for processing algorithms.
static bool isDynamic(const QVariantMap &parameters, const QString &name)
Returns true if the parameter with matching name is a dynamic parameter, and must be evaluated once f...
Definition for a property.
Definition qgsproperty.h:45
@ Double
Double value (including negative values)
Definition qgsproperty.h:55
@ DoublePositive
Positive double value (including 0)
Definition qgsproperty.h:56
A store for object properties.
QVariant value(const QgsExpressionContext &context, const QVariant &defaultValue=QVariant(), bool *ok=nullptr) const
Calculates the current value of the property, including any transforms which are set for the property...
double valueAsDouble(const QgsExpressionContext &context, double defaultValue=0.0, bool *ok=nullptr) const
Calculates the current value of the property and interprets it as a double.
static Qgis::WkbType addM(Qgis::WkbType type)
Adds the m dimension to a WKB type and returns the new type.
static Qgis::WkbType addZ(Qgis::WkbType type)
Adds the z dimension to a WKB type and returns the new type.
static bool hasZ(Qgis::WkbType type)
Tests whether a WKB type contains the z-dimension.
static bool hasM(Qgis::WkbType type)
Tests whether a WKB type contains m values.
double ANALYSIS_EXPORT angle(QgsPoint *p1, QgsPoint *p2, QgsPoint *p3, QgsPoint *p4)
Calculates the angle between two segments (in 2 dimension, z-values are ignored)
QgsPointSequence QgsPolyline
Polyline as represented as a vector of points.
Definition qgsgeometry.h:70
Utility class for identifying a unique vertex within a geometry.
Definition qgsvertexid.h:30
int vertex
Vertex number.
Definition qgsvertexid.h:94