QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgsalgorithmlayoutatlastopdf.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsalgorithmlayoutatlastopdf.cpp
3 ---------------------
4 begin : August 2020
5 copyright : (C) 2020 by Mathieu Pellerin
6 email : nirvn dot asia 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 "qgslayout.h"
20#include "qgslayoutatlas.h"
21#include "qgslayoutitemmap.h"
22#include "qgslayoututils.h"
23#include "qgsprintlayout.h"
25#include "qgslayoutexporter.h"
26
28
29// QgsLayoutAtlasToPdfAlgorithmBase
30
31QStringList QgsLayoutAtlasToPdfAlgorithmBase::tags() const
32{
33 return QObject::tr( "layout,atlas,composer,composition,save" ).split( ',' );
34}
35
36QString QgsLayoutAtlasToPdfAlgorithmBase::group() const
37{
38 return QObject::tr( "Cartography" );
39}
40
41QString QgsLayoutAtlasToPdfAlgorithmBase::groupId() const
42{
43 return QStringLiteral( "cartography" );
44}
45
46Qgis::ProcessingAlgorithmFlags QgsLayoutAtlasToPdfAlgorithmBase::flags() const
47{
49}
50
51void QgsLayoutAtlasToPdfAlgorithmBase::initAlgorithm( const QVariantMap & )
52{
53 addParameter( new QgsProcessingParameterLayout( QStringLiteral( "LAYOUT" ), QObject::tr( "Atlas layout" ) ) );
54
55 addParameter( new QgsProcessingParameterVectorLayer( QStringLiteral( "COVERAGE_LAYER" ), QObject::tr( "Coverage layer" ), QList< int >(), QVariant(), true ) );
56 addParameter( new QgsProcessingParameterExpression( QStringLiteral( "FILTER_EXPRESSION" ), QObject::tr( "Filter expression" ), QString(), QStringLiteral( "COVERAGE_LAYER" ), true ) );
57 addParameter( new QgsProcessingParameterExpression( QStringLiteral( "SORTBY_EXPRESSION" ), QObject::tr( "Sort expression" ), QString(), QStringLiteral( "COVERAGE_LAYER" ), true ) );
58 addParameter( new QgsProcessingParameterBoolean( QStringLiteral( "SORTBY_REVERSE" ), QObject::tr( "Reverse sort order (used when a sort expression is provided)" ), false, true ) );
59
60 std::unique_ptr< QgsProcessingParameterMultipleLayers > layersParam = std::make_unique< QgsProcessingParameterMultipleLayers>( QStringLiteral( "LAYERS" ), QObject::tr( "Map layers to assign to unlocked map item(s)" ), Qgis::ProcessingSourceType::MapLayer, QVariant(), true );
61 layersParam->setFlags( layersParam->flags() | Qgis::ProcessingParameterFlag::Advanced );
62 addParameter( layersParam.release() );
63
64 std::unique_ptr< QgsProcessingParameterNumber > dpiParam = std::make_unique< QgsProcessingParameterNumber >( QStringLiteral( "DPI" ), QObject::tr( "DPI (leave blank for default layout DPI)" ), Qgis::ProcessingNumberParameterType::Double, QVariant(), true, 0 );
65 dpiParam->setFlags( dpiParam->flags() | Qgis::ProcessingParameterFlag::Advanced );
66 addParameter( dpiParam.release() );
67
68 std::unique_ptr< QgsProcessingParameterBoolean > forceVectorParam = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "FORCE_VECTOR" ), QObject::tr( "Always export as vectors" ), false );
69 forceVectorParam->setFlags( forceVectorParam->flags() | Qgis::ProcessingParameterFlag::Advanced );
70 addParameter( forceVectorParam.release() );
71
72 std::unique_ptr< QgsProcessingParameterBoolean > forceRasterParam = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "FORCE_RASTER" ), QObject::tr( "Always export as raster" ), false );
73 forceRasterParam->setFlags( forceRasterParam->flags() | Qgis::ProcessingParameterFlag::Advanced );
74 addParameter( forceRasterParam.release() );
75
76 std::unique_ptr< QgsProcessingParameterBoolean > appendGeorefParam = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "GEOREFERENCE" ), QObject::tr( "Append georeference information" ), true );
77 appendGeorefParam->setFlags( appendGeorefParam->flags() | Qgis::ProcessingParameterFlag::Advanced );
78 addParameter( appendGeorefParam.release() );
79
80 std::unique_ptr< QgsProcessingParameterBoolean > exportRDFParam = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "INCLUDE_METADATA" ), QObject::tr( "Export RDF metadata (title, author, etc.)" ), true );
81 exportRDFParam->setFlags( exportRDFParam->flags() | Qgis::ProcessingParameterFlag::Advanced );
82 addParameter( exportRDFParam.release() );
83
84 std::unique_ptr< QgsProcessingParameterBoolean > disableTiled = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "DISABLE_TILED" ), QObject::tr( "Disable tiled raster layer exports" ), false );
85 disableTiled->setFlags( disableTiled->flags() | Qgis::ProcessingParameterFlag::Advanced );
86 addParameter( disableTiled.release() );
87
88 std::unique_ptr< QgsProcessingParameterBoolean > simplify = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "SIMPLIFY" ), QObject::tr( "Simplify geometries to reduce output file size" ), true );
89 simplify->setFlags( simplify->flags() | Qgis::ProcessingParameterFlag::Advanced );
90 addParameter( simplify.release() );
91
92 const QStringList textExportOptions
93 {
94 QObject::tr( "Always Export Text as Paths (Recommended)" ),
95 QObject::tr( "Always Export Text as Text Objects" ),
96 QObject::tr( "Prefer Exporting Text as Text Objects" ),
97 };
98
99 std::unique_ptr< QgsProcessingParameterEnum > textFormat = std::make_unique< QgsProcessingParameterEnum >( QStringLiteral( "TEXT_FORMAT" ), QObject::tr( "Text export" ), textExportOptions, false, 0 );
100 textFormat->setFlags( textFormat->flags() | Qgis::ProcessingParameterFlag::Advanced );
101 addParameter( textFormat.release() );
102
103 const QStringList imageCompressionOptions
104 {
105 QObject::tr( "Lossy (JPEG)" ),
106 QObject::tr( "Lossless" )
107 };
108
109 std::unique_ptr< QgsProcessingParameterEnum > imageCompression = std::make_unique< QgsProcessingParameterEnum >( QStringLiteral( "IMAGE_COMPRESSION" ), QObject::tr( "Image compression" ), imageCompressionOptions, false, 0 );
110 imageCompression->setFlags( imageCompression->flags() | Qgis::ProcessingParameterFlag::Advanced );
111 addParameter( imageCompression.release() );
112}
113
114QVariantMap QgsLayoutAtlasToPdfAlgorithmBase::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
115{
116 // this needs to be done in main thread, layouts are not thread safe
117 QgsPrintLayout *l = parameterAsLayout( parameters, QStringLiteral( "LAYOUT" ), context );
118 if ( !l )
119 throw QgsProcessingException( QObject::tr( "Cannot find layout with name \"%1\"" ).arg( parameters.value( QStringLiteral( "LAYOUT" ) ).toString() ) );
120
121 std::unique_ptr< QgsPrintLayout > layout( l->clone() );
122 QgsLayoutAtlas *atlas = layout->atlas();
123
124 QString expression, error;
125 QgsVectorLayer *layer = parameterAsVectorLayer( parameters, QStringLiteral( "COVERAGE_LAYER" ), context );
126 if ( layer )
127 {
128 atlas->setEnabled( true );
129 atlas->setCoverageLayer( layer );
130
131 expression = parameterAsString( parameters, QStringLiteral( "FILTER_EXPRESSION" ), context );
132 atlas->setFilterExpression( expression, error );
133 atlas->setFilterFeatures( !expression.isEmpty() && error.isEmpty() );
134 if ( !expression.isEmpty() && !error.isEmpty() )
135 {
136 throw QgsProcessingException( QObject::tr( "Error setting atlas filter expression" ) );
137 }
138 error.clear();
139
140 expression = parameterAsString( parameters, QStringLiteral( "SORTBY_EXPRESSION" ), context );
141 if ( !expression.isEmpty() )
142 {
143 const bool sortByReverse = parameterAsBool( parameters, QStringLiteral( "SORTBY_REVERSE" ), context );
144 atlas->setSortFeatures( true );
145 atlas->setSortExpression( expression );
146 atlas->setSortAscending( !sortByReverse );
147 }
148 else
149 {
150 atlas->setSortFeatures( false );
151 }
152 }
153 else if ( !atlas->enabled() )
154 {
155 throw QgsProcessingException( QObject::tr( "Selected layout does not have atlas functionality enabled" ) );
156 }
157
158 const QgsLayoutExporter exporter( layout.get() );
160
161 if ( parameters.value( QStringLiteral( "DPI" ) ).isValid() )
162 {
163 settings.dpi = parameterAsDouble( parameters, QStringLiteral( "DPI" ), context );
164 }
165 settings.forceVectorOutput = parameterAsBool( parameters, QStringLiteral( "FORCE_VECTOR" ), context );
166 settings.rasterizeWholeImage = parameterAsBool( parameters, QStringLiteral( "FORCE_RASTER" ), context );
167 settings.appendGeoreference = parameterAsBool( parameters, QStringLiteral( "GEOREFERENCE" ), context );
168 settings.exportMetadata = parameterAsBool( parameters, QStringLiteral( "INCLUDE_METADATA" ), context );
169 settings.simplifyGeometries = parameterAsBool( parameters, QStringLiteral( "SIMPLIFY" ), context );
170 const int textFormat = parameterAsEnum( parameters, QStringLiteral( "TEXT_FORMAT" ), context );
171 switch ( textFormat )
172 {
173 case 0:
175 break;
176 case 1:
178 break;
179 case 2:
181 break;
182 default:
183 break;
184 }
185
186 if ( parameterAsBool( parameters, QStringLiteral( "DISABLE_TILED" ), context ) )
188 else
189 settings.flags = settings.flags & ~QgsLayoutRenderContext::FlagDisableTiledRasterLayerRenders;
190
191 if ( parameterAsEnum( parameters, QStringLiteral( "IMAGE_COMPRESSION" ), context ) == 1 )
193 else
194 settings.flags = settings.flags & ~QgsLayoutRenderContext::FlagLosslessImageRendering;
195
196 settings.predefinedMapScales = QgsLayoutUtils::predefinedScales( layout.get() );
197
198 const QList< QgsMapLayer * > layers = parameterAsLayerList( parameters, QStringLiteral( "LAYERS" ), context );
199 if ( layers.size() > 0 )
200 {
201 const QList<QGraphicsItem *> items = layout->items();
202 for ( QGraphicsItem *graphicsItem : items )
203 {
204 QgsLayoutItem *item = dynamic_cast<QgsLayoutItem *>( graphicsItem );
205 QgsLayoutItemMap *map = dynamic_cast<QgsLayoutItemMap *>( item );
206 if ( map && !map->followVisibilityPreset() && !map->keepLayerSet() )
207 {
208 map->setKeepLayerSet( true );
209 map->setLayers( layers );
210 }
211 }
212 }
213
214 return exportAtlas( atlas, exporter, settings, parameters, context, feedback );
215}
216
217//
218// QgsLayoutAtlasToPdfAlgorithm
219//
220
221QString QgsLayoutAtlasToPdfAlgorithm::name() const
222{
223 return QStringLiteral( "atlaslayouttopdf" );
224}
225
226QString QgsLayoutAtlasToPdfAlgorithm::displayName() const
227{
228 return QObject::tr( "Export atlas layout as PDF (single file)" );
229}
230
231QString QgsLayoutAtlasToPdfAlgorithm::shortDescription() const
232{
233 return QObject::tr( "Exports an atlas layout as a single PDF file." );
234}
235
236QString QgsLayoutAtlasToPdfAlgorithm::shortHelpString() const
237{
238 return QObject::tr( "This algorithm outputs an atlas layout as a single PDF file.\n\n"
239 "If a coverage layer is set, the selected layout's atlas settings exposed in this algorithm "
240 "will be overwritten. In this case, an empty filter or sort by expression will turn those "
241 "settings off." );
242}
243
244void QgsLayoutAtlasToPdfAlgorithm::initAlgorithm( const QVariantMap & )
245{
246 QgsLayoutAtlasToPdfAlgorithmBase::initAlgorithm();
247 addParameter( new QgsProcessingParameterFileDestination( QStringLiteral( "OUTPUT" ), QObject::tr( "PDF file" ), QObject::tr( "PDF Format" ) + " (*.pdf *.PDF)" ) );
248}
249
250QgsLayoutAtlasToPdfAlgorithm *QgsLayoutAtlasToPdfAlgorithm::createInstance() const
251{
252 return new QgsLayoutAtlasToPdfAlgorithm();
253}
254
255QVariantMap QgsLayoutAtlasToPdfAlgorithm::exportAtlas( QgsLayoutAtlas *atlas, const QgsLayoutExporter &exporter, const QgsLayoutExporter::PdfExportSettings &settings,
256 const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
257{
258 Q_UNUSED( exporter )
259
260 const QString dest = parameterAsFileOutput( parameters, QStringLiteral( "OUTPUT" ), context );
261
262 QString error;
263 if ( atlas->updateFeatures() )
264 {
265 feedback->pushInfo( QObject::tr( "Exporting %n atlas feature(s)", "", atlas->count() ) );
266 switch ( QgsLayoutExporter::exportToPdf( atlas, dest, settings, error, feedback ) )
267 {
269 {
270 feedback->pushInfo( QObject::tr( "Successfully exported atlas to %1" ).arg( QDir::toNativeSeparators( dest ) ) );
271 break;
272 }
273
275 throw QgsProcessingException( !error.isEmpty() ? error : QObject::tr( "Cannot write to %1.\n\nThis file may be open in another application." ).arg( QDir::toNativeSeparators( dest ) ) );
276
278 throw QgsProcessingException( !error.isEmpty() ? error : QObject::tr( "Could not create print device." ) );
279
281 throw QgsProcessingException( !error.isEmpty() ? error : QObject::tr( "Trying to create the image "
282 "resulted in a memory overflow.\n\n"
283 "Please try a lower resolution or a smaller paper size." ) );
284
286 throw QgsProcessingException( !error.isEmpty() ? error : QObject::tr( "Error encountered while exporting atlas." ) );
287
290 // no meaning for PDF exports, will not be encountered
291 break;
292 }
293 }
294 else
295 {
296 feedback->reportError( QObject::tr( "No atlas features found" ) );
297 }
298
299 feedback->setProgress( 100 );
300
301 QVariantMap outputs;
302 outputs.insert( QStringLiteral( "OUTPUT" ), dest );
303 return outputs;
304}
305
306//
307// QgsLayoutAtlasToMultiplePdfAlgorithm
308//
309
310QString QgsLayoutAtlasToMultiplePdfAlgorithm::name() const
311{
312 return QStringLiteral( "atlaslayouttomultiplepdf" );
313}
314
315QString QgsLayoutAtlasToMultiplePdfAlgorithm::displayName() const
316{
317 return QObject::tr( "Export atlas layout as PDF (multiple files)" );
318}
319
320QString QgsLayoutAtlasToMultiplePdfAlgorithm::shortDescription() const
321{
322 return QObject::tr( "Exports an atlas layout to multiple PDF files." );
323}
324
325QString QgsLayoutAtlasToMultiplePdfAlgorithm::shortHelpString() const
326{
327 return QObject::tr( "This algorithm outputs an atlas layout to multiple PDF files.\n\n"
328 "If a coverage layer is set, the selected layout's atlas settings exposed in this algorithm "
329 "will be overwritten. In this case, an empty filter or sort by expression will turn those "
330 "settings off.\n"
331 );
332}
333
334void QgsLayoutAtlasToMultiplePdfAlgorithm::initAlgorithm( const QVariantMap & )
335{
336 QgsLayoutAtlasToPdfAlgorithmBase::initAlgorithm();
337 addParameter( new QgsProcessingParameterExpression( QStringLiteral( "OUTPUT_FILENAME" ), QObject::tr( "Output filename" ), QString(), QStringLiteral( "COVERAGE_LAYER" ), true ) );
338 addParameter( new QgsProcessingParameterFile( QStringLiteral( "OUTPUT_FOLDER" ), QObject::tr( "Output folder" ), Qgis::ProcessingFileParameterBehavior::Folder ) );
339}
340
341QgsLayoutAtlasToMultiplePdfAlgorithm *QgsLayoutAtlasToMultiplePdfAlgorithm::createInstance() const
342{
343 return new QgsLayoutAtlasToMultiplePdfAlgorithm();
344}
345
346QVariantMap QgsLayoutAtlasToMultiplePdfAlgorithm::exportAtlas( QgsLayoutAtlas *atlas, const QgsLayoutExporter &exporter, const QgsLayoutExporter::PdfExportSettings &settings,
347 const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
348{
349 Q_UNUSED( exporter )
350
351 QString error;
352
353 const QString filename = parameterAsString( parameters, QStringLiteral( "OUTPUT_FILENAME" ), context );
354 const QString destFolder = parameterAsFile( parameters, QStringLiteral( "OUTPUT_FOLDER" ), context );
355
356 // the "atlas.pdf" part will be overridden, only the folder is important
357 const QString dest = QStringLiteral( "%1/atlas.pdf" ).arg( destFolder );
358
359 if ( atlas->updateFeatures() )
360 {
361 feedback->pushInfo( QObject::tr( "Exporting %n atlas feature(s)", "", atlas->count() ) );
362
364 if ( atlas->filenameExpression().isEmpty() && filename.isEmpty() )
365 {
366 atlas->setFilenameExpression( QStringLiteral( "'output_'||@atlas_featurenumber" ), error );
367 }
368 else if ( !filename.isEmpty() )
369 {
370 if ( !atlas->setFilenameExpression( filename, error ) )
371 {
372 throw QgsProcessingException( QObject::tr( "Output file name expression is not valid: %1" ).arg( error ) );
373 }
374 }
375
376 result = QgsLayoutExporter::exportToPdfs( atlas, dest, settings, error, feedback );
377
378 switch ( result )
379 {
381 {
382 feedback->pushInfo( QObject::tr( "Successfully exported atlas to %1" ).arg( QDir::toNativeSeparators( destFolder ) ) );
383 break;
384 }
385
387 throw QgsProcessingException( !error.isEmpty() ? error : QObject::tr( "Cannot write to %1.\n\nThis file may be open in another application." ).arg( QDir::toNativeSeparators( dest ) ) );
388
390 throw QgsProcessingException( !error.isEmpty() ? error : QObject::tr( "Could not create print device." ) );
391
393 throw QgsProcessingException( !error.isEmpty() ? error : QObject::tr( "Trying to create the image "
394 "resulted in a memory overflow.\n\n"
395 "Please try a lower resolution or a smaller paper size." ) );
396
398 throw QgsProcessingException( !error.isEmpty() ? error : QObject::tr( "Error encountered while exporting atlas." ) );
399
402 // no meaning for PDF exports, will not be encountered
403 break;
404 }
405 }
406 else
407 {
408 feedback->reportError( QObject::tr( "No atlas features found" ) );
409 }
410
411 feedback->setProgress( 100 );
412
413 QVariantMap outputs;
414 outputs.insert( QStringLiteral( "OUTPUT_FOLDER" ), destFolder );
415 return outputs;
416}
417
419
@ MapLayer
Any map layer type (raster, vector, mesh, point cloud, annotation or plugin layer)
@ Folder
Parameter is a folder.
QFlags< ProcessingAlgorithmFlag > ProcessingAlgorithmFlags
Flags indicating how and when an algorithm operates and should be exposed to users.
Definition qgis.h:3339
@ PreferText
Render text as text objects, unless doing so results in rendering artifacts or poor quality rendering...
@ AlwaysOutlines
Always render text using path objects (AKA outlines/curves). This setting guarantees the best quality...
@ AlwaysText
Always render text as text objects. While this mode preserves text objects as text for post-processin...
@ NoThreading
Algorithm is not thread safe and cannot be run in a background thread, e.g. for algorithms which mani...
@ RequiresProject
The algorithm requires that a valid QgsProject is available from the processing context in order to e...
@ Advanced
Parameter is an advanced parameter which should be hidden from users by default.
void setProgress(double progress)
Sets the current progress for the feedback object.
Definition qgsfeedback.h:61
Class used to render QgsLayout as an atlas, by iterating over the features from an associated vector ...
QString filenameExpression() const
Returns the filename expression used for generating output filenames for each atlas page.
void setCoverageLayer(QgsVectorLayer *layer)
Sets the coverage layer to use for the atlas features.
bool setFilterExpression(const QString &expression, QString &errorString)
Sets the expression used for filtering features in the coverage layer.
void setSortAscending(bool ascending)
Sets whether features should be sorted in an ascending order.
void setEnabled(bool enabled)
Sets whether the atlas is enabled.
bool enabled() const
Returns whether the atlas generation is enabled.
bool setFilenameExpression(const QString &expression, QString &errorString)
Sets the filename expression used for generating output filenames for each atlas page.
void setSortFeatures(bool enabled)
Sets whether features should be sorted in the atlas.
int count() const override
Returns the number of features to iterate over.
void setSortExpression(const QString &expression)
Sets the expression (or field name) to use for sorting features.
void setFilterFeatures(bool filtered)
Sets whether features should be filtered in the coverage layer.
int updateFeatures()
Requeries the current atlas coverage layer and applies filtering and sorting.
Handles rendering and exports of layouts to various formats.
ExportResult exportToPdf(const QString &filePath, const QgsLayoutExporter::PdfExportSettings &settings)
Exports the layout as a PDF to the filePath, using the specified export settings.
ExportResult
Result codes for exporting layouts.
@ Canceled
Export was canceled.
@ MemoryError
Unable to allocate memory required to export.
@ PrintError
Could not start printing to destination device.
@ IteratorError
Error iterating over layout.
@ FileError
Could not write to destination file, likely due to a lock held by another application.
@ Success
Export was successful.
@ SvgLayerError
Could not create layered SVG file.
static ExportResult exportToPdfs(QgsAbstractLayoutIterator *iterator, const QString &baseFilePath, const QgsLayoutExporter::PdfExportSettings &settings, QString &error, QgsFeedback *feedback=nullptr)
Exports a layout iterator to multiple PDF files, with the specified export settings.
Layout graphical items for displaying a map.
bool keepLayerSet() const
Returns whether a stored layer set should be used or the current layer set from the project associate...
void setKeepLayerSet(bool enabled)
Sets whether the stored layer set should be used or the current layer set of the associated project.
bool followVisibilityPreset() const
Returns whether the map should follow a map theme.
void setLayers(const QList< QgsMapLayer * > &layers)
Sets the stored layers set.
Base class for graphical items within a QgsLayout.
Stores information relating to the current rendering settings for a layout.
@ FlagLosslessImageRendering
Render images losslessly whenever possible, instead of the default lossy jpeg rendering used for some...
@ FlagDisableTiledRasterLayerRenders
If set, then raster layers will not be drawn as separate tiles. This may improve the appearance in ex...
static QVector< double > predefinedScales(const QgsLayout *layout)
Returns a list of predefined scales associated with a layout.
Print layout, a QgsLayout subclass for static or atlas-based layouts.
QgsPrintLayout * clone() const override
Creates a clone of the layout.
virtual Qgis::ProcessingAlgorithmFlags flags() const
Returns the flags indicating how and when the algorithm operates and should be exposed to users.
Contains information about the context in which a processing algorithm is executed.
Custom exception class for processing related exceptions.
Base class for providing feedback from a processing algorithm.
virtual void pushInfo(const QString &info)
Pushes a general informational message from the algorithm.
virtual void reportError(const QString &error, bool fatalError=false)
Reports that the algorithm encountered an error while executing.
A boolean parameter for processing algorithms.
An expression parameter for processing algorithms.
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
An input file or folder parameter for processing algorithms.
A print layout parameter, allowing users to select a print layout.
A vector layer (with or without geometry) parameter for processing algorithms.
Represents a vector layer which manages a vector based data sets.
Contains settings relating to exporting layouts to PDF.
bool forceVectorOutput
Set to true to force vector object exports, even when the resultant appearance will differ from the l...
bool rasterizeWholeImage
Set to true to force whole layout to be rasterized while exporting.
bool exportMetadata
Indicates whether PDF export should include metadata generated from the layout's project's metadata.
bool appendGeoreference
Indicates whether PDF export should append georeference data.
QgsLayoutRenderContext::Flags flags
Layout context flags, which control how the export will be created.
double dpi
Resolution to export layout at. If dpi <= 0 the default layout dpi will be used.
QVector< qreal > predefinedMapScales
A list of predefined scales to use with the layout.
bool simplifyGeometries
Indicates whether vector geometries should be simplified to avoid redundant extraneous detail,...
Qgis::TextRenderFormat textRenderFormat
Text rendering format, which controls how text should be rendered in the export (e....