QGIS API Documentation  3.27.0-Master (0e23467727)
qgsalgorithmextentfromlayer.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsalgorithmextentfromlayer.cpp
3  ---------------------
4  begin : November 2019
5  copyright : (C) 2019 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 
19 #include "qgsapplication.h"
20 #include "qgsvectorlayer.h"
21 
23 
24 QString QgsExtentFromLayerAlgorithm::name() const
25 {
26  return QStringLiteral( "polygonfromlayerextent" );
27 }
28 
29 QString QgsExtentFromLayerAlgorithm::displayName() const
30 {
31  return QObject::tr( "Extract layer extent" );
32 }
33 
34 QStringList QgsExtentFromLayerAlgorithm::tags() const
35 {
36  return QObject::tr( "polygon,vector,raster,extent,envelope,bounds,bounding,boundary,layer,round,rounded" ).split( ',' );
37 }
38 
39 QString QgsExtentFromLayerAlgorithm::group() const
40 {
41  return QObject::tr( "Layer tools" );
42 }
43 
44 QString QgsExtentFromLayerAlgorithm::groupId() const
45 {
46  return QStringLiteral( "layertools" );
47 }
48 
49 QString QgsExtentFromLayerAlgorithm::shortHelpString() const
50 {
51  return QObject::tr( "This algorithm takes a map layer and generates a new vector "
52  "layer with the minimum bounding box (rectangle polygon with "
53  "N-S orientation) that covers the input layer. Optionally, the "
54  "extent can be enlarged to a rounded value." );
55 }
56 
57 QString QgsExtentFromLayerAlgorithm::svgIconPath() const
58 {
59  return QgsApplication::iconPath( QStringLiteral( "/algorithms/mAlgorithmExtractLayerExtent.svg" ) );
60 }
61 
62 QIcon QgsExtentFromLayerAlgorithm::icon() const
63 {
64  return QgsApplication::getThemeIcon( QStringLiteral( "/algorithms/mAlgorithmExtractLayerExtent.svg" ) );
65 }
66 
67 QgsExtentFromLayerAlgorithm *QgsExtentFromLayerAlgorithm::createInstance() const
68 {
69  return new QgsExtentFromLayerAlgorithm();
70 }
71 
72 void QgsExtentFromLayerAlgorithm::initAlgorithm( const QVariantMap & )
73 {
74  addParameter( new QgsProcessingParameterMapLayer( QStringLiteral( "INPUT" ), QObject::tr( "Input layer" ) ) );
75 
76  auto roundParam = std::make_unique < QgsProcessingParameterDistance >( QStringLiteral( "ROUND_TO" ), QObject::tr( "Round values to" ), 0, QStringLiteral( "INPUT" ), 0 );
77  roundParam->setFlags( QgsProcessingParameterDefinition::FlagAdvanced );
78  addParameter( roundParam.release() );
79 
80  addParameter( new QgsProcessingParameterFeatureSink( QStringLiteral( "OUTPUT" ), QObject::tr( "Extent" ), QgsProcessing::TypeVectorPolygon ) );
81 }
82 
83 QVariantMap QgsExtentFromLayerAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback * )
84 {
85  QgsMapLayer *layer = parameterAsLayer( parameters, QStringLiteral( "INPUT" ), context );
86 
87  if ( !layer )
88  throw QgsProcessingException( QObject::tr( "Invalid input layer" ) );
89 
90  const double roundTo = parameterAsDouble( parameters, QStringLiteral( "ROUND_TO" ), context );
91 
92  QgsFields fields;
93  fields.append( QgsField( QStringLiteral( "MINX" ), QVariant::Double ) );
94  fields.append( QgsField( QStringLiteral( "MINY" ), QVariant::Double ) );
95  fields.append( QgsField( QStringLiteral( "MAXX" ), QVariant::Double ) );
96  fields.append( QgsField( QStringLiteral( "MAXY" ), QVariant::Double ) );
97  fields.append( QgsField( QStringLiteral( "CNTX" ), QVariant::Double ) );
98  fields.append( QgsField( QStringLiteral( "CNTY" ), QVariant::Double ) );
99  fields.append( QgsField( QStringLiteral( "AREA" ), QVariant::Double ) );
100  fields.append( QgsField( QStringLiteral( "PERIM" ), QVariant::Double ) );
101  fields.append( QgsField( QStringLiteral( "HEIGHT" ), QVariant::Double ) );
102  fields.append( QgsField( QStringLiteral( "WIDTH" ), QVariant::Double ) );
103 
104  QString dest;
105  std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest, fields, QgsWkbTypes::Polygon, layer->crs() ) );
106  if ( !sink )
107  throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
108 
109  if ( QgsVectorLayer *vl = qobject_cast< QgsVectorLayer * >( layer ) )
110  {
111  vl->updateExtents();
112  }
113 
114  QgsRectangle rect = layer->extent();
115 
116  if ( roundTo > 0 )
117  {
118  rect.setXMinimum( std::floor( rect.xMinimum() / roundTo ) * roundTo );
119  rect.setYMinimum( std::floor( rect.yMinimum() / roundTo ) * roundTo );
120  rect.setXMaximum( std::ceil( rect.xMaximum() / roundTo ) * roundTo );
121  rect.setYMaximum( std::ceil( rect.yMaximum() / roundTo ) * roundTo );
122  }
123 
124  const QgsGeometry geom = QgsGeometry::fromRect( rect );
125 
126  const double minX = rect.xMinimum();
127  const double maxX = rect.xMaximum();
128  const double minY = rect.yMinimum();
129  const double maxY = rect.yMaximum();
130  const double height = rect.height();
131  const double width = rect.width();
132  const double cntX = minX + width / 2.0;
133  const double cntY = minY + height / 2.0;
134  const double area = width * height;
135  const double perim = 2 * width + 2 * height;
136 
137  QgsFeature feat;
138  feat.setGeometry( geom );
139  feat.setAttributes( QgsAttributes() << minX << minY << maxX << maxY << cntX << cntY << area << perim << height << width );
140  if ( !sink->addFeature( feat, QgsFeatureSink::FastInsert ) )
141  throw QgsProcessingException( writeFeatureError( sink.get(), parameters, QStringLiteral( "OUTPUT" ) ) );
142 
143  QVariantMap outputs;
144  outputs.insert( QStringLiteral( "OUTPUT" ), dest );
145  return outputs;
146 }
147 
static QIcon getThemeIcon(const QString &name, const QColor &fillColor=QColor(), const QColor &strokeColor=QColor())
Helper to get a theme icon.
static QString iconPath(const QString &iconFile)
Returns path to the desired icon file.
A vector of attributes.
Definition: qgsattributes.h:58
@ FastInsert
Use faster inserts, at the cost of updating the passed features to reflect changes made at the provid...
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition: qgsfeature.h:56
void setAttributes(const QgsAttributes &attrs)
Sets the feature's attributes.
Definition: qgsfeature.cpp:153
void setGeometry(const QgsGeometry &geometry)
Set the feature's geometry.
Definition: qgsfeature.cpp:163
Encapsulate a field in an attribute table or data source.
Definition: qgsfield.h:51
Container of fields for a vector layer.
Definition: qgsfields.h:45
bool append(const QgsField &field, FieldOrigin origin=OriginProvider, int originIndex=-1)
Appends a field. The field must have unique name, otherwise it is rejected (returns false)
Definition: qgsfields.cpp:59
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:125
static QgsGeometry fromRect(const QgsRectangle &rect) SIP_HOLDGIL
Creates a new geometry from a QgsRectangle.
Base class for all map layer types.
Definition: qgsmaplayer.h:73
virtual QgsRectangle extent() const
Returns the extent of the layer.
QgsCoordinateReferenceSystem crs
Definition: qgsmaplayer.h:79
Contains information about the context in which a processing algorithm is executed.
Custom exception class for processing related exceptions.
Definition: qgsexception.h:83
Base class for providing feedback from a processing algorithm.
@ FlagAdvanced
Parameter is an advanced parameter which should be hidden from users by default.
A feature sink output for processing algorithms.
A map layer parameter for processing algorithms.
@ TypeVectorPolygon
Vector polygon layers.
Definition: qgsprocessing.h:51
A rectangle specified with double values.
Definition: qgsrectangle.h:42
double yMaximum() const SIP_HOLDGIL
Returns the y maximum value (top side of rectangle).
Definition: qgsrectangle.h:193
double xMaximum() const SIP_HOLDGIL
Returns the x maximum value (right side of rectangle).
Definition: qgsrectangle.h:183
double xMinimum() const SIP_HOLDGIL
Returns the x minimum value (left side of rectangle).
Definition: qgsrectangle.h:188
double yMinimum() const SIP_HOLDGIL
Returns the y minimum value (bottom side of rectangle).
Definition: qgsrectangle.h:198
void setYMinimum(double y) SIP_HOLDGIL
Set the minimum y value.
Definition: qgsrectangle.h:161
void setXMaximum(double x) SIP_HOLDGIL
Set the maximum x value.
Definition: qgsrectangle.h:156
void setXMinimum(double x) SIP_HOLDGIL
Set the minimum x value.
Definition: qgsrectangle.h:151
double height() const SIP_HOLDGIL
Returns the height of the rectangle.
Definition: qgsrectangle.h:230
void setYMaximum(double y) SIP_HOLDGIL
Set the maximum y value.
Definition: qgsrectangle.h:166
double width() const SIP_HOLDGIL
Returns the width of the rectangle.
Definition: qgsrectangle.h:223
Represents a vector layer which manages a vector based data sets.