28int tile2tms(
const int y,
const int zoom )
30 double n = std::pow( 2, zoom );
31 return (
int )std::floor( n - y - 1 );
34int lon2tileX(
const double lon,
const int z )
36 return (
int )( std::floor( ( lon + 180.0 ) / 360.0 * ( 1 << z ) ) );
39int lat2tileY(
const double lat,
const int z )
41 double latRad = lat * M_PI / 180.0;
42 return (
int )( std::floor( ( 1.0 - std::asinh( std::tan( latRad ) ) / M_PI ) / 2.0 * ( 1 << z ) ) );
45double tileX2lon(
const int x,
const int z )
47 return x / ( double )( 1 << z ) * 360.0 - 180 ;
50double tileY2lat(
const int y,
const int z )
52 double n = M_PI - 2.0 * M_PI * y / ( double )( 1 << z );
53 return 180.0 / M_PI * std::atan( 0.5 * ( std::exp( n ) - std::exp( -n ) ) );
56void extent2TileXY(
QgsRectangle extent,
const int zoom,
int &xMin,
int &yMin,
int &xMax,
int &yMax )
58 xMin = lon2tileX( extent.
xMinimum(), zoom );
59 yMin = lat2tileY( extent.
yMinimum(), zoom );
60 xMax = lon2tileX( extent.
xMaximum(), zoom );
61 yMax = lat2tileY( extent.
xMaximum(), zoom );
64QList< MetaTile > getMetatiles(
const QgsRectangle extent,
const int zoom,
const int tileSize )
66 int minX = lon2tileX( extent.
xMinimum(), zoom );
67 int minY = lat2tileY( extent.
yMaximum(), zoom );
68 int maxX = lon2tileX( extent.
xMaximum(), zoom );
69 int maxY = lat2tileY( extent.
yMinimum(), zoom );;
72 QMap< QString, MetaTile > tiles;
73 for (
int x = minX; x <= maxX; x++ )
76 for (
int y = minY; y <= maxY; y++ )
78 QString key = QStringLiteral(
"%1:%2" ).arg( (
int )( i / tileSize ) ).arg( (
int )( j / tileSize ) );
79 MetaTile tile = tiles.value( key, MetaTile() );
80 tile.addTile( i % tileSize, j % tileSize, Tile( x, y, zoom ) );
81 tiles.insert( key, tile );
86 return tiles.values();
91QString QgsXyzTilesBaseAlgorithm::group()
const
93 return QObject::tr(
"Raster tools" );
96QString QgsXyzTilesBaseAlgorithm::groupId()
const
98 return QStringLiteral(
"rastertools" );
101QgsProcessingAlgorithm::Flags QgsXyzTilesBaseAlgorithm::flags()
const
106void QgsXyzTilesBaseAlgorithm::createCommonParameters()
112 addParameter(
new QgsProcessingParameterColor( QStringLiteral(
"BACKGROUND_COLOR" ), QObject::tr(
"Background color" ), QColor( Qt::transparent ),
true,
true ) );
114 addParameter(
new QgsProcessingParameterEnum( QStringLiteral(
"TILE_FORMAT" ), QObject::tr(
"Tile format" ), QStringList() << QStringLiteral(
"PNG" ) << QStringLiteral(
"JPG" ),
false, 0 ) );
121 Q_UNUSED( feedback );
126 QSet< QString > visibleLayers;
129 if ( layer->isVisible() )
131 visibleLayers << layer->layer()->id();
138 if ( visibleLayers.contains( layer->id() ) )
141 clonedLayer->moveToThread(
nullptr );
142 mLayers << clonedLayer;
146 QgsRectangle extent = parameterAsExtent( parameters, QStringLiteral(
"EXTENT" ), context );
149 mExtent = ct.transformBoundingBox( extent );
151 mMinZoom = parameterAsInt( parameters, QStringLiteral(
"ZOOM_MIN" ), context );
152 mMaxZoom = parameterAsInt( parameters, QStringLiteral(
"ZOOM_MAX" ), context );
153 mDpi = parameterAsInt( parameters, QStringLiteral(
"DPI" ), context );
154 mBackgroundColor = parameterAsColor( parameters, QStringLiteral(
"BACKGROUND_COLOR" ), context );
155 if ( mTileFormat != QLatin1String(
"PNG" ) && mBackgroundColor.alpha() != 255 )
157 feedback->
pushWarning( QObject::tr(
"Background color setting ignored, the JPG format only supports fully opaque colors" ) );
159 mAntialias = parameterAsBool( parameters, QStringLiteral(
"ANTIALIAS" ), context );
160 mTileFormat = parameterAsEnum( parameters, QStringLiteral(
"TILE_FORMAT" ), context ) ? QStringLiteral(
"JPG" ) : QStringLiteral(
"PNG" );
161 mJpgQuality = parameterAsInt( parameters, QStringLiteral(
"QUALITY" ), context );
162 mMetaTileSize = parameterAsInt( parameters, QStringLiteral(
"METATILESIZE" ), context );
165 mFeedback = feedback;
172 mWgs84Extent = mSrc2Wgs.transformBoundingBox( mExtent );
174 if ( parameters.contains( QStringLiteral(
"TILE_WIDTH" ) ) )
176 mTileWidth = parameterAsInt( parameters, QStringLiteral(
"TILE_WIDTH" ), context );
179 if ( parameters.contains( QStringLiteral(
"TILE_HEIGHT" ) ) )
181 mTileHeight = parameterAsInt( parameters, QStringLiteral(
"TILE_HEIGHT" ), context );
187void QgsXyzTilesBaseAlgorithm::startJobs()
189 while ( mRendererJobs.size() < mThreadsNumber && !mMetaTiles.empty() )
191 MetaTile metaTile = mMetaTiles.takeFirst();
194 settings.
setExtent( mWgs2Mercator.transformBoundingBox( metaTile.extent() ) );
200 if ( mTileFormat == QLatin1String(
"PNG" ) || mBackgroundColor.alpha() == 255 )
204 QSize size( mTileWidth * metaTile.rows, mTileHeight * metaTile.cols );
216 mRendererJobs.insert( job, metaTile );
224QString QgsXyzTilesDirectoryAlgorithm::name()
const
226 return QStringLiteral(
"tilesxyzdirectory" );
229QString QgsXyzTilesDirectoryAlgorithm::displayName()
const
231 return QObject::tr(
"Generate XYZ tiles (Directory)" );
234QStringList QgsXyzTilesDirectoryAlgorithm::tags()
const
236 return QObject::tr(
"tiles,xyz,tms,directory" ).split(
',' );
239QString QgsXyzTilesDirectoryAlgorithm::shortHelpString()
const
241 return QObject::tr(
"Generates XYZ tiles of map canvas content and saves them as individual images in a directory." );
244QgsXyzTilesDirectoryAlgorithm *QgsXyzTilesDirectoryAlgorithm::createInstance()
const
246 return new QgsXyzTilesDirectoryAlgorithm();
249void QgsXyzTilesDirectoryAlgorithm::initAlgorithm(
const QVariantMap & )
251 createCommonParameters();
254 addParameter(
new QgsProcessingParameterBoolean( QStringLiteral(
"TMS_CONVENTION" ), QObject::tr(
"Use inverted tile Y axis (TMS convention)" ),
false,
true ) );
256 std::unique_ptr< QgsProcessingParameterString > titleParam = std::make_unique< QgsProcessingParameterString >( QStringLiteral(
"HTML_TITLE" ), QObject::tr(
"Leaflet HTML output title" ), QVariant(),
false,
true );
258 addParameter( titleParam.release() );
259 std::unique_ptr< QgsProcessingParameterString > attributionParam = std::make_unique< QgsProcessingParameterString >( QStringLiteral(
"HTML_ATTRIBUTION" ), QObject::tr(
"Leaflet HTML output attribution" ), QVariant(),
false,
true );
261 addParameter( attributionParam.release() );
262 std::unique_ptr< QgsProcessingParameterBoolean > osmParam = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral(
"HTML_OSM" ), QObject::tr(
"Include OpenStreetMap basemap in Leaflet HTML output" ),
false,
true );
264 addParameter( osmParam.release() );
267 addParameter(
new QgsProcessingParameterFileDestination( QStringLiteral(
"OUTPUT_HTML" ), QObject::tr(
"Output html (Leaflet)" ), QObject::tr(
"HTML files (*.html)" ), QVariant(),
true ) );
272 const bool tms = parameterAsBoolean( parameters, QStringLiteral(
"TMS_CONVENTION" ), context );
273 const QString title = parameterAsString( parameters, QStringLiteral(
"HTML_TITLE" ), context );
274 const QString attribution = parameterAsString( parameters, QStringLiteral(
"HTML_ATTRIBUTION" ), context );
275 const bool useOsm = parameterAsBoolean( parameters, QStringLiteral(
"HTML_OSM" ), context );
276 QString outputDir = parameterAsString( parameters, QStringLiteral(
"OUTPUT_DIRECTORY" ), context );
277 const QString outputHtml = parameterAsString( parameters, QStringLiteral(
"OUTPUT_HTML" ), context );
279 mOutputDir = outputDir;
282 for (
int z = mMinZoom; z <= mMaxZoom; z++ )
287 mMetaTiles += getMetatiles( mWgs84Extent, z, mMetaTileSize );
290 for (
QgsMapLayer *layer : std::as_const( mLayers ) )
292 layer->moveToThread( QThread::currentThread() );
295 mTotalTiles = mMetaTiles.size();
303 qDeleteAll( mLayers );
307 results.insert( QStringLiteral(
"OUTPUT_DIRECTORY" ), outputDir );
309 if ( !outputHtml.isEmpty() )
311 QString osm = QStringLiteral(
312 "var osm_layer = L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png',"
313 "{minZoom: %1, maxZoom: %2, attribution: '© <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a> contributors'}).addTo(map);" )
314 .arg( mMinZoom ).arg( mMaxZoom );
316 QString addOsm = useOsm ? osm : QString();
317 QString tmsConvention = tms ? QStringLiteral(
"true" ) : QStringLiteral(
"false" );
318 QString attr = attribution.isEmpty() ? QStringLiteral(
"Created by QGIS" ) : attribution;
319 QString tileSource = QStringLiteral(
"'file:///%1/{z}/{x}/{y}.%2'" )
320 .arg( outputDir.replace(
"\\",
"/" ).toHtmlEscaped() ).arg( mTileFormat.toLower() );
322 QString html = QStringLiteral(
323 "<!DOCTYPE html><html><head><title>%1</title><meta charset=\"utf-8\"/>"
324 "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">"
325 "<link rel=\"stylesheet\" href=\"https://unpkg.com/[email protected]/dist/leaflet.css\""
326 "integrity=\"sha384-o/2yZuJZWGJ4s/adjxVW71R+EO/LyCwdQfP5UWSgX/w87iiTXuvDZaejd3TsN7mf\""
329 "integrity=\"sha384-okbbMvvx/qfQkmiQKfd5VifbKZ/W8p1qIsWvE1ROPUfHWsDcC8/BnHohF7vPg2T6\""
330 "crossorigin=\"\"></script>"
331 "<style type=\"text/css\">body {margin: 0;padding: 0;} html, body, #map{width: 100%;height: 100%;}</style></head>"
332 "<body><div id=\"map\"></div><script>"
333 "var map = L.map('map', {attributionControl: false}).setView([%2, %3], %4);"
334 "L.control.attribution({prefix: false}).addTo(map);"
336 "var tilesource_layer = L.tileLayer(%6, {minZoom: %7, maxZoom: %8, tms: %9, attribution: '%10'}).addTo(map);"
337 "</script></body></html>"
339 .arg( title.isEmpty() ? QStringLiteral(
"Leaflet preview" ) : title )
340 .arg( mWgs84Extent.center().y() )
341 .arg( mWgs84Extent.center().x() )
342 .arg( ( mMaxZoom + mMinZoom ) / 2 )
347 .arg( tmsConvention )
350 QFile htmlFile( outputHtml );
351 if ( !htmlFile.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
355 QTextStream fout( &htmlFile );
356#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
357 fout.setCodec(
"UTF-8" );
361 results.insert( QStringLiteral(
"OUTPUT_HTML" ), outputHtml );
369 MetaTile metaTile = mRendererJobs.value( job );
372 QMap<QPair<int, int>, Tile>::const_iterator it = metaTile.tiles.constBegin();
373 while ( it != metaTile.tiles.constEnd() )
375 QPair<int, int> tm = it.key();
376 Tile tile = it.value();
377 QImage tileImage = img.copy( mTileWidth * tm.first, mTileHeight * tm.second, mTileWidth, mTileHeight );
378 QDir tileDir( QStringLiteral(
"%1/%2/%3" ).arg( mOutputDir ).arg( tile.z ).arg( tile.x ) );
379 tileDir.mkpath( tileDir.absolutePath() );
383 y = tile2tms( y, tile.z );
385 tileImage.save( QStringLiteral(
"%1/%2.%3" ).arg( tileDir.absolutePath() ).arg( y ).arg( mTileFormat.toLower() ), mTileFormat.toStdString().c_str(), mJpgQuality );
389 mRendererJobs.remove( job );
392 mFeedback->setProgress( 100.0 * ( mProcessedTiles++ ) / mTotalTiles );
394 if ( mFeedback->isCanceled() )
396 while ( mRendererJobs.size() > 0 )
400 mRendererJobs.remove( j );
403 mRendererJobs.clear();
408 if ( mMetaTiles.size() > 0 )
412 else if ( mMetaTiles.size() == 0 && mRendererJobs.size() == 0 )
420QString QgsXyzTilesMbtilesAlgorithm::name()
const
422 return QStringLiteral(
"tilesxyzmbtiles" );
425QString QgsXyzTilesMbtilesAlgorithm::displayName()
const
427 return QObject::tr(
"Generate XYZ tiles (MBTiles)" );
430QStringList QgsXyzTilesMbtilesAlgorithm::tags()
const
432 return QObject::tr(
"tiles,xyz,tms,mbtiles" ).split(
',' );
435QString QgsXyzTilesMbtilesAlgorithm::shortHelpString()
const
437 return QObject::tr(
"Generates XYZ tiles of map canvas content and saves them as an MBTiles file." );
440QgsXyzTilesMbtilesAlgorithm *QgsXyzTilesMbtilesAlgorithm::createInstance()
const
442 return new QgsXyzTilesMbtilesAlgorithm();
445void QgsXyzTilesMbtilesAlgorithm::initAlgorithm(
const QVariantMap & )
447 createCommonParameters();
453 const QString outputFile = parameterAsString( parameters, QStringLiteral(
"OUTPUT_FILE" ), context );
455 mMbtilesWriter = std::make_unique<QgsMbTiles>( outputFile );
456 if ( !mMbtilesWriter->create() )
460 mMbtilesWriter->setMetadataValue(
"format", mTileFormat.toLower() );
461 mMbtilesWriter->setMetadataValue(
"name", QFileInfo( outputFile ).baseName() );
462 mMbtilesWriter->setMetadataValue(
"version", QStringLiteral(
"1.1" ) );
463 mMbtilesWriter->setMetadataValue(
"type", QStringLiteral(
"overlay" ) );
464 mMbtilesWriter->setMetadataValue(
"minzoom", QString::number( mMinZoom ) );
465 mMbtilesWriter->setMetadataValue(
"maxzoom", QString::number( mMaxZoom ) );
466 QString boundsStr = QString(
"%1,%2,%3,%4" )
467 .arg( mWgs84Extent.xMinimum() ).arg( mWgs84Extent.yMinimum() )
468 .arg( mWgs84Extent.xMaximum() ).arg( mWgs84Extent.yMaximum() );
469 mMbtilesWriter->setMetadataValue(
"bounds", boundsStr );
471 for (
int z = mMinZoom; z <= mMaxZoom; z++ )
476 mMetaTiles += getMetatiles( mWgs84Extent, z, mMetaTileSize );
479 mTotalTiles = mMetaTiles.size();
488 results.insert( QStringLiteral(
"OUTPUT_FILE" ), outputFile );
494 MetaTile metaTile = mRendererJobs.value( job );
497 QMap<QPair<int, int>, Tile>::const_iterator it = metaTile.tiles.constBegin();
498 while ( it != metaTile.tiles.constEnd() )
500 QPair<int, int> tm = it.key();
501 Tile tile = it.value();
502 QImage tileImage = img.copy( mTileWidth * tm.first, mTileHeight * tm.second, mTileWidth, mTileHeight );
504 QBuffer buffer( &ba );
505 buffer.open( QIODevice::WriteOnly );
506 tileImage.save( &buffer, mTileFormat.toStdString().c_str(), mJpgQuality );
507 mMbtilesWriter->setTileData( tile.z, tile.x, tile2tms( tile.y, tile.z ), ba );
511 mRendererJobs.remove( job );
514 mFeedback->setProgress( 100.0 * ( mProcessedTiles++ ) / mTotalTiles );
516 if ( mFeedback->isCanceled() )
518 while ( mRendererJobs.size() > 0 )
522 mRendererJobs.remove( j );
525 mRendererJobs.clear();
530 if ( mMetaTiles.size() > 0 )
534 else if ( mMetaTiles.size() == 0 && mRendererJobs.size() == 0 )
@ UsePartialCandidates
Whether to use also label candidates that are partially outside of the map view.
This class represents a coordinate reference system (CRS).
static QgsExpressionContextScope * mapSettingsScope(const QgsMapSettings &mapSettings)
Creates a new scope which contains variables and functions relating to a QgsMapSettings object.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
bool isCanceled() const
Tells whether the operation has been canceled already.
Stores global configuration for labeling engine.
void setFlag(Qgis::LabelingFlag f, bool enabled=true)
Sets whether a particual flag is enabled.
QList< QgsLayerTreeLayer * > findLayers() const
Find all layer nodes.
Layer tree node points to a map layer.
QList< QgsMapLayer * > layerOrder() const
The order in which layers will be rendered on the canvas.
Base class for all map layer types.
virtual QgsMapLayer * clone() const =0
Returns a new instance equivalent to this one except for the id which is still unique.
void finished()
emitted when asynchronous rendering is finished (or canceled).
void start()
Start the rendering job and immediately return.
Job implementation that renders everything sequentially in one thread.
QImage renderedImage() override
Gets a preview/resulting image.
void cancel() override
Stop the rendering job - does not return until the job has terminated.
The QgsMapSettings class contains configuration for rendering of the map.
const QgsLabelingEngineSettings & labelingEngineSettings() const
Returns the global configuration of the labeling engine.
void setLayers(const QList< QgsMapLayer * > &layers)
Sets the list of layers to render in the map.
void setOutputDpi(double dpi)
Sets the dpi (dots per inch) used for conversion between real world units (e.g.
void setOutputImageFormat(QImage::Format format)
sets format of internal QImage
void setExtent(const QgsRectangle &rect, bool magnified=true)
Sets the coordinates of the rectangle which should be rendered.
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
void setLabelingEngineSettings(const QgsLabelingEngineSettings &settings)
Sets the global configuration of the labeling engine.
void setTransformContext(const QgsCoordinateTransformContext &context)
Sets the coordinate transform context, which stores various information regarding which datum transfo...
void setOutputSize(QSize size)
Sets the size of the resulting map image, in pixels.
void setBackgroundColor(const QColor &color)
Sets the background color of the map.
void setDestinationCrs(const QgsCoordinateReferenceSystem &crs)
Sets the destination crs (coordinate reference system) for the map render.
const QgsExpressionContext & expressionContext() const
Gets the expression context.
virtual Flags flags() const
Returns the flags indicating how and when the algorithm operates and should be exposed to users.
@ FlagRequiresProject
The algorithm requires that a valid QgsProject is available from the processing context in order to e...
Contains information about the context in which a processing algorithm is executed.
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context.
QgsProject * project() const
Returns the project in which the algorithm is being executed.
int maximumThreads() const
Returns the (optional) number of threads to use when running algorithms.
Custom exception class for processing related exceptions.
Base class for providing feedback from a processing algorithm.
virtual void pushWarning(const QString &warning)
Pushes a warning informational message from the algorithm.
A boolean parameter for processing algorithms.
A color parameter for processing algorithms.
@ FlagAdvanced
Parameter is an advanced parameter which should be hidden from users by default.
An enum based parameter for processing algorithms, allowing for selection from predefined values.
A rectangular map extent parameter for processing algorithms.
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
A folder destination parameter, for specifying the destination path for a folder created by the algor...
A numeric parameter for processing algorithms.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
QgsLayerTree * layerTreeRoot() const
Returns pointer to the root (invisible) node of the project's layer tree.
QgsCoordinateReferenceSystem crs
A rectangle specified with double values.
double xMinimum() const
Returns the x minimum value (left side of rectangle).
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
double xMaximum() const
Returns the x maximum value (right side of rectangle).
double yMaximum() const
Returns the y maximum value (top side of rectangle).