QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgsalgorithmlayouttopdf.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsalgorithmlayouttopdf.cpp
3 ---------------------
4 begin : June 2020
5 copyright : (C) 2020 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 "qgslayout.h"
20#include "qgslayoutitemmap.h"
21#include "qgsprintlayout.h"
23#include "qgslayoutexporter.h"
24
26
27QString QgsLayoutToPdfAlgorithm::name() const
28{
29 return QStringLiteral( "printlayouttopdf" );
30}
31
32QString QgsLayoutToPdfAlgorithm::displayName() const
33{
34 return QObject::tr( "Export print layout as PDF" );
35}
36
37QStringList QgsLayoutToPdfAlgorithm::tags() const
38{
39 return QObject::tr( "layout,composer,composition,save" ).split( ',' );
40}
41
42QString QgsLayoutToPdfAlgorithm::group() const
43{
44 return QObject::tr( "Cartography" );
45}
46
47QString QgsLayoutToPdfAlgorithm::groupId() const
48{
49 return QStringLiteral( "cartography" );
50}
51
52QString QgsLayoutToPdfAlgorithm::shortDescription() const
53{
54 return QObject::tr( "Exports a print layout as a PDF." );
55}
56
57QString QgsLayoutToPdfAlgorithm::shortHelpString() const
58{
59 return QObject::tr( "This algorithm outputs a print layout as a PDF file." );
60}
61
62void QgsLayoutToPdfAlgorithm::initAlgorithm( const QVariantMap & )
63{
64 addParameter( new QgsProcessingParameterLayout( QStringLiteral( "LAYOUT" ), QObject::tr( "Print layout" ) ) );
65
66 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 );
67 layersParam->setFlags( layersParam->flags() | Qgis::ProcessingParameterFlag::Advanced );
68 addParameter( layersParam.release() );
69
70 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 );
71 dpiParam->setFlags( dpiParam->flags() | Qgis::ProcessingParameterFlag::Advanced );
72 addParameter( dpiParam.release() );
73
74 std::unique_ptr< QgsProcessingParameterBoolean > forceVectorParam = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "FORCE_VECTOR" ), QObject::tr( "Always export as vectors" ), false );
75 forceVectorParam->setFlags( forceVectorParam->flags() | Qgis::ProcessingParameterFlag::Advanced );
76 addParameter( forceVectorParam.release() );
77
78 std::unique_ptr< QgsProcessingParameterBoolean > forceRasterParam = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "FORCE_RASTER" ), QObject::tr( "Always export as raster" ), false );
79 forceRasterParam->setFlags( forceRasterParam->flags() | Qgis::ProcessingParameterFlag::Advanced );
80 addParameter( forceRasterParam.release() );
81
82 std::unique_ptr< QgsProcessingParameterBoolean > appendGeorefParam = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "GEOREFERENCE" ), QObject::tr( "Append georeference information" ), true );
83 appendGeorefParam->setFlags( appendGeorefParam->flags() | Qgis::ProcessingParameterFlag::Advanced );
84 addParameter( appendGeorefParam.release() );
85
86 std::unique_ptr< QgsProcessingParameterBoolean > exportRDFParam = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "INCLUDE_METADATA" ), QObject::tr( "Export RDF metadata (title, author, etc.)" ), true );
87 exportRDFParam->setFlags( exportRDFParam->flags() | Qgis::ProcessingParameterFlag::Advanced );
88 addParameter( exportRDFParam.release() );
89
90 std::unique_ptr< QgsProcessingParameterBoolean > disableTiled = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "DISABLE_TILED" ), QObject::tr( "Disable tiled raster layer exports" ), false );
91 disableTiled->setFlags( disableTiled->flags() | Qgis::ProcessingParameterFlag::Advanced );
92 addParameter( disableTiled.release() );
93
94 std::unique_ptr< QgsProcessingParameterBoolean > simplify = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "SIMPLIFY" ), QObject::tr( "Simplify geometries to reduce output file size" ), true );
95 simplify->setFlags( simplify->flags() | Qgis::ProcessingParameterFlag::Advanced );
96 addParameter( simplify.release() );
97
98 const QStringList textExportOptions
99 {
100 QObject::tr( "Always Export Text as Paths (Recommended)" ),
101 QObject::tr( "Always Export Text as Text Objects" ),
102 QObject::tr( "Prefer Exporting Text as Text Objects" )
103 };
104
105 std::unique_ptr< QgsProcessingParameterEnum > textFormat = std::make_unique< QgsProcessingParameterEnum >( QStringLiteral( "TEXT_FORMAT" ), QObject::tr( "Text export" ), textExportOptions, false, 0 );
106 textFormat->setFlags( textFormat->flags() | Qgis::ProcessingParameterFlag::Advanced );
107 addParameter( textFormat.release() );
108
109 const QStringList imageCompressionOptions
110 {
111 QObject::tr( "Lossy (JPEG)" ),
112 QObject::tr( "Lossless" )
113 };
114
115 std::unique_ptr< QgsProcessingParameterEnum > imageCompression = std::make_unique< QgsProcessingParameterEnum >( QStringLiteral( "IMAGE_COMPRESSION" ), QObject::tr( "Image compression" ), imageCompressionOptions, false, 0 );
116 imageCompression->setFlags( imageCompression->flags() | Qgis::ProcessingParameterFlag::Advanced );
117 addParameter( imageCompression.release() );
118
119 std::unique_ptr< QgsProcessingParameterBoolean > layeredExport = std::make_unique< QgsProcessingParameterBoolean >( QStringLiteral( "SEPARATE_LAYERS" ), QObject::tr( "Export layers as separate PDF files" ), false );
120 layeredExport->setFlags( layeredExport->flags() | Qgis::ProcessingParameterFlag::Advanced );
121 addParameter( layeredExport.release() );
122
123 addParameter( new QgsProcessingParameterFileDestination( QStringLiteral( "OUTPUT" ), QObject::tr( "PDF file" ), QObject::tr( "PDF Format" ) + " (*.pdf *.PDF)" ) );
124}
125
126Qgis::ProcessingAlgorithmFlags QgsLayoutToPdfAlgorithm::flags() const
127{
129}
130
131QgsLayoutToPdfAlgorithm *QgsLayoutToPdfAlgorithm::createInstance() const
132{
133 return new QgsLayoutToPdfAlgorithm();
134}
135
136QVariantMap QgsLayoutToPdfAlgorithm::processAlgorithm( const QVariantMap &parameters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
137{
138 // this needs to be done in main thread, layouts are not thread safe
139 QgsPrintLayout *l = parameterAsLayout( parameters, QStringLiteral( "LAYOUT" ), context );
140 if ( !l )
141 throw QgsProcessingException( QObject::tr( "Cannot find layout with name \"%1\"" ).arg( parameters.value( QStringLiteral( "LAYOUT" ) ).toString() ) );
142 std::unique_ptr< QgsPrintLayout > layout( l->clone() );
143
144 const QList< QgsMapLayer * > layers = parameterAsLayerList( parameters, QStringLiteral( "LAYERS" ), context );
145 if ( layers.size() > 0 )
146 {
147 const QList<QGraphicsItem *> items = layout->items();
148 for ( QGraphicsItem *graphicsItem : items )
149 {
150 QgsLayoutItem *item = dynamic_cast<QgsLayoutItem *>( graphicsItem );
151 QgsLayoutItemMap *map = dynamic_cast<QgsLayoutItemMap *>( item );
152 if ( map && !map->followVisibilityPreset() && !map->keepLayerSet() )
153 {
154 map->setKeepLayerSet( true );
155 map->setLayers( layers );
156 }
157 }
158 }
159
160 const QString dest = parameterAsFileOutput( parameters, QStringLiteral( "OUTPUT" ), context );
161
162 QgsLayoutExporter exporter( layout.get() );
164
165 if ( parameters.value( QStringLiteral( "DPI" ) ).isValid() )
166 {
167 settings.dpi = parameterAsDouble( parameters, QStringLiteral( "DPI" ), context );
168 }
169
170 settings.forceVectorOutput = parameterAsBool( parameters, QStringLiteral( "FORCE_VECTOR" ), context );
171 settings.rasterizeWholeImage = parameterAsBool( parameters, QStringLiteral( "FORCE_RASTER" ), context );
172 settings.appendGeoreference = parameterAsBool( parameters, QStringLiteral( "GEOREFERENCE" ), context );
173 settings.exportMetadata = parameterAsBool( parameters, QStringLiteral( "INCLUDE_METADATA" ), context );
174 settings.simplifyGeometries = parameterAsBool( parameters, QStringLiteral( "SIMPLIFY" ), context );
175 const int textFormat = parameterAsEnum( parameters, QStringLiteral( "TEXT_FORMAT" ), context );
176 switch ( textFormat )
177 {
178 case 0:
180 break;
181 case 1:
183 break;
184 case 2:
186 break;
187 default:
188 break;
189 }
190 settings.exportLayersAsSeperateFiles = parameterAsBool( parameters, QStringLiteral( "SEPARATE_LAYERS" ), context ); //#spellok
191
192 if ( parameterAsBool( parameters, QStringLiteral( "DISABLE_TILED" ), context ) )
194 else
195 settings.flags = settings.flags & ~QgsLayoutRenderContext::FlagDisableTiledRasterLayerRenders;
196
197 if ( parameterAsEnum( parameters, QStringLiteral( "IMAGE_COMPRESSION" ), context ) == 1 )
199 else
200 settings.flags = settings.flags & ~QgsLayoutRenderContext::FlagLosslessImageRendering;
201
202 switch ( exporter.exportToPdf( dest, settings ) )
203 {
205 {
206 feedback->pushInfo( QObject::tr( "Successfully exported layout to %1" ).arg( QDir::toNativeSeparators( dest ) ) );
207 break;
208 }
209
211 throw QgsProcessingException( !exporter.errorMessage().isEmpty() ? exporter.errorMessage() : QObject::tr( "Cannot write to %1.\n\nThis file may be open in another application." ).arg( QDir::toNativeSeparators( dest ) ) );
212
214 throw QgsProcessingException( !exporter.errorMessage().isEmpty() ? exporter.errorMessage() : QObject::tr( "Could not create print device." ) );
215
217 throw QgsProcessingException( !exporter.errorMessage().isEmpty() ? exporter.errorMessage() : QObject::tr( "Exporting the PDF "
218 "resulted in a memory overflow.\n\n"
219 "Please try a lower resolution or a smaller paper size." ) );
220
224 // no meaning for PDF exports, will not be encountered
225 break;
226 }
227
228 feedback->setProgress( 100 );
229
230 QVariantMap outputs;
231 outputs.insert( QStringLiteral( "OUTPUT" ), dest );
232 return outputs;
233}
234
236
@ MapLayer
Any map layer type (raster, vector, mesh, point cloud, annotation or plugin layer)
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
Handles rendering and exports of layouts to various formats.
@ 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.
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...
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.
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
A print layout parameter, allowing users to select a print layout.
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.
bool exportLayersAsSeperateFiles
true if individual layers from the layout should be rendered to separate PDF files.
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....