QGIS API Documentation  3.26.3-Buenos Aires (65e4edfdad)
qgsalgorithmwedgebuffers.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsalgorithmwedgebuffers.cpp
3  ---------------------
4  begin : April 2018
5  copyright : (C) 2018 by Nyall Dawson
6  email : nyall dot dawson 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 
19 #include "qgsmultipoint.h"
20 #include "qgsmultisurface.h"
21 
23 
24 QString QgsWedgeBuffersAlgorithm::name() const
25 {
26  return QStringLiteral( "wedgebuffers" );
27 }
28 
29 QString QgsWedgeBuffersAlgorithm::displayName() const
30 {
31  return QObject::tr( "Create wedge buffers" );
32 }
33 
34 QStringList QgsWedgeBuffersAlgorithm::tags() const
35 {
36  return QObject::tr( "arc,segment,circular,circle,slice" ).split( ',' );
37 }
38 
39 QString QgsWedgeBuffersAlgorithm::group() const
40 {
41  return QObject::tr( "Vector geometry" );
42 }
43 
44 QString QgsWedgeBuffersAlgorithm::groupId() const
45 {
46  return QStringLiteral( "vectorgeometry" );
47 }
48 
49 QString QgsWedgeBuffersAlgorithm::outputName() const
50 {
51  return QObject::tr( "Buffers" );
52 }
53 
54 QgsWkbTypes::Type QgsWedgeBuffersAlgorithm::outputWkbType( QgsWkbTypes::Type inputWkbType ) const
55 {
57  if ( QgsWkbTypes::hasZ( inputWkbType ) )
58  out = QgsWkbTypes::addZ( out );
59  if ( QgsWkbTypes::hasM( inputWkbType ) )
60  out = QgsWkbTypes::addM( out );
61  if ( QgsWkbTypes::isMultiType( inputWkbType ) )
62  out = QgsWkbTypes::multiType( out );
63  return out;
64 }
65 
66 QString QgsWedgeBuffersAlgorithm::shortHelpString() const
67 {
68  return QObject::tr( "This algorithm creates wedge shaped buffers from input points.\n\n"
69  "The azimuth parameter gives the angle (in degrees) for the middle of the wedge to point. "
70  "The buffer width (in degrees) is specified by the width parameter. Note that the "
71  "wedge will extend to half of the angular width either side of the azimuth direction.\n\n"
72  "The outer radius of the buffer is specified via outer radius, and optionally an "
73  "inner radius can also be specified.\n\n"
74  "The native output from this algorithm are CurvePolygon geometries, but these may "
75  "be automatically segmentized to Polygons depending on the output format." );
76 }
77 
78 QList<int> QgsWedgeBuffersAlgorithm::inputLayerTypes() const
79 {
80  return QList<int>() << QgsProcessing::TypeVectorPoint;
81 }
82 
83 QgsProcessing::SourceType QgsWedgeBuffersAlgorithm::outputLayerType() const
84 {
86 }
87 
88 QgsWedgeBuffersAlgorithm *QgsWedgeBuffersAlgorithm::createInstance() const
89 {
90  return new QgsWedgeBuffersAlgorithm();
91 }
92 
93 void QgsWedgeBuffersAlgorithm::initParameters( const QVariantMap & )
94 {
95  std::unique_ptr< QgsProcessingParameterNumber > azimuth = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "AZIMUTH" ), QObject::tr( "Azimuth (degrees from North)" ), QgsProcessingParameterNumber::Double, 0, false );
96  azimuth->setIsDynamic( true );
97  azimuth->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "Azimuth" ), QObject::tr( "Azimuth (degrees from North)" ), QgsPropertyDefinition::Double ) );
98  azimuth->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
99  addParameter( azimuth.release() );
100 
101  std::unique_ptr< QgsProcessingParameterNumber > width = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "WIDTH" ), QObject::tr( "Wedge width (in degrees)" ), QgsProcessingParameterNumber::Double, 45, false, 0, 360.0 );
102  width->setIsDynamic( true );
103  width->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "Width" ), QObject::tr( "Wedge width (in degrees)" ), QgsPropertyDefinition::DoublePositive ) );
104  width->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
105  addParameter( width.release() );
106 
107  std::unique_ptr< QgsProcessingParameterNumber > outerRadius = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "OUTER_RADIUS" ), QObject::tr( "Outer radius" ), QgsProcessingParameterNumber::Double, 1, false, 0 );
108  outerRadius->setIsDynamic( true );
109  outerRadius->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "Outer radius" ), QObject::tr( "Outer radius" ), QgsPropertyDefinition::DoublePositive ) );
110  outerRadius->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
111  addParameter( outerRadius.release() );
112 
113  std::unique_ptr< QgsProcessingParameterNumber > innerRadius = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "INNER_RADIUS" ), QObject::tr( "Inner radius" ), QgsProcessingParameterNumber::Double, 0, true, 0 );
114  innerRadius->setIsDynamic( true );
115  innerRadius->setDynamicPropertyDefinition( QgsPropertyDefinition( QStringLiteral( "Inner radius" ), QObject::tr( "Inner radius" ), QgsPropertyDefinition::DoublePositive ) );
116  innerRadius->setDynamicLayerParameterName( QStringLiteral( "INPUT" ) );
117  addParameter( innerRadius.release() );
118 }
119 
120 QgsProcessingFeatureSource::Flag QgsWedgeBuffersAlgorithm::sourceFlags() const
121 {
123 }
124 
125 bool QgsWedgeBuffersAlgorithm::prepareAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback * )
126 {
127  mAzimuth = parameterAsDouble( parameters, QStringLiteral( "AZIMUTH" ), context );
128  mDynamicAzimuth = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "AZIMUTH" ) );
129  if ( mDynamicAzimuth )
130  mAzimuthProperty = parameters.value( QStringLiteral( "AZIMUTH" ) ).value< QgsProperty >();
131 
132  mWidth = parameterAsDouble( parameters, QStringLiteral( "WIDTH" ), context );
133  mDynamicWidth = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "WIDTH" ) );
134  if ( mDynamicWidth )
135  mWidthProperty = parameters.value( QStringLiteral( "WIDTH" ) ).value< QgsProperty >();
136 
137  mOuterRadius = parameterAsDouble( parameters, QStringLiteral( "OUTER_RADIUS" ), context );
138  mDynamicOuterRadius = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "OUTER_RADIUS" ) );
139  if ( mDynamicOuterRadius )
140  mOuterRadiusProperty = parameters.value( QStringLiteral( "OUTER_RADIUS" ) ).value< QgsProperty >();
141 
142  mInnerRadius = parameterAsDouble( parameters, QStringLiteral( "INNER_RADIUS" ), context );
143  mDynamicInnerRadius = QgsProcessingParameters::isDynamic( parameters, QStringLiteral( "INNER_RADIUS" ) );
144  if ( mDynamicInnerRadius )
145  mInnerRadiusProperty = parameters.value( QStringLiteral( "INNER_RADIUS" ) ).value< QgsProperty >();
146 
147  return true;
148 }
149 
150 QgsFeatureList QgsWedgeBuffersAlgorithm::processFeature( const QgsFeature &feature, QgsProcessingContext &context, QgsProcessingFeedback * )
151 {
152  QgsFeature f = feature;
154  {
155  double azimuth = mAzimuth;
156  if ( mDynamicAzimuth )
157  azimuth = mAzimuthProperty.valueAsDouble( context.expressionContext(), azimuth );
158 
159  double width = mWidth;
160  if ( mDynamicWidth )
161  width = mWidthProperty.valueAsDouble( context.expressionContext(), width );
162 
163  double outerRadius = mOuterRadius;
164  if ( mDynamicOuterRadius )
165  outerRadius = mOuterRadiusProperty.valueAsDouble( context.expressionContext(), outerRadius );
166 
167  double innerRadius = mInnerRadius;
168  if ( mDynamicInnerRadius )
169  innerRadius = mInnerRadiusProperty.valueAsDouble( context.expressionContext(), innerRadius );
170 
171  const QgsGeometry g = f.geometry();
172  if ( QgsWkbTypes::isMultiType( g.wkbType() ) )
173  {
174  const QgsMultiPoint *mp = static_cast< const QgsMultiPoint * >( g.constGet() );
175  std::unique_ptr< QgsMultiSurface > result = std::make_unique< QgsMultiSurface >();
176  result->reserve( mp->numGeometries() );
177  for ( int i = 0; i < mp->numGeometries(); ++i )
178  {
179  const QgsPoint *p = mp->pointN( i );
180  result->addGeometry( QgsGeometry::createWedgeBuffer( *p, azimuth, width, outerRadius, innerRadius ).constGet()->clone() );
181  }
182  f.setGeometry( QgsGeometry( std::move( result ) ) );
183  }
184  else
185  {
186  const QgsPoint *p = static_cast< const QgsPoint * >( g.constGet() );
187  f.setGeometry( QgsGeometry::createWedgeBuffer( *p, azimuth, width, outerRadius, innerRadius ) );
188  }
189  }
190 
191  return QgsFeatureList() << f;
192 }
193 
195 
QgsProcessingParameterNumber::Double
@ Double
Double/float values.
Definition: qgsprocessingparameters.h:2187
QgsProperty
A store for object properties.
Definition: qgsproperty.h:230
QgsProcessingParameters::isDynamic
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: qgsprocessingparameters.cpp:114
QgsPoint
Point geometry type, with support for z-dimension and m-values.
Definition: qgspoint.h:48
QgsProcessingFeedback
Base class for providing feedback from a processing algorithm.
Definition: qgsprocessingfeedback.h:37
qgsalgorithmwedgebuffers.h
QgsProcessing::TypeVectorPolygon
@ TypeVectorPolygon
Vector polygon layers.
Definition: qgsprocessing.h:51
QgsWkbTypes::addZ
static Type addZ(Type type) SIP_HOLDGIL
Adds the z dimension to a WKB type and returns the new type.
Definition: qgswkbtypes.h:1176
qgsmultipoint.h
QgsFeature::geometry
QgsGeometry geometry
Definition: qgsfeature.h:71
QgsPropertyDefinition::Double
@ Double
Double value (including negative values)
Definition: qgsproperty.h:57
QgsProcessingFeatureSource::FlagSkipGeometryValidityChecks
@ FlagSkipGeometryValidityChecks
Invalid geometry checks should always be skipped. This flag can be useful for algorithms which always...
Definition: qgsprocessingutils.h:584
QgsWkbTypes::Type
Type
The WKB type describes the number of dimensions a geometry has.
Definition: qgswkbtypes.h:69
QgsWkbTypes::multiType
static Type multiType(Type type) SIP_HOLDGIL
Returns the multi type for a WKB type.
Definition: qgswkbtypes.h:304
QgsProcessing::TypeVectorPoint
@ TypeVectorPoint
Vector point layers.
Definition: qgsprocessing.h:49
QgsGeometryCollection::numGeometries
int numGeometries() const SIP_HOLDGIL
Returns the number of geometries within the collection.
Definition: qgsgeometrycollection.h:58
QgsWkbTypes::addM
static Type addM(Type type) SIP_HOLDGIL
Adds the m dimension to a WKB type and returns the new type.
Definition: qgswkbtypes.h:1201
QgsFeature::setGeometry
void setGeometry(const QgsGeometry &geometry)
Set the feature's geometry.
Definition: qgsfeature.cpp:170
QgsProcessingContext
Contains information about the context in which a processing algorithm is executed.
Definition: qgsprocessingcontext.h:46
QgsWkbTypes::CurvePolygon
@ CurvePolygon
Definition: qgswkbtypes.h:82
QgsFeatureList
QList< QgsFeature > QgsFeatureList
Definition: qgsfeature.h:882
QgsWkbTypes::hasM
static bool hasM(Type type) SIP_HOLDGIL
Tests whether a WKB type contains m values.
Definition: qgswkbtypes.h:1130
QgsPropertyDefinition
Definition for a property.
Definition: qgsproperty.h:46
QgsGeometry::constGet
const QgsAbstractGeometry * constGet() const SIP_HOLDGIL
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
Definition: qgsgeometry.cpp:136
QgsMultiPoint
Multi point geometry collection.
Definition: qgsmultipoint.h:29
QgsMultiPoint::pointN
QgsPoint * pointN(int index)
Returns the point with the specified index.
Definition: qgsmultipoint.cpp:32
QgsWkbTypes::PointGeometry
@ PointGeometry
Definition: qgswkbtypes.h:142
QgsProcessingFeatureSource::Flag
Flag
Flags controlling how QgsProcessingFeatureSource fetches features.
Definition: qgsprocessingutils.h:582
QgsGeometry
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:124
QgsFeature::hasGeometry
bool hasGeometry() const
Returns true if the feature has an associated geometry.
Definition: qgsfeature.cpp:230
QgsProcessingContext::expressionContext
QgsExpressionContext & expressionContext()
Returns the expression context.
Definition: qgsprocessingcontext.h:149
QgsProperty::valueAsDouble
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.
Definition: qgsproperty.cpp:690
QgsWkbTypes::geometryType
static GeometryType geometryType(Type type) SIP_HOLDGIL
Returns the geometry type for a WKB type, e.g., both MultiPolygon and CurvePolygon would have a Polyg...
Definition: qgswkbtypes.h:968
QgsGeometry::createWedgeBuffer
static QgsGeometry createWedgeBuffer(const QgsPoint &center, double azimuth, double angularWidth, double outerRadius, double innerRadius=0)
Creates a wedge shaped buffer from a center point.
Definition: qgsgeometry.cpp:288
QgsWkbTypes::hasZ
static bool hasZ(Type type) SIP_HOLDGIL
Tests whether a WKB type contains the z-dimension.
Definition: qgswkbtypes.h:1080
QgsFeature
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition: qgsfeature.h:55
QgsWkbTypes::isMultiType
static bool isMultiType(Type type) SIP_HOLDGIL
Returns true if the WKB type is a multi type.
Definition: qgswkbtypes.h:862
QgsProcessing::SourceType
SourceType
Data source types enum.
Definition: qgsprocessing.h:45
qgsmultisurface.h
QgsGeometry::wkbType
QgsWkbTypes::Type wkbType() const SIP_HOLDGIL
Returns type of the geometry as a WKB type (point / linestring / polygon etc.)
Definition: qgsgeometry.cpp:357
QgsPropertyDefinition::DoublePositive
@ DoublePositive
Positive double value (including 0)
Definition: qgsproperty.h:58