QGIS API Documentation 3.40.0-Bratislava (b56115d8743)
Loading...
Searching...
No Matches
qgswmsgetlegendgraphics.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgswmsgetlegendgraphics.cpp
3 -------------------------
4 begin : December 20 , 2016
5 copyright : (C) 2007 by Marco Hugentobler (original code)
6 (C) 2014 by Alessandro Pasotti (original code)
7 (C) 2016 by David Marteau
8 email : marco dot hugentobler at karto dot baug dot ethz dot ch
9 a dot pasotti at itopen dot it
10 david dot marteau at 3liz dot com
11 ***************************************************************************/
12
13/***************************************************************************
14 * *
15 * This program is free software; you can redistribute it and/or modify *
16 * it under the terms of the GNU General Public License as published by *
17 * the Free Software Foundation; either version 2 of the License, or *
18 * (at your option) any later version. *
19 * *
20 ***************************************************************************/
21#include "qgslayertree.h"
22#include "qgslegendrenderer.h"
23#include "qgsvectorlayer.h"
26
27#include "qgswmsutils.h"
28#include "qgswmsrequest.h"
31#include "qgswmsrenderer.h"
33#include "qgsmapsettings.h"
34
35#include <QImage>
36#include <QJsonObject>
37#include <QJsonDocument>
38
39namespace QgsWms
40{
41 void writeGetLegendGraphics( QgsServerInterface *serverIface, const QgsProject *project,
42 const QgsWmsRequest &request,
43 QgsServerResponse &response )
44 {
45 // get parameters from query
46 QgsWmsParameters parameters = request.wmsParameters();
47
48 // check parameters validity
49 // FIXME fail with png + mode
50 checkParameters( parameters );
51
52 // init render context
53 QgsWmsRenderContext context( project, serverIface );
56 context.setParameters( parameters );
57 context.setSocketFeedback( response.feedback() );
58
59 // get the requested output format
60 QgsWmsParameters::Format format = parameters.format();
61
62 // parameters.format() returns NONE if the requested format is image/png with a
63 // mode (e.g. image/png;mode=16bit), so in that case we use parseImageFormat to
64 // give the requested format another chance
65
66 QString imageSaveFormat;
67 QString imageContentType;
68 if ( format == QgsWmsParameters::Format::PNG )
69 {
70 imageContentType = "image/png";
71 imageSaveFormat = "PNG";
72 }
73 else if ( format == QgsWmsParameters::Format::JPG )
74 {
75 imageContentType = "image/jpeg";
76 imageSaveFormat = "JPEG";
77 }
78 else if ( format == QgsWmsParameters::Format::NONE )
79 {
80 switch ( parseImageFormat( parameters.formatAsString() ) )
81 {
87 imageContentType = "image/png";
88 imageSaveFormat = "PNG";
89 break;
91 break;
92
93 // not possible
96 break;
97 }
98 }
99
100 if ( format == QgsWmsParameters::Format::NONE )
101 {
103 QStringLiteral( "Output format '%1' is not supported in the GetLegendGraphic request" ).arg( parameters.formatAsString() ) );
104 }
105
106 // Get cached image
107#ifdef HAVE_SERVER_PYTHON_PLUGINS
108 QgsAccessControl *accessControl = serverIface->accessControls();
109 QgsServerCacheManager *cacheManager = serverIface->cacheManager();
110 if ( cacheManager && !imageSaveFormat.isEmpty() )
111 {
112 QImage image;
113 const QByteArray content = cacheManager->getCachedImage( project, request, accessControl );
114 if ( !content.isEmpty() && image.loadFromData( content ) )
115 {
116 response.setHeader( QStringLiteral( "Content-Type" ), imageContentType );
117 image.save( response.io(), qPrintable( imageSaveFormat ) );
118 return;
119 }
120 }
121#endif
122 QgsRenderer renderer( context );
123
124 // retrieve legend settings and model
125 bool addLegendGroups = QgsServerProjectUtils::wmsAddLegendGroupsLegendGraphic( *project ) || parameters.addLayerGroups();
126 std::unique_ptr<QgsLayerTree> tree( addLegendGroups ? layerTreeWithGroups( context, QgsProject::instance()->layerTreeRoot() ) : layerTree( context ) );
127 const std::unique_ptr<QgsLayerTreeModel> model( legendModel( context, *tree.get() ) );
128
129 // rendering
130 if ( format == QgsWmsParameters::Format::JSON )
131 {
132 QJsonObject result;
133
135
136 if ( parameters.showRuleDetailsAsBool() )
137 {
139 }
140
141 if ( !parameters.rule().isEmpty() )
142 {
143 QgsLayerTreeModelLegendNode *node = legendNode( parameters.rule(), *model.get() );
144 if ( ! node )
145 {
146 throw QgsException( QStringLiteral( "Could not get a legend node for the requested RULE" ) );
147 }
148 result = renderer.getLegendGraphicsAsJson( *node, jsonFlags );
149 }
150 else
151 {
152 result = renderer.getLegendGraphicsAsJson( *model.get(), jsonFlags );
153 }
154 tree->clear();
155 response.setHeader( QStringLiteral( "Content-Type" ), parameters.formatAsString() );
156 const QJsonDocument doc( result );
157 response.write( doc.toJson( QJsonDocument::Compact ) );
158 }
159 else
160 {
161 std::unique_ptr<QImage> result;
162 if ( !parameters.rule().isEmpty() )
163 {
164 QgsLayerTreeModelLegendNode *node = legendNode( parameters.rule(), *model.get() );
165 if ( ! node )
166 {
167 throw QgsException( QStringLiteral( "Could not get a legend node for the requested RULE" ) );
168 }
169 result.reset( renderer.getLegendGraphics( *node ) );
170 }
171 else
172 {
173 result.reset( renderer.getLegendGraphics( *model.get() ) );
174 }
175 tree->clear();
176 if ( result )
177 {
178 writeImage( response, *result, parameters.formatAsString(), context.imageQuality() );
179#ifdef HAVE_SERVER_PYTHON_PLUGINS
180 if ( cacheManager )
181 {
182 const QByteArray content = response.data();
183 if ( !content.isEmpty() )
184 cacheManager->setCachedImage( &content, project, request, accessControl );
185 }
186#endif
187 }
188 else
189 {
190 throw QgsException( QStringLiteral( "Failed to compute GetLegendGraphics image" ) );
191 }
192 }
193 }
194
196 {
197 if ( parameters.allLayersNickname().isEmpty() )
198 {
200 parameters[QgsWmsParameter::LAYERS] );
201 }
202
203 if ( parameters.format() == QgsWmsParameters::Format::NONE )
204 {
206 parameters[QgsWmsParameter::FORMAT] );
207 }
208
209 if ( ! parameters.bbox().isEmpty() && !parameters.rule().isEmpty() )
210 {
212 QStringLiteral( "BBOX parameter cannot be combined with RULE." ) );
213 }
214
215 if ( ! parameters.bbox().isEmpty() && parameters.bboxAsRectangle().isEmpty() )
216 {
218 parameters[QgsWmsParameter::BBOX] );
219 }
220 // If we have a contextual legend (BBOX is set)
221 // make sure (SRC)WIDTH and (SRC)HEIGHT are set, default to 800px width
222 // height is calculated from that value, respecting the aspect
223 if ( ! parameters.bbox().isEmpty() )
224 {
225 // Calculate ratio from bbox
226 QgsRectangle bbox { parameters.bboxAsRectangle() };
227 const QString crs = parameters.crs();
228 if ( crs.compare( QStringLiteral( "CRS:84" ), Qt::CaseInsensitive ) == 0 )
229 {
230 bbox.invert();
231 }
233 if ( parameters.versionAsNumber() >= QgsProjectVersion( 1, 3, 0 ) &&
235 {
236 bbox.invert();
237 }
238 const double ratio { bbox.width() / bbox.height() };
239 const int defaultHeight { static_cast<int>( 800 / ratio ) };
240 if ( parameters.width().isEmpty() && parameters.srcWidth().isEmpty() )
241 {
242 parameters.set( QgsWmsParameter::SRCWIDTH, 800 );
243 }
244 if ( parameters.height().isEmpty() && parameters.srcHeight().isEmpty() )
245 {
246 parameters.set( QgsWmsParameter::SRCHEIGHT, defaultHeight );
247 }
248 }
249 }
250
252 {
253
254 const QgsWmsParameters parameters = context.parameters();
255 std::unique_ptr<QgsLayerTreeModel> model( new QgsLayerTreeModel( &tree ) );
256 std::unique_ptr<QgsMapSettings> mapSettings;
257
258 if ( context.scaleDenominator() > 0 )
259 {
260 model->setLegendFilterByScale( context.scaleDenominator() );
261 }
262
263 // content based legend
264 if ( ! parameters.bbox().isEmpty() )
265 {
266 mapSettings = std::make_unique<QgsMapSettings>();
267 mapSettings->setOutputSize( context.mapSize() );
268 // Inverted axis?
269 QgsRectangle bbox { parameters.bboxAsRectangle() };
270 const QString crs = parameters.crs();
271 if ( crs.compare( QStringLiteral( "CRS:84" ), Qt::CaseInsensitive ) == 0 )
272 {
273 bbox.invert();
274 }
276 if ( parameters.versionAsNumber() >= QgsProjectVersion( 1, 3, 0 ) &&
278 {
279 bbox.invert();
280 }
281 mapSettings->setDestinationCrs( outputCrs );
282 mapSettings->setExtent( bbox );
283 QgsRenderer renderer( context );
284 QList<QgsMapLayer *> layers = context.layersToRender();
285 renderer.configureLayers( layers, mapSettings.get() );
286 mapSettings->setLayers( context.layersToRender() );
287
288 QgsLayerTreeFilterSettings filterSettings( *mapSettings );
289 filterSettings.setLayerFilterExpressionsFromLayerTree( model->rootGroup() );
290 model->setFilterSettings( &filterSettings );
291 }
292
293 // if legend is not based on rendering rules
294 if ( parameters.rule().isEmpty() )
295 {
296 const QList<QgsLayerTreeNode *> children = tree.children();
297 const QString ruleLabel = parameters.ruleLabel();
298 for ( QgsLayerTreeNode *node : children )
299 {
300 if ( ! QgsLayerTree::isLayer( node ) )
301 continue;
302
303 QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node );
304
305 // layer titles - hidden or not
307 // rule item titles
308 if ( !parameters.ruleLabelAsBool() )
309 {
310 for ( QgsLayerTreeModelLegendNode *legendNode : model->layerLegendNodes( nodeLayer ) )
311 {
312 // empty string = no override, so let's use one space
313 legendNode->setUserLabel( QStringLiteral( " " ) );
314 }
315 }
316 else if ( ruleLabel.compare( QStringLiteral( "AUTO" ), Qt::CaseInsensitive ) == 0 )
317 {
318 for ( QgsLayerTreeModelLegendNode *legendNode : model->layerLegendNodes( nodeLayer ) )
319 {
320 //clearing label for single symbol
323 }
324 }
325 }
326 }
327
328 return model.release();
329 }
330
332 {
333 std::unique_ptr<QgsLayerTree> tree( new QgsLayerTree() );
334
335 QList<QgsVectorLayerFeatureCounter *> counters;
336 for ( QgsMapLayer *ml : context.layersToRender() )
337 {
338 QgsLayerTreeLayer *lt = tree->addLayer( ml );
339 lt->setUseLayerName( false ); // do not modify underlying layer
340
341 // name
342 if ( !ml->serverProperties()->title().isEmpty() )
343 lt->setName( ml->serverProperties()->title() );
344
345 // show feature count
346 const bool showFeatureCount = context.parameters().showFeatureCountAsBool();
347 const QString property = QStringLiteral( "showFeatureCount" );
348 lt->setCustomProperty( property, showFeatureCount );
349
350 if ( ml->type() != Qgis::LayerType::Vector || !showFeatureCount )
351 continue;
352
353 QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( ml );
355 if ( !counter )
356 continue;
357
358 counters.append( counter );
359 }
360
361 for ( QgsVectorLayerFeatureCounter *counter : counters )
362 {
363 counter->waitForFinished();
364 }
365
366 return tree.release();
367 }
368
370 {
371 if ( !projectRoot )
372 {
373 return 0;
374 }
375
376 std::unique_ptr<QgsLayerTree> tree( new QgsLayerTree() );
377
378 QgsWmsParameters wmsParams = context.parameters();
379 QStringList layerNicknames = wmsParams.allLayersNickname();
380 for ( int i = 0; i < layerNicknames.size(); ++i )
381 {
382 QString nickname = layerNicknames.at( i );
383
384 //single layer
385 QgsMapLayer *layer = context.layer( nickname );
386 if ( layer )
387 {
388 tree->addLayer( layer );
389 }
390 else //nickname refers to a group
391 {
392 QgsLayerTreeGroup *group = projectRoot->findGroup( nickname );
393 if ( group )
394 {
395 tree->insertChildNode( i, group->clone() );
396 }
397 }
398 }
399
400 return tree.release();
401 }
402
404 {
405 for ( QgsLayerTreeLayer *layer : model.rootGroup()->findLayers() )
406 {
407 for ( QgsLayerTreeModelLegendNode *node : model.layerLegendNodes( layer ) )
408 {
409 if ( node->data( Qt::DisplayRole ).toString().compare( rule ) == 0 )
410 return node;
411 }
412 }
413 return nullptr;
414 }
415} // namespace QgsWms
@ ShowRuleDetails
If set, the rule expression of a rule based renderer legend item will be added to the JSON.
@ Vector
Vector layer.
QFlags< LegendJsonRenderFlag > LegendJsonRenderFlags
Definition qgis.h:4256
A helper class that centralizes restrictions given by all the access control filter plugins.
This class represents a coordinate reference system (CRS).
static QgsCoordinateReferenceSystem fromOgcWmsCrs(const QString &ogcCrs)
Creates a CRS from a given OGC WMS-format Coordinate Reference System string.
bool hasAxisInverted() const
Returns whether the axis order is inverted for the CRS compared to the order east/north (longitude/la...
Defines a QGIS exception class.
Contains settings relating to filtering the contents of QgsLayerTreeModel and views.
void setLayerFilterExpressionsFromLayerTree(QgsLayerTree *tree)
Sets layer filter expressions using a layer tree.
Layer tree group node serves as a container for layers and further groups.
void insertChildNode(int index, QgsLayerTreeNode *node)
Insert existing node at specified position.
QgsLayerTreeGroup * findGroup(const QString &name)
Find group node with specified name.
QgsLayerTreeGroup * clone() const override
Returns a clone of the group.
QList< QgsLayerTreeLayer * > findLayers() const
Find all layer nodes.
Layer tree node points to a map layer.
void setName(const QString &n) override
Sets the layer's name.
void setUseLayerName(bool use=true)
Uses the layer's name if use is true, or the name manually set if false.
The QgsLegendRendererItem class is abstract interface for legend items returned from QgsMapLayerLegen...
virtual void setEmbeddedInParent(bool embedded)
virtual void setUserLabel(const QString &userLabel)
The QgsLayerTreeModel class is model implementation for Qt item views framework.
QList< QgsLayerTreeModelLegendNode * > layerLegendNodes(QgsLayerTreeLayer *nodeLayer, bool skipNodeEmbeddedInParent=false)
Returns filtered list of active legend nodes attached to a particular layer node (by default it retur...
QgsLayerTree * rootGroup() const
Returns pointer to the root node of the layer tree. Always a non nullptr value.
This class is a base class for nodes in a layer tree.
void setCustomProperty(const QString &key, const QVariant &value)
Sets a custom property for the node. Properties are stored in a map and saved in project file.
QList< QgsLayerTreeNode * > children()
Gets list of children of the node. Children are owned by the parent.
Namespace with helper functions for layer tree operations.
static QgsLayerTreeLayer * toLayer(QgsLayerTreeNode *node)
Cast node to a layer.
static bool isLayer(const QgsLayerTreeNode *node)
Check whether the node is a valid layer node.
static void setNodeLegendStyle(QgsLayerTreeNode *node, QgsLegendStyle::Style style)
Sets the style of a node.
@ Subgroup
Legend subgroup title.
@ Hidden
Special style, item is hidden including margins around.
Base class for all map layer types.
Definition qgsmaplayer.h:76
A class to describe the version of a project.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition qgsproject.h:107
static QgsProject * instance()
Returns the QgsProject singleton instance.
A rectangle specified with double values.
bool isEmpty() const
Returns true if the rectangle has no area.
A helper class that centralizes caches accesses given by all the server cache filter plugins.
bool setCachedImage(const QByteArray *img, const QgsProject *project, const QgsServerRequest &request, QgsAccessControl *accessControl) const
Updates or inserts the image in cache like tiles.
QByteArray getCachedImage(const QgsProject *project, const QgsServerRequest &request, QgsAccessControl *accessControl) const
Returns cached image (or 0 if image not in cache) like tiles.
QgsServerInterface Class defining interfaces exposed by QGIS Server and made available to plugins.
virtual QgsServerCacheManager * cacheManager() const =0
Gets the registered server cache filters.
virtual QgsAccessControl * accessControls() const =0
Gets the registered access control filters.
QgsServerResponse Class defining response interface passed to services QgsService::executeRequest() m...
virtual void write(const QString &data)
Write string This is a convenient method that will write directly to the underlying I/O device.
virtual QByteArray data() const =0
Gets the data written so far.
virtual void setHeader(const QString &key, const QString &value)=0
Set Header entry Add Header entry to the response Note that it is usually an error to set Header afte...
virtual QgsFeedback * feedback() const
Returns the socket feedback if any.
virtual QIODevice * io()=0
Returns the underlying QIODevice.
bool waitForFinished(int timeout=30000)
Blocks the current thread until the task finishes or a maximum of timeout milliseconds.
Counts the features in a QgsVectorLayer in task.
Represents a vector layer which manages a vector based data sets.
QgsVectorLayerFeatureCounter * countSymbolFeatures(bool storeSymbolFids=false)
Count features for symbols.
Exception thrown in case of malformed request.
Map renderer for WMS requests.
void configureLayers(QList< QgsMapLayer * > &layers, QgsMapSettings *settings=nullptr)
Configures layers for rendering optionally considering the map settings.
QImage * getLegendGraphics(QgsLayerTreeModel &model)
Returns the map legend as an image (or nullptr in case of error).
QJsonObject getLegendGraphicsAsJson(QgsLayerTreeModel &model, const Qgis::LegendJsonRenderFlags &jsonRenderFlags=Qgis::LegendJsonRenderFlags())
Returns the map legend as a JSON object.
Provides an interface to retrieve and manipulate WMS parameters received from the client.
QString rule() const
Returns RULE parameter or an empty string if none is defined.
QStringList allLayersNickname() const
Returns nickname of layers found in LAYER and LAYERS parameters.
QString formatAsString() const
Returns FORMAT parameter as a string.
QgsProjectVersion versionAsNumber() const
Returns VERSION parameter if defined or its default value.
QString ruleLabel() const
Returns RULELABEL parameter or an empty string if none is defined.
QgsRectangle bboxAsRectangle() const
Returns BBOX as a rectangle if defined and valid.
void set(QgsWmsParameter::Name name, const QVariant &value)
Sets a parameter value thanks to its name.
QString srcHeight() const
Returns SRCHEIGHT parameter or an empty string if not defined.
bool showFeatureCountAsBool() const
Returns SHOWFEATURECOUNT as a bool.
QString bbox() const
Returns BBOX if defined or an empty string.
Format format() const
Returns format.
bool ruleLabelAsBool() const
Returns RULELABEL as a bool.
QString srcWidth() const
Returns SRCWIDTH parameter or an empty string if not defined.
QString height() const
Returns HEIGHT parameter or an empty string if not defined.
QString crs() const
Returns CRS or an empty string if none is defined.
bool showRuleDetailsAsBool() const
Returns SHOWRULEDETAILS as a bool.
bool layerTitleAsBool() const
Returns LAYERTITLE as a bool or its default value if not defined.
bool addLayerGroups() const
Returns true if layer groups shall be added to GetLegendGraphic results.
Format
Output format for the response.
QString width() const
Returns WIDTH parameter or an empty string if not defined.
Rendering context for the WMS renderer.
QSize mapSize(bool aspectRatio=true) const
Returns the size (in pixels) of the map to render, according to width and height WMS parameters as we...
void setParameters(const QgsWmsParameters &parameters)
Sets WMS parameters.
QList< QgsMapLayer * > layersToRender() const
Returns a list of all layers to actually render according to the current configuration.
QgsMapLayer * layer(const QString &nickname) const
Returns the layer corresponding to the nickname, or a nullptr if not found or if the layer do not nee...
void setFlag(Flag flag, bool on=true)
Sets or unsets a rendering flag according to the on value.
QgsWmsParameters parameters() const
Returns WMS parameters.
void setSocketFeedback(QgsFeedback *feedback)
Sets the response feedback.
double scaleDenominator() const
Returns the scale denominator to use for rendering according to the current configuration.
int imageQuality() const
Returns the image quality to use for rendering according to the current configuration.
Class defining request interface passed to WMS service.
const QgsWmsParameters & wmsParameters() const
Returns the parameters interpreted for the WMS service.
SERVER_EXPORT bool wmsAddLegendGroupsLegendGraphic(const QgsProject &project)
Returns if legend groups should be in the legend graphic response if GetLegendGraphic is called on a ...
Median cut implementation.
void writeImage(QgsServerResponse &response, QImage &img, const QString &formatStr, int imageQuality)
Write image response.
void writeGetLegendGraphics(QgsServerInterface *serverIface, const QgsProject *project, const QgsWmsRequest &request, QgsServerResponse &response)
Output GetLegendGRaphics response.
QgsLayerTree * layerTree(const QgsWmsRenderContext &context)
QgsLayerTreeModelLegendNode * legendNode(const QString &rule, QgsLayerTreeModel &model)
QgsLayerTreeModel * legendModel(const QgsWmsRenderContext &context, QgsLayerTree &tree)
QgsLayerTree * layerTreeWithGroups(const QgsWmsRenderContext &context, QgsLayerTree *projectRoot)
@ Unknown
Unknown/invalid format.
ImageOutputFormat parseImageFormat(const QString &format)
Parse image format parameter.
void checkParameters(QgsWmsParameters &parameters)
checkParameters checks request parameters and sets SRCHEIGHT and SRCWIDTH to default values in case B...
const QgsCoordinateReferenceSystem & outputCrs
const QgsCoordinateReferenceSystem & crs