QGIS API Documentation 3.39.0-Master (67e056379ed)
Loading...
Searching...
No Matches
qgsalgorithmwritevectortiles.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsalgorithmwritevectortiles.h
3 ---------------------
4 Date : April 2020
5 Copyright : (C) 2020 by Martin Dobias
6 Email : wonder dot sk at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
17
19#include "qgsvectorlayer.h"
20#include "qgsvectortilewriter.h"
21#include <QUrl>
22
24
25
26QString QgsWriteVectorTilesBaseAlgorithm::group() const
27{
28 return QObject::tr( "Vector tiles" );
29}
30
31QString QgsWriteVectorTilesBaseAlgorithm::groupId() const
32{
33 return QStringLiteral( "vectortiles" );
34}
35
36QString QgsWriteVectorTilesBaseAlgorithm::shortHelpString() const
37{
38 return QObject::tr( "This algorithm exports one or more vector layers to vector tiles - a data format optimized for fast map rendering and small data size." );
39}
40
41void QgsWriteVectorTilesBaseAlgorithm::addBaseParameters()
42{
43 addParameter( new QgsProcessingParameterVectorTileWriterLayers( QStringLiteral( "LAYERS" ), QObject::tr( "Input layers" ) ) );
44
45 addParameter( new QgsProcessingParameterNumber( QStringLiteral( "MIN_ZOOM" ), QObject::tr( "Minimum zoom level" ), Qgis::ProcessingNumberParameterType::Integer, 0, false, 0, 24 ) );
46 addParameter( new QgsProcessingParameterNumber( QStringLiteral( "MAX_ZOOM" ), QObject::tr( "Maximum zoom level" ), Qgis::ProcessingNumberParameterType::Integer, 3, false, 0, 24 ) );
47
48 // optional extent
49 addParameter( new QgsProcessingParameterExtent( QStringLiteral( "EXTENT" ), QObject::tr( "Extent" ), QVariant(), true ) );
50}
51
52QVariantMap QgsWriteVectorTilesBaseAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
53{
54 const int minZoom = parameterAsInt( parameters, QStringLiteral( "MIN_ZOOM" ), context );
55 const int maxZoom = parameterAsInt( parameters, QStringLiteral( "MAX_ZOOM" ), context );
56
57 const QVariant layersVariant = parameters.value( parameterDefinition( QStringLiteral( "LAYERS" ) )->name() );
58 const QList<QgsVectorTileWriter::Layer> layers = QgsProcessingParameterVectorTileWriterLayers::parameterAsLayers( layersVariant, context );
59
60 for ( const QgsVectorTileWriter::Layer &layer : layers )
61 {
62 if ( !layer.layer() )
63 throw QgsProcessingException( QObject::tr( "Unknown input layer" ) );
64 }
65
67 QVariantMap outputs;
68 prepareWriter( writer, parameters, context, outputs );
69
70 writer.setMinZoom( minZoom );
71 writer.setMaxZoom( maxZoom );
72 writer.setLayers( layers );
73 writer.setTransformContext( context.transformContext() );
74
75 if ( parameters.contains( QStringLiteral( "EXTENT" ) ) )
76 {
77 const QgsRectangle extent = parameterAsExtent( parameters, QStringLiteral( "EXTENT" ), context, QgsCoordinateReferenceSystem( "EPSG:3857" ) );
78 writer.setExtent( extent );
79 }
80
81 const bool res = writer.writeTiles( feedback );
82
83 if ( !res )
84 throw QgsProcessingException( QObject::tr( "Failed to write vector tiles: " ) + writer.errorMessage() );
85
86 return outputs;
87}
88
89//
90// QgsWriteVectorTilesXyzAlgorithm
91//
92
93QString QgsWriteVectorTilesXyzAlgorithm::name() const
94{
95 return QStringLiteral( "writevectortiles_xyz" );
96}
97
98QString QgsWriteVectorTilesXyzAlgorithm::displayName() const
99{
100 return QObject::tr( "Write Vector Tiles (XYZ)" );
101}
102
103QgsProcessingAlgorithm *QgsWriteVectorTilesXyzAlgorithm::createInstance() const
104{
105 return new QgsWriteVectorTilesXyzAlgorithm();
106}
107
108void QgsWriteVectorTilesXyzAlgorithm::initAlgorithm( const QVariantMap & )
109{
110 addParameter( new QgsProcessingParameterFolderDestination( QStringLiteral( "OUTPUT_DIRECTORY" ), QObject::tr( "Output directory" ) ) );
111 addParameter( new QgsProcessingParameterString( QStringLiteral( "XYZ_TEMPLATE" ), QObject::tr( "File template" ), QStringLiteral( "{z}/{x}/{y}.pbf" ) ) );
112
113 addBaseParameters();
114}
115
116void QgsWriteVectorTilesXyzAlgorithm::prepareWriter( QgsVectorTileWriter &writer, const QVariantMap &parameters, QgsProcessingContext &context, QVariantMap &outputs )
117{
118 const QString outputDir = parameterAsString( parameters, QStringLiteral( "OUTPUT_DIRECTORY" ), context );
119 const QString xyzTemplate = parameterAsString( parameters, QStringLiteral( "XYZ_TEMPLATE" ), context );
120 QgsDataSourceUri dsUri;
121 dsUri.setParam( QStringLiteral( "type" ), QStringLiteral( "xyz" ) );
122 dsUri.setParam( QStringLiteral( "url" ), QUrl::fromLocalFile( outputDir + "/" + xyzTemplate ).toString() );
123 const QString uri = dsUri.encodedUri();
124
125 writer.setDestinationUri( uri );
126
127 outputs.insert( QStringLiteral( "OUTPUT_DIRECTORY" ), outputDir );
128}
129
130//
131// QgsWriteVectorTilesMbtilesAlgorithm
132//
133
134QString QgsWriteVectorTilesMbtilesAlgorithm::name() const
135{
136 return QStringLiteral( "writevectortiles_mbtiles" );
137}
138
139QString QgsWriteVectorTilesMbtilesAlgorithm::displayName() const
140{
141 return QObject::tr( "Write Vector Tiles (MBTiles)" );
142}
143
144QgsProcessingAlgorithm *QgsWriteVectorTilesMbtilesAlgorithm::createInstance() const
145{
146 return new QgsWriteVectorTilesMbtilesAlgorithm();
147}
148
149void QgsWriteVectorTilesMbtilesAlgorithm::initAlgorithm( const QVariantMap & )
150{
151 addParameter( new QgsProcessingParameterVectorTileDestination( QStringLiteral( "OUTPUT" ), QObject::tr( "Destination MBTiles" ) ) );
152
153 addBaseParameters();
154
155 // optional metadata for MBTiles
156 addParameter( new QgsProcessingParameterString( QStringLiteral( "META_NAME" ), QObject::tr( "Metadata: Name" ), QVariant(), false, true ) );
157 addParameter( new QgsProcessingParameterString( QStringLiteral( "META_DESCRIPTION" ), QObject::tr( "Metadata: Description" ), QVariant(), false, true ) );
158 addParameter( new QgsProcessingParameterString( QStringLiteral( "META_ATTRIBUTION" ), QObject::tr( "Metadata: Attribution" ), QVariant(), false, true ) );
159 addParameter( new QgsProcessingParameterString( QStringLiteral( "META_VERSION" ), QObject::tr( "Metadata: Version" ), QVariant(), false, true ) );
160 std::unique_ptr< QgsProcessingParameterString > metaTypeParam = std::make_unique< QgsProcessingParameterString >( QStringLiteral( "META_TYPE" ), QObject::tr( "Metadata: Type" ), QVariant(), false, true );
161 metaTypeParam->setMetadata( {{
162 QStringLiteral( "widget_wrapper" ), QVariantMap(
163 {{QStringLiteral( "value_hints" ), QStringList() << QStringLiteral( "overlay" ) << QStringLiteral( "baselayer" ) }}
164 )
165 }
166 } );
167 addParameter( metaTypeParam.release() );
168 addParameter( new QgsProcessingParameterString( QStringLiteral( "META_CENTER" ), QObject::tr( "Metadata: Center" ), QVariant(), false, true ) );
169}
170
171void QgsWriteVectorTilesMbtilesAlgorithm::prepareWriter( QgsVectorTileWriter &writer, const QVariantMap &parameters, QgsProcessingContext &context, QVariantMap &outputs )
172{
173 const QString outputFile = parameterAsFileOutput( parameters, QStringLiteral( "OUTPUT" ), context );
174 QgsDataSourceUri dsUri;
175 dsUri.setParam( QStringLiteral( "type" ), QStringLiteral( "mbtiles" ) );
176 dsUri.setParam( QStringLiteral( "url" ), outputFile );
177 const QString uri = dsUri.encodedUri();
178
179 writer.setDestinationUri( uri );
180
181 const QString metaName = parameterAsString( parameters, QStringLiteral( "META_NAME" ), context );
182 const QString metaDescription = parameterAsString( parameters, QStringLiteral( "META_DESCRIPTION" ), context );
183 const QString metaAttribution = parameterAsString( parameters, QStringLiteral( "META_ATTRIBUTION" ), context );
184 const QString metaVersion = parameterAsString( parameters, QStringLiteral( "META_VERSION" ), context );
185 const QString metaType = parameterAsString( parameters, QStringLiteral( "META_TYPE" ), context );
186 const QString metaCenter = parameterAsString( parameters, QStringLiteral( "META_CENTER" ), context );
187
188 QVariantMap meta;
189 if ( !metaName.isEmpty() )
190 meta["name"] = metaName;
191 if ( !metaDescription.isEmpty() )
192 meta["description"] = metaDescription;
193 if ( !metaAttribution.isEmpty() )
194 meta["attribution"] = metaAttribution;
195 if ( !metaVersion.isEmpty() )
196 meta["version"] = metaVersion;
197 if ( !metaType.isEmpty() )
198 meta["type"] = metaType;
199 if ( !metaCenter.isEmpty() )
200 meta["center"] = metaCenter;
201
202 writer.setMetadata( meta );
203
204 outputs.insert( QStringLiteral( "OUTPUT" ), outputFile );
205}
206
207
This class represents a coordinate reference system (CRS).
Class for storing the component parts of a RDBMS data source URI (e.g.
QByteArray encodedUri() const
Returns the complete encoded URI as a byte array.
void setParam(const QString &key, const QString &value)
Sets a generic parameter value on the URI.
Abstract base class for processing algorithms.
Contains information about the context in which a processing algorithm is executed.
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context.
Custom exception class for processing related exceptions.
Base class for providing feedback from a processing algorithm.
A rectangular map extent parameter for processing algorithms.
A folder destination parameter, for specifying the destination path for a folder created by the algor...
A numeric parameter for processing algorithms.
A string parameter for processing algorithms.
A vector tile layer destination parameter, for specifying the destination path for a vector tile laye...
A parameter for processing algorithms that need a list of input vector layers for writing of vector t...
static QList< QgsVectorTileWriter::Layer > parameterAsLayers(const QVariant &layersVariant, QgsProcessingContext &context)
Converts a QVariant value (a QVariantList) to a list of input layers.
A rectangle specified with double values.
Configuration of a single input vector layer to be included in the output.
Takes care of writing vector tiles.
QString errorMessage() const
Returns error message related to the previous call to writeTiles().
void setMaxZoom(int maxZoom)
Sets the maximum zoom level of tiles. Allowed values are in interval [0,24].
void setDestinationUri(const QString &uri)
Sets where and how the vector tiles will be written.
void setTransformContext(const QgsCoordinateTransformContext &transformContext)
Sets coordinate transform context for transforms between layers and tile matrix CRS.
void setExtent(const QgsRectangle &extent)
Sets extent of vector tile output.
bool writeTiles(QgsFeedback *feedback=nullptr)
Writes vector tiles according to the configuration.
void setLayers(const QList< QgsVectorTileWriter::Layer > &layers)
Sets vector layers and their configuration for output of vector tiles.
void setMinZoom(int minZoom)
Sets the minimum zoom level of tiles. Allowed values are in interval [0,24].
void setMetadata(const QVariantMap &metadata)
Sets that will be written to the output dataset. See class description for more on metadata support.