qgswmsrenderer.cpp

Go to the documentation of this file.

/***************************************************************************
                              qgswmsrenderer.cpp
                              -------------------
  begin                : May 14, 2006
  copyright            : (C) 2006 by Marco Hugentobler
                         (C) 2017 by David Marteau
  email                : marco dot hugentobler at karto dot baug dot ethz dot ch
                         david dot marteau at 3liz dot com
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgswmsrenderer.h"
 
#include <memory>
#include <nlohmann/json.hpp>
 
#include "qgsaccesscontrol.h"
#include "qgsannotation.h"
#include "qgsannotationmanager.h"
#include "qgsattributeeditorcontainer.h"
#include "qgsattributeeditorelement.h"
#include "qgsattributeeditorfield.h"
#include "qgsattributeeditorrelation.h"
#include "qgscoordinatereferencesystem.h"
#include "qgsdimensionfilter.h"
#include "qgsdxfexport.h"
#include "qgsexception.h"
#include "qgsexpressioncontextutils.h"
#include "qgsfeature.h"
#include "qgsfeatureiterator.h"
#include "qgsfeaturerequest.h"
#include "qgsfeaturestore.h"
#include "qgsfieldformatter.h"
#include "qgsfieldformatterregistry.h"
#include "qgsfields.h"
#include "qgsfilterrestorer.h"
#include "qgsgeometry.h"
#include "qgsjsonutils.h"
#include "qgslayertree.h"
#include "qgslayertreemodel.h"
#include "qgslayoututils.h"
#include "qgslegendrenderer.h"
#include "qgsmaplayer.h"
#include "qgsmaplayerstylemanager.h"
#include "qgsmaplayertemporalproperties.h"
#include "qgsmaprendererjobproxy.h"
#include "qgsmaprenderertask.h"
#include "qgsmapthemecollection.h"
#include "qgsmaptopixel.h"
#include "qgsmeshlayer.h"
#include "qgsmeshlayertemporalproperties.h"
#include "qgsmessagelog.h"
#include "qgspallabeling.h"
#include "qgsproject.h"
#include "qgsrasteridentifyresult.h"
#include "qgsrasterlayer.h"
#include "qgsrasterrenderer.h"
#include "qgsrenderer.h"
#include "qgsscalecalculator.h"
#include "qgsselectivemaskingsourcesetmanager.h"
#include "qgsserverapiutils.h"
#include "qgsserverexception.h"
#include "qgsserverfeatureid.h"
#include "qgsserverprojectutils.h"
#include "qgssymbollayerutils.h"
#include "qgstriangularmesh.h"
#include "qgsvectordataprovider.h"
#include "qgsvectorlayer.h"
#include "qgsvectorlayerlabeling.h"
#include "qgsvectortilelayer.h"
#include "qgswkbtypes.h"
#include "qgswmsrestorer.h"
#include "qgswmsserviceexception.h"
 
#include <QDir>
#include <QImage>
#include <QPainter>
#include <QString>
#include <QStringList>
#include <QTemporaryFile>
#include <QUrl>
#include <QXmlStreamReader>
 
using namespace Qt::StringLiterals;
 
//for printing
#include "qgslayoutatlas.h"
#include "qgslayoutmanager.h"
#include "qgslayoutexporter.h"
#include "qgslayoutsize.h"
#include "qgslayoutrendercontext.h"
#include "qgslayoutmeasurement.h"
#include "qgsprintlayout.h"
#include "qgslayoutpagecollection.h"
#include "qgslayoutitempage.h"
#include "qgslayoutitemlabel.h"
#include "qgslayoutitemlegend.h"
#include "qgslayoutitemmap.h"
#include "qgslayoutitemmapgrid.h"
#include "qgslayoutframe.h"
#include "qgslayoutitemhtml.h"
#include "qgsfeaturefilterprovidergroup.h"
#include "qgsogcutils.h"
 
namespace QgsWms
{
  constexpr const char *MEMBERNAME_FEATURETYPE = "featureType";                     // name of the JSON-FG member describing the layer name
  constexpr const char *MEMBERNAME_QGIS_REQUESTEDWMSNAME = "qgis:requestedWmsName"; // name of the QGIS member describing the name of the group that requested this layer
 
  QgsRenderer::QgsRenderer( const QgsWmsRenderContext &context )
    : mContext( context )
  {
    mProject = mContext.project();
 
    mWmsParameters = mContext.parameters();
    mWmsParameters.dump();
  }
 
  QgsRenderer::~QgsRenderer()
  {
    removeTemporaryLayers();
  }
 
  QImage *QgsRenderer::getLegendGraphics( QgsLayerTreeModel &model )
  {
    // get layers
    std::unique_ptr<QgsWmsRestorer> restorer;
    restorer = std::make_unique<QgsWmsRestorer>( mContext );
 
    // configure layers
    QList<QgsMapLayer *> layers = mContext.layersToRender();
    configureLayers( layers );
 
    const qreal dpmm = mContext.dotsPerMm();
 
    QgsLegendSettings settings = legendSettings();
 
    // adjust the size settings if there any WMS cascading layers to renderer
    const auto layersToRender = mContext.layersToRender();
    for ( const auto &layer : std::as_const( layersToRender ) )
    {
      // If it is a cascading WMS layer, get legend node image size
      if ( layer->dataProvider()->name() == "wms"_L1 )
      {
        if ( QgsWmsLegendNode *layerNode = qobject_cast<QgsWmsLegendNode *>( model.findLegendNode( layer->id(), QString() ) ) )
        {
          const auto image { layerNode->getLegendGraphicBlocking() };
          if ( !image.isNull() )
          {
            // Check that we are not exceeding the maximum size
            if ( mContext.isValidWidthHeight( image.width(), image.height() ) )
            {
              const double w = image.width() / dpmm;
              const double h = image.height() / dpmm;
              const QSizeF newWmsSize { w, h };
              settings.setWmsLegendSize( newWmsSize );
            }
          }
        }
      }
    }
 
    // init renderer
    QgsLegendRenderer renderer( &model, settings );
 
    // create context
    QgsRenderContext context;
    if ( !mWmsParameters.bbox().isEmpty() )
    {
      QgsMapSettings mapSettings;
      mapSettings.setFlag( Qgis::MapSettingsFlag::RenderBlocking );
      std::unique_ptr<QImage> tmp( createImage( mContext.mapSize( false ) ) );
      configureMapSettings( tmp.get(), mapSettings );
      context = QgsRenderContext::fromMapSettings( mapSettings );
    }
    else
    {
      //use default scale settings
      context = configureDefaultRenderContext();
    }
 
    // create image according to context
    std::unique_ptr<QImage> image;
    const QSizeF minSize = renderer.minimumSize( &context );
    const QSize size( static_cast<int>( minSize.width() * dpmm ), static_cast<int>( minSize.height() * dpmm ) );
    if ( !mContext.isValidWidthHeight( size.width(), size.height() ) )
    {
      throw QgsServerException( u"Legend image is too large"_s );
    }
    image.reset( createImage( size ) );
 
    // configure painter and adapt to the context
    QPainter painter( image.get() );
 
    context.setPainter( &painter );
    if ( painter.renderHints() & QPainter::SmoothPixmapTransform )
      context.setFlag( Qgis::RenderContextFlag::HighQualityImageTransforms, true );
    if ( painter.renderHints() & QPainter::LosslessImageRendering )
      context.setFlag( Qgis::RenderContextFlag::LosslessImageRendering, true );
 
    context.setFlag( Qgis::RenderContextFlag::Antialiasing, true );
    QgsScopedRenderContextScaleToMm scaleContext( context );
 
    // rendering
    renderer.drawLegend( context );
    painter.end();
 
    return image.release();
  }
 
  QImage *QgsRenderer::getLegendGraphics( QgsLayerTreeModelLegendNode &nodeModel )
  {
    // get layers
    std::unique_ptr<QgsWmsRestorer> restorer;
    restorer = std::make_unique<QgsWmsRestorer>( mContext );
 
    // configure layers
    QList<QgsMapLayer *> layers = mContext.layersToRender();
    configureLayers( layers );
 
    // create image
    const QSize size( mWmsParameters.widthAsInt(), mWmsParameters.heightAsInt() );
    //test if legend image is larger than max width/height
    if ( !mContext.isValidWidthHeight( size.width(), size.height() ) )
    {
      throw QgsServerException( u"Legend image is too large"_s );
    }
    std::unique_ptr<QImage> image( createImage( size ) );
 
    // configure painter
    const qreal dpmm = mContext.dotsPerMm();
    std::unique_ptr<QPainter> painter;
    painter = std::make_unique<QPainter>( image.get() );
    painter->setRenderHint( QPainter::Antialiasing, true );
    painter->scale( dpmm, dpmm );
 
    // rendering
    QgsLegendSettings settings = legendSettings();
    QgsLayerTreeModelLegendNode::ItemContext ctx;
    ctx.painter = painter.get();
 
    // create context
    QgsRenderContext context = configureDefaultRenderContext( painter.get() );
    ctx.context = &context;
 
    nodeModel.drawSymbol( settings, &ctx, size.height() / dpmm );
    painter->end();
 
    return image.release();
  }
 
  QJsonObject QgsRenderer::getLegendGraphicsAsJson( QgsLayerTreeModel &model, const Qgis::LegendJsonRenderFlags &jsonRenderFlags )
  {
    // get layers
    std::unique_ptr<QgsWmsRestorer> restorer;
    restorer = std::make_unique<QgsWmsRestorer>( mContext );
 
    // configure layers
    QList<QgsMapLayer *> layers = mContext.layersToRender();
    configureLayers( layers );
 
    // init renderer
    QgsLegendSettings settings = legendSettings();
    settings.setJsonRenderFlags( jsonRenderFlags );
    QgsLegendRenderer renderer( &model, settings );
 
    // rendering
    QgsRenderContext renderContext;
    return renderer.exportLegendToJson( renderContext );
  }
 
  QJsonObject QgsRenderer::getLegendGraphicsAsJson( QgsLayerTreeModelLegendNode &legendNode, const Qgis::LegendJsonRenderFlags &jsonRenderFlags )
  {
    // get layers
    std::unique_ptr<QgsWmsRestorer> restorer;
    restorer = std::make_unique<QgsWmsRestorer>( mContext );
 
    // configure layers
    QList<QgsMapLayer *> layers = mContext.layersToRender();
    configureLayers( layers );
 
    // init renderer
    QgsLegendSettings settings = legendSettings();
    settings.setJsonRenderFlags( jsonRenderFlags );
 
    // rendering
    QgsRenderContext renderContext;
    QJsonObject jsonSymbol { legendNode.exportSymbolToJson( settings, renderContext ) };
 
    if ( jsonRenderFlags.testFlag( Qgis::LegendJsonRenderFlag::ShowRuleDetails ) )
    {
      QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( legendNode.layerNode() );
      if ( QgsVectorLayer *vLayer = qobject_cast<QgsVectorLayer *>( nodeLayer->layer() ) )
      {
        if ( vLayer->renderer() )
        {
          const QString ruleKey { legendNode.data( static_cast<int>( QgsLayerTreeModelLegendNode::CustomRole::RuleKey ) ).toString() };
          bool ok = false;
          const QString ruleExp { vLayer->renderer()->legendKeyToExpression( ruleKey, vLayer, ok ) };
          if ( ok )
          {
            jsonSymbol[u"rule"_s] = ruleExp;
          }
        }
      }
    }
 
    return jsonSymbol;
  }
 
  void QgsRenderer::runHitTest( const QgsMapSettings &mapSettings, HitTest &hitTest ) const
  {
    QgsRenderContext context = QgsRenderContext::fromMapSettings( mapSettings );
 
    for ( const QString &id : mapSettings.layerIds() )
    {
      QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( mProject->mapLayer( id ) );
      if ( !vl || !vl->renderer() )
        continue;
 
      if ( vl->hasScaleBasedVisibility() && vl->isInScaleRange( mapSettings.scale() ) )
      {
        hitTest[vl] = SymbolSet(); // no symbols -> will not be shown
        continue;
      }
 
      QgsCoordinateTransform tr = mapSettings.layerTransform( vl );
      context.setCoordinateTransform( tr );
      context.setExtent( tr.transformBoundingBox( mapSettings.extent(), Qgis::TransformDirection::Reverse ) );
 
      SymbolSet &usedSymbols = hitTest[vl];
      runHitTestLayer( vl, usedSymbols, context );
    }
  }
 
  void QgsRenderer::runHitTestLayer( QgsVectorLayer *vl, SymbolSet &usedSymbols, QgsRenderContext &context ) const
  {
    std::unique_ptr<QgsFeatureRenderer> r( vl->renderer()->clone() );
    bool moreSymbolsPerFeature = r->capabilities() & QgsFeatureRenderer::MoreSymbolsPerFeature;
    r->startRender( context, vl->fields() );
    QgsFeature f;
    QgsFeatureRequest request( context.extent() );
    request.setFlags( Qgis::FeatureRequestFlag::ExactIntersect );
    QgsFeatureIterator fi = vl->getFeatures( request );
    while ( fi.nextFeature( f ) )
    {
      context.expressionContext().setFeature( f );
      if ( moreSymbolsPerFeature )
      {
        for ( QgsSymbol *s : r->originalSymbolsForFeature( f, context ) )
          usedSymbols.insert( QgsSymbolLayerUtils::symbolProperties( s ) );
      }
      else
        usedSymbols.insert( QgsSymbolLayerUtils::symbolProperties( r->originalSymbolForFeature( f, context ) ) );
    }
    r->stopRender( context );
  }
 
  QgsRenderer::HitTest QgsRenderer::symbols()
  {
    // check size
    if ( !mContext.isValidWidthHeight() )
    {
      throw QgsBadRequestException( QgsServiceException::QGIS_InvalidParameterValue, u"The requested map size is too large"_s );
    }
 
    // init layer restorer before doing anything
    std::unique_ptr<QgsWmsRestorer> restorer;
    restorer = std::make_unique<QgsWmsRestorer>( mContext );
 
    // configure layers
    QgsMapSettings mapSettings;
    mapSettings.setFlag( Qgis::MapSettingsFlag::RenderBlocking );
    QList<QgsMapLayer *> layers = mContext.layersToRender();
    configureLayers( layers, &mapSettings );
 
    // create the output image and the painter
    std::unique_ptr<QPainter> painter;
    std::unique_ptr<QImage> image( createImage( mContext.mapSize() ) );
 
    // configure map settings (background, DPI, ...)
    configureMapSettings( image.get(), mapSettings );
 
    // add layers to map settings
    mapSettings.setLayers( layers );
 
    // run hit tests
    HitTest symbols;
    runHitTest( mapSettings, symbols );
 
    return symbols;
  }
 
  QByteArray QgsRenderer::getPrint()
  {
    // init layer restorer before doing anything
    std::unique_ptr<QgsWmsRestorer> restorer;
    restorer = std::make_unique<QgsWmsRestorer>( mContext );
 
    // GetPrint request needs a template parameter
    const QString templateName = mWmsParameters.composerTemplate();
    if ( templateName.isEmpty() )
    {
      throw QgsBadRequestException( QgsServiceException::QGIS_MissingParameterValue, QgsWmsParameter::TEMPLATE );
    }
    else if ( QgsServerProjectUtils::wmsRestrictedComposers( *mProject ).contains( templateName ) )
    {
      throw QgsBadRequestException( QgsServiceException::QGIS_InvalidParameterValue, mWmsParameters[QgsWmsParameter::TEMPLATE] );
    }
 
    // check template
    const QgsLayoutManager *lManager = mProject->layoutManager();
    QgsPrintLayout *sourceLayout( dynamic_cast<QgsPrintLayout *>( lManager->layoutByName( templateName ) ) );
    if ( !sourceLayout )
    {
      throw QgsBadRequestException( QgsServiceException::QGIS_InvalidParameterValue, mWmsParameters[QgsWmsParameter::TEMPLATE] );
    }
 
    // Check that layout has at least one page
    if ( sourceLayout->pageCollection()->pageCount() < 1 )
    {
      throw QgsBadRequestException( QgsServiceException::QGIS_InvalidParameterValue, u"The template has no pages"_s );
    }
 
    std::unique_ptr<QgsPrintLayout> layout( sourceLayout->clone() );
 
    //atlas print?
    QgsLayoutAtlas *atlas = nullptr;
    QStringList atlasPk = mWmsParameters.atlasPk();
    if ( !atlasPk.isEmpty() ) //atlas print requested?
    {
      atlas = layout->atlas();
      if ( !atlas || !atlas->enabled() )
      {
        //error
        throw QgsBadRequestException( QgsServiceException::QGIS_InvalidParameterValue, u"The template has no atlas enabled"_s );
      }
 
      QgsVectorLayer *cLayer = atlas->coverageLayer();
      if ( !cLayer )
      {
        throw QgsBadRequestException( QgsServiceException::QGIS_InvalidParameterValue, u"The atlas has no coverage layer"_s );
      }
 
      int maxAtlasFeatures = QgsServerProjectUtils::wmsMaxAtlasFeatures( *mProject );
      if ( atlasPk.size() == 1 && atlasPk.at( 0 ) == "*"_L1 )
      {
        atlas->setFilterFeatures( false );
        atlas->updateFeatures();
        if ( atlas->count() > maxAtlasFeatures )
        {
          throw QgsBadRequestException( QgsServiceException::QGIS_InvalidParameterValue, QString( "The project configuration allows printing maximum %1 atlas features at a time" ).arg( maxAtlasFeatures ) );
        }
      }
      else
      {
        const QgsAttributeList pkIndexes = cLayer->primaryKeyAttributes();
        if ( pkIndexes.size() == 0 )
        {
          QgsDebugMsgLevel( u"Atlas print: layer %1 has no primary key attributes"_s.arg( cLayer->name() ), 2 );
        }
 
        // Handles the pk-less case
        const int pkIndexesSize { std::max<int>( pkIndexes.size(), 1 ) };
 
        QStringList pkAttributeNames;
        for ( int pkIndex : std::as_const( pkIndexes ) )
        {
          pkAttributeNames.append( cLayer->fields().at( pkIndex ).name() );
        }
 
        const int nAtlasFeatures = atlasPk.size() / pkIndexesSize;
        if ( nAtlasFeatures * pkIndexesSize != atlasPk.size() ) //Test if atlasPk.size() is a multiple of pkIndexesSize. Bail out if not
        {
          throw QgsBadRequestException( QgsServiceException::QGIS_InvalidParameterValue, u"Wrong number of ATLAS_PK parameters"_s );
        }
 
        //number of atlas features might be restricted
        if ( nAtlasFeatures > maxAtlasFeatures )
        {
          throw QgsBadRequestException(
            QgsServiceException::QGIS_InvalidParameterValue,
            QString( "%1 atlas features have been requested, but the project configuration only allows printing %2 atlas features at a time" ).arg( nAtlasFeatures ).arg( maxAtlasFeatures )
          );
        }
 
        QString filterString;
        int currentAtlasPk = 0;
 
        for ( int i = 0; i < nAtlasFeatures; ++i )
        {
          if ( i > 0 )
          {
            filterString.append( " OR " );
          }
 
          filterString.append( "( " );
 
          // If the layer has no PK attributes, assume FID
          if ( pkAttributeNames.isEmpty() )
          {
            filterString.append( u"$id = %1"_s.arg( atlasPk.at( currentAtlasPk ) ) );
            ++currentAtlasPk;
          }
          else
          {
            for ( int j = 0; j < pkIndexes.size(); ++j )
            {
              if ( j > 0 )
              {
                filterString.append( " AND " );
              }
              filterString.append( QgsExpression::createFieldEqualityExpression( pkAttributeNames.at( j ), atlasPk.at( currentAtlasPk ) ) );
              ++currentAtlasPk;
            }
          }
 
          filterString.append( " )" );
        }
 
        atlas->setFilterFeatures( true );
 
        QString errorString;
        atlas->setFilterExpression( filterString, errorString );
 
        if ( !errorString.isEmpty() )
        {
          throw QgsException( u"An error occurred during the Atlas print: %1"_s.arg( errorString ) );
        }
      }
    }
 
    // configure layers
    QgsMapSettings mapSettings;
    mapSettings.setFlag( Qgis::MapSettingsFlag::RenderBlocking );
    QList<QgsMapLayer *> layers = mContext.layersToRender();
    configureLayers( layers, &mapSettings );
 
    // configure map settings (background, DPI, ...)
    auto image = std::make_unique<QImage>();
    configureMapSettings( image.get(), mapSettings );
 
    // add layers to map settings
    mapSettings.setLayers( layers );
 
    // configure layout
    configurePrintLayout( layout.get(), mapSettings, atlas );
 
    QgsLayoutRenderContext &layoutRendererContext = layout->renderContext();
    QgsFeatureFilterProviderGroup filters;
    const QList<QgsMapLayer *> lyrs = mapSettings.layers();
 
#ifdef HAVE_SERVER_PYTHON_PLUGINS
    mContext.accessControl()->resolveFilterFeatures( lyrs );
    filters.addProvider( mContext.accessControl() );
#endif
 
    QHash<const QgsVectorLayer *, QStringList> fltrs;
    for ( QgsMapLayer *l : lyrs )
    {
      if ( QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( l ) )
      {
        fltrs.insert( vl, dimensionFilter( vl ) );
      }
    }
 
    QgsDimensionFilter dimFilter( fltrs );
    filters.addProvider( &dimFilter );
    layoutRendererContext.setFeatureFilterProvider( &filters );
 
    // Get the temporary output file
    const QgsWmsParameters::Format format = mWmsParameters.format();
    const QString extension = QgsWmsParameters::formatAsString( format ).toLower();
 
    QTemporaryFile tempOutputFile( QDir::tempPath() + '/' + u"XXXXXX.%1"_s.arg( extension ) );
    if ( !tempOutputFile.open() )
    {
      throw QgsException( u"Could not open temporary file for the GetPrint request."_s );
    }
 
    QString exportError;
    if ( format == QgsWmsParameters::SVG )
    {
      // Settings for the layout exporter
      QgsLayoutExporter::SvgExportSettings exportSettings;
      if ( !mWmsParameters.dpi().isEmpty() )
      {
        bool ok;
        double dpi( mWmsParameters.dpi().toDouble( &ok ) );
        if ( ok )
          exportSettings.dpi = dpi;
      }
      // Set scales
      exportSettings.predefinedMapScales = QgsLayoutUtils::predefinedScales( layout.get() );
      // Draw selections
      exportSettings.flags |= Qgis::LayoutRenderFlag::DrawSelection;
      if ( atlas )
      {
        //export first page of atlas
        atlas->beginRender();
        if ( atlas->next() )
        {
          QgsLayoutExporter atlasSvgExport( atlas->layout() );
          atlasSvgExport.exportToSvg( tempOutputFile.fileName(), exportSettings );
        }
      }
      else
      {
        QgsLayoutExporter exporter( layout.get() );
        exporter.exportToSvg( tempOutputFile.fileName(), exportSettings );
      }
    }
    else if ( format == QgsWmsParameters::PNG || format == QgsWmsParameters::JPG )
    {
      // Settings for the layout exporter
      QgsLayoutExporter::ImageExportSettings exportSettings;
 
      // Get the dpi from input or use the default
      double dpi( layout->renderContext().dpi() );
      if ( !mWmsParameters.dpi().isEmpty() )
      {
        bool ok;
        double _dpi = mWmsParameters.dpi().toDouble( &ok );
        if ( ok )
          dpi = _dpi;
      }
      exportSettings.dpi = dpi;
      // Set scales
      exportSettings.predefinedMapScales = QgsLayoutUtils::predefinedScales( layout.get() );
      // Draw selections
      exportSettings.flags |= Qgis::LayoutRenderFlag::DrawSelection;
      // Destination image size in px
      QgsLayoutSize layoutSize( layout->pageCollection()->page( 0 )->sizeWithUnits() );
 
      QgsLayoutMeasurement width( layout->convertFromLayoutUnits( layoutSize.width(), Qgis::LayoutUnit::Millimeters ) );
      QgsLayoutMeasurement height( layout->convertFromLayoutUnits( layoutSize.height(), Qgis::LayoutUnit::Millimeters ) );
 
      const QSize imageSize = QSize( static_cast<int>( width.length() * dpi / 25.4 ), static_cast<int>( height.length() * dpi / 25.4 ) );
 
      const QString paramWidth = mWmsParameters.width();
      const QString paramHeight = mWmsParameters.height();
 
      // Prefer width and height from the http request
      // Fallback to predefined values from layout
      // Preserve aspect ratio if only one value is specified
      if ( !paramWidth.isEmpty() && !paramHeight.isEmpty() )
      {
        exportSettings.imageSize = QSize( paramWidth.toInt(), paramHeight.toInt() );
      }
      else if ( !paramWidth.isEmpty() && paramHeight.isEmpty() )
      {
        exportSettings.imageSize = QSize( paramWidth.toInt(), static_cast<double>( paramWidth.toInt() ) / imageSize.width() * imageSize.height() );
      }
      else if ( paramWidth.isEmpty() && !paramHeight.isEmpty() )
      {
        exportSettings.imageSize = QSize( static_cast<double>( paramHeight.toInt() ) / imageSize.height() * imageSize.width(), paramHeight.toInt() );
      }
      else
      {
        exportSettings.imageSize = imageSize;
      }
 
      // Export first page only (unless it's a pdf, see below)
      exportSettings.pages.append( 0 );
      if ( atlas )
      {
        //only can give back one page in server rendering
        atlas->beginRender();
        if ( atlas->next() )
        {
          QgsLayoutExporter atlasPngExport( atlas->layout() );
          atlasPngExport.exportToImage( tempOutputFile.fileName(), exportSettings );
        }
        else
        {
          throw QgsServiceException( u"Bad request"_s, u"Atlas error: empty atlas."_s, QString(), 400 );
        }
      }
      else
      {
        QgsLayoutExporter exporter( layout.get() );
        exporter.exportToImage( tempOutputFile.fileName(), exportSettings );
      }
    }
    else if ( format == QgsWmsParameters::PDF )
    {
      // Settings for the layout exporter
      QgsLayoutExporter::PdfExportSettings exportSettings;
      // TODO: handle size from input ?
      if ( !mWmsParameters.dpi().isEmpty() )
      {
        bool ok;
        double dpi( mWmsParameters.dpi().toDouble( &ok ) );
        if ( ok )
          exportSettings.dpi = dpi;
      }
      // Draw selections
      exportSettings.flags |= Qgis::LayoutRenderFlag::DrawSelection;
      // Print as raster
      exportSettings.rasterizeWholeImage = layout->customProperty( u"rasterize"_s, false ).toBool();
      // Set scales. 1. Prio: request, 2. Prio: predefined mapscales in layout
      QVector<qreal> requestMapScales = mWmsParameters.pdfPredefinedMapScales();
      if ( requestMapScales.size() > 0 )
      {
        exportSettings.predefinedMapScales = requestMapScales;
      }
      else
      {
        exportSettings.predefinedMapScales = QgsLayoutUtils::predefinedScales( layout.get() );
      }
      // Export themes
      QStringList exportThemes = mWmsParameters.pdfExportMapThemes();
      if ( exportThemes.size() > 0 )
      {
        exportSettings.exportThemes = exportThemes;
      }
      exportSettings.writeGeoPdf = mWmsParameters.writeGeospatialPdf();
      exportSettings.textRenderFormat = mWmsParameters.pdfTextRenderFormat();
      exportSettings.forceVectorOutput = mWmsParameters.pdfForceVectorOutput();
      exportSettings.appendGeoreference = mWmsParameters.pdfAppendGeoreference();
      exportSettings.simplifyGeometries = mWmsParameters.pdfSimplifyGeometries();
      exportSettings.useIso32000ExtensionFormatGeoreferencing = mWmsParameters.pdfUseIso32000ExtensionFormatGeoreferencing();
      if ( mWmsParameters.pdfLosslessImageCompression() )
      {
        exportSettings.flags |= Qgis::LayoutRenderFlag::LosslessImageRendering;
      }
      if ( mWmsParameters.pdfDisableTiledRasterRendering() )
      {
        exportSettings.flags |= Qgis::LayoutRenderFlag::DisableTiledRasterLayerRenders;
      }
 
      // Export all pages
      if ( atlas )
      {
        QgsLayoutExporter::exportToPdf( atlas, tempOutputFile.fileName(), exportSettings, exportError );
      }
      else
      {
        QgsLayoutExporter exporter( layout.get() );
        exporter.exportToPdf( tempOutputFile.fileName(), exportSettings );
      }
    }
    else //unknown format
    {
      throw QgsBadRequestException( QgsServiceException::OGC_InvalidFormat, mWmsParameters[QgsWmsParameter::FORMAT] );
    }
 
    if ( atlas )
    {
      handlePrintErrors( atlas->layout() );
    }
    else
    {
      handlePrintErrors( layout.get() );
    }
 
    return tempOutputFile.readAll();
  }
 
  bool QgsRenderer::configurePrintLayout( QgsPrintLayout *c, const QgsMapSettings &mapSettings, QgsLayoutAtlas *atlas )
  {
    c->renderContext().setSelectionColor( mapSettings.selectionColor() );
    // Maps are configured first
    QList<QgsLayoutItemMap *> maps;
    c->layoutItems<QgsLayoutItemMap>( maps );
    // Layout maps now use a string UUID as "id", let's assume that the first map
    // has id 0 and so on ...
    int mapId = 0;
 
    for ( const auto &map : std::as_const( maps ) )
    {
      QgsWmsParametersComposerMap cMapParams = mWmsParameters.composerMapParameters( mapId );
      mapId++;
 
      // If there are no configured layers, we take layers from unprefixed LAYER(S) if any
      if ( cMapParams.mLayers.isEmpty() )
      {
        cMapParams.mLayers = mWmsParameters.composerMapParameters( -1 ).mLayers;
      }
 
      if ( !atlas || !map->atlasDriven() ) //No need to extent, scale, rotation set with atlas feature
      {
        //map extent is mandatory
        if ( !cMapParams.mHasExtent )
        {
          //remove map from composition if not referenced by the request
          c->removeLayoutItem( map );
          continue;
        }
        // Change CRS of map set to "project CRS" to match requested CRS
        // (if map has a valid preset crs then we keep this crs and don't use the
        // requested crs for this map item)
        if ( mapSettings.destinationCrs().isValid() && !map->presetCrs().isValid() )
          map->setCrs( mapSettings.destinationCrs() );
 
        QgsRectangle r( cMapParams.mExtent );
        if ( mWmsParameters.versionAsNumber() >= QgsProjectVersion( 1, 3, 0 ) && mapSettings.destinationCrs().hasAxisInverted() )
        {
          r.invert();
        }
        map->setExtent( r );
 
        // scale
        if ( cMapParams.mScale > 0 )
        {
          map->setScale( static_cast<double>( cMapParams.mScale ) );
        }
 
        // rotation
        if ( cMapParams.mRotation )
        {
          map->setMapRotation( cMapParams.mRotation );
        }
      }
 
      if ( !map->keepLayerSet() )
      {
        QList<QgsMapLayer *> layerSet;
 
        for ( const auto &layer : std::as_const( cMapParams.mLayers ) )
        {
          if ( mContext.isValidGroup( layer.mNickname ) )
          {
            QList<QgsMapLayer *> layersFromGroup;
 
            const QList<QgsMapLayer *> cLayersFromGroup = mContext.layersFromGroup( layer.mNickname );
            for ( QgsMapLayer *layerFromGroup : cLayersFromGroup )
            {
              if ( !layerFromGroup )
              {
                continue;
              }
 
              layersFromGroup.push_front( layerFromGroup );
            }
 
            if ( !layersFromGroup.isEmpty() )
            {
              layerSet.append( layersFromGroup );
            }
          }
          else
          {
            QgsMapLayer *mlayer = mContext.layer( layer.mNickname );
 
            if ( !mlayer )
            {
              continue;
            }
 
            setLayerStyle( mlayer, layer.mStyle );
            layerSet << mlayer;
          }
        }
 
        std::reverse( layerSet.begin(), layerSet.end() );
 
        // If the map is set to follow preset we need to disable follow preset and manually
        // configure the layers here or the map item internal logic will override and get
        // the layers from the map theme.
        QMap<QString, QString> layersStyle;
        if ( map->followVisibilityPreset() )
        {
          if ( atlas )
          {
            // Possibly triggers a refresh of the DD visibility preset (theme) name
            // see issue GH #54475
            atlas->updateFeatures();
            atlas->first();
          }
 
          const QString presetName = map->followVisibilityPresetName();
          if ( layerSet.isEmpty() )
          {
            // Get the layers from the theme
            const QgsExpressionContext ex { map->createExpressionContext() };
            layerSet = map->layersToRender( &ex );
          }
          // Disable the theme
          map->setFollowVisibilityPreset( false );
 
          // Collect the style of each layer in the theme that has been disabled
          const QList<QgsMapThemeCollection::MapThemeLayerRecord> mapThemeRecords = QgsProject::instance()->mapThemeCollection()->mapThemeState( presetName ).layerRecords();
          for ( const auto &layerMapThemeRecord : std::as_const( mapThemeRecords ) )
          {
            if ( layerSet.contains( layerMapThemeRecord.layer() ) )
            {
              layersStyle.insert( layerMapThemeRecord.layer()->id(), layerMapThemeRecord.layer()->styleManager()->style( layerMapThemeRecord.currentStyle ).xmlData() );
            }
          }
        }
 
        // Handle highlight layers
        const QList<QgsMapLayer *> highlights = highlightLayers( cMapParams.mHighlightLayers );
        for ( const auto &hl : std::as_const( highlights ) )
        {
          layerSet.prepend( hl );
        }
 
        map->setLayers( layerSet );
        map->setKeepLayerSet( true );
 
        // Set style override if a particular style should be used due to a map theme.
        // It will actualize linked legend symbols too.
        if ( !layersStyle.isEmpty() )
        {
          map->setLayerStyleOverrides( layersStyle );
          map->setKeepLayerStyles( true );
        }
      }
 
      //grid space x / y
      if ( cMapParams.mGridX >= 0 && cMapParams.mGridY >= 0 )
      {
        map->grid()->setIntervalX( static_cast<double>( cMapParams.mGridX ) );
        map->grid()->setIntervalY( static_cast<double>( cMapParams.mGridY ) );
      }
    }
 
    // Labels
    QList<QgsLayoutItemLabel *> labels;
    c->layoutItems<QgsLayoutItemLabel>( labels );
    for ( const auto &label : std::as_const( labels ) )
    {
      bool ok = false;
      const QString labelId = label->id();
      const QString labelParam = mWmsParameters.layoutParameter( labelId, ok );
 
      if ( !ok )
        continue;
 
      if ( labelParam.isEmpty() )
      {
        //remove exported labels referenced in the request
        //but with empty string
        c->removeItem( label );
        delete label;
        continue;
      }
 
      label->setText( labelParam );
    }
 
    // HTMLs
    QList<QgsLayoutItemHtml *> htmls;
    c->layoutObjects<QgsLayoutItemHtml>( htmls );
    for ( const auto &html : std::as_const( htmls ) )
    {
      if ( html->frameCount() == 0 )
        continue;
 
      QgsLayoutFrame *htmlFrame = html->frame( 0 );
      bool ok = false;
      const QString htmlId = htmlFrame->id();
      const QString htmlValue = mWmsParameters.layoutParameter( htmlId, ok );
 
      if ( !ok )
      {
        html->update();
        continue;
      }
 
      //remove exported Htmls referenced in the request
      //but with empty string
      if ( htmlValue.isEmpty() )
      {
        c->removeMultiFrame( html );
        delete html;
        continue;
      }
 
      if ( html->contentMode() == QgsLayoutItemHtml::Url )
      {
        QUrl newUrl( htmlValue );
        html->setUrl( newUrl );
      }
      else if ( html->contentMode() == QgsLayoutItemHtml::ManualHtml )
      {
        html->setHtml( htmlValue );
      }
      html->update();
    }
 
 
    // legends
    QList<QgsLayoutItemLegend *> legends;
    c->layoutItems<QgsLayoutItemLegend>( legends );
    for ( const auto &legend : std::as_const( legends ) )
    {
      switch ( legend->syncMode() )
      {
        case Qgis::LegendSyncMode::AllProjectLayers:
        case Qgis::LegendSyncMode::VisibleLayers:
        {
          // the legend has an auto-update model
          // we will update it with map's layers
          const QgsLayoutItemMap *map = legend->linkedMap();
          if ( !map )
          {
            continue;
          }
 
          legend->setSyncMode( Qgis::LegendSyncMode::Manual );
 
          // get model and layer tree root of the legend
          QgsLegendModel *model = legend->model();
          QStringList layerSet;
          QList<QgsMapLayer *> mapLayers;
          if ( map->layers().isEmpty() )
          {
            // in QGIS desktop, each layer has its legend, including invisible layers
            // and using maptheme, legend items are automatically filtered
            mapLayers = mProject->mapLayers( true ).values();
          }
          else
          {
            mapLayers = map->layers();
          }
          const QList<QgsMapLayer *> layerList = mapLayers;
          for ( const auto &layer : layerList )
            layerSet << layer->id();
 
          // get model and layer tree root of the legend
          QgsLayerTree *root = model->rootGroup();
 
          // get layerIds find in the layer tree root
          const QStringList layerIds = root->findLayerIds();
 
          // find the layer in the layer tree
          // remove it if the layer id is not in map layerIds
          for ( const auto &layerId : layerIds )
          {
            QgsLayerTreeLayer *nodeLayer = root->findLayer( layerId );
            if ( !nodeLayer )
            {
              continue;
            }
            if ( !layerSet.contains( layerId ) )
            {
              qobject_cast<QgsLayerTreeGroup *>( nodeLayer->parent() )->removeChildNode( nodeLayer );
            }
            else
            {
              QgsMapLayer *layer = nodeLayer->layer();
              if ( !layer->isInScaleRange( map->scale() ) )
              {
                qobject_cast<QgsLayerTreeGroup *>( nodeLayer->parent() )->removeChildNode( nodeLayer );
              }
            }
          }
          root->removeChildrenGroupWithoutLayers();
          break;
        }
 
        case Qgis::LegendSyncMode::Manual:
          break;
      }
    }
    return true;
  }
 
  std::unique_ptr<QImage> QgsRenderer::getMap()
  {
    // check size
    if ( !mContext.isValidWidthHeight() )
    {
      throw QgsBadRequestException( QgsServiceException::QGIS_InvalidParameterValue, u"The requested map size is too large"_s );
    }
 
    if ( mContext.socketFeedback() && mContext.socketFeedback()->isCanceled() )
    {
      return nullptr;
    }
 
    // init layer restorer before doing anything
    std::unique_ptr<QgsWmsRestorer> restorer;
    restorer = std::make_unique<QgsWmsRestorer>( mContext );
 
    // configure layers
    QList<QgsMapLayer *> layers = mContext.layersToRender();
 
    QgsMapSettings mapSettings;
    mapSettings.setFlag( Qgis::MapSettingsFlag::RenderBlocking );
    configureLayers( layers, &mapSettings );
 
    // create the output image and the painter
    std::unique_ptr<QPainter> painter;
    std::unique_ptr<QImage> image( createImage( mContext.mapSize() ) );
 
    // configure map settings (background, DPI, ...)
    configureMapSettings( image.get(), mapSettings );
 
    // add layers to map settings
    mapSettings.setLayers( layers );
 
    // rendering step for layers
    QPainter *renderedPainter = layersRendering( mapSettings, image.get() );
    if ( !renderedPainter ) // job has been canceled
    {
      return nullptr;
    }
 
    painter.reset( renderedPainter );
 
    // rendering step for annotations
    annotationsRendering( painter.get(), mapSettings );
 
    // painting is terminated
    painter->end();
 
    // scale output image if necessary (required by WMS spec)
    QImage *scaledImage = scaleImage( image.get() );
    if ( scaledImage )
      image.reset( scaledImage );
 
    // return
    if ( mContext.socketFeedback() && mContext.socketFeedback()->isCanceled() )
    {
      return nullptr;
    }
    return image;
  }
 
  std::unique_ptr<QgsDxfExport> QgsRenderer::getDxf()
  {
    // configure layers
    QList<QgsMapLayer *> layers = mContext.layersToRender();
    configureLayers( layers );
 
    // get dxf layers
    const QStringList attributes = mWmsParameters.dxfLayerAttributes();
    QList<QgsDxfExport::DxfLayer> dxfLayers;
    int layerIdx = -1;
    for ( QgsMapLayer *layer : layers )
    {
      layerIdx++;
      if ( layer->type() != Qgis::LayerType::Vector )
        continue;
 
      // cast for dxf layers
      QgsVectorLayer *vlayer = static_cast<QgsVectorLayer *>( layer );
 
      // get the layer attribute used in dxf
      int layerAttribute = -1;
      if ( attributes.size() > layerIdx )
      {
        layerAttribute = vlayer->fields().indexFromName( attributes[layerIdx] );
      }
 
      dxfLayers.append( QgsDxfExport::DxfLayer( vlayer, layerAttribute ) );
    }
 
    //map extent
    QgsRectangle mapExtent = mWmsParameters.bboxAsRectangle();
 
    QString crs = mWmsParameters.crs();
    if ( crs.compare( u"CRS:84"_s, Qt::CaseInsensitive ) == 0 )
    {
      crs = u"EPSG:4326"_s;
      mapExtent.invert();
    }
    else if ( crs.isEmpty() )
    {
      crs = u"EPSG:4326"_s;
    }
 
    QgsCoordinateReferenceSystem outputCRS = QgsCoordinateReferenceSystem::fromOgcWmsCrs( crs );
 
    if ( !outputCRS.isValid() )
    {
      QgsServiceException::ExceptionCode code;
      QgsWmsParameter parameter;
 
      if ( mWmsParameters.versionAsNumber() >= QgsProjectVersion( 1, 3, 0 ) )
      {
        code = QgsServiceException::OGC_InvalidCRS;
        parameter = mWmsParameters[QgsWmsParameter::CRS];
      }
      else
      {
        code = QgsServiceException::OGC_InvalidSRS;
        parameter = mWmsParameters[QgsWmsParameter::SRS];
      }
 
      throw QgsBadRequestException( code, parameter );
    }
 
    //then set destinationCrs
 
    // Change x- and y- of BBOX for WMS 1.3.0 if axis inverted
    if ( mWmsParameters.versionAsNumber() >= QgsProjectVersion( 1, 3, 0 ) && outputCRS.hasAxisInverted() )
    {
      mapExtent.invert();
    }
 
 
    // add layers to dxf
    auto dxf = std::make_unique<QgsDxfExport>();
    dxf->setExtent( mapExtent );
    dxf->setDestinationCrs( outputCRS );
    dxf->addLayers( dxfLayers );
    dxf->setLayerTitleAsName( mWmsParameters.dxfUseLayerTitleAsName() );
    dxf->setSymbologyExport( mWmsParameters.dxfMode() );
    if ( mWmsParameters.formatOptions<QgsWmsParameters::DxfFormatOption>().contains( QgsWmsParameters::DxfFormatOption::SCALE ) )
    {
      dxf->setSymbologyScale( mWmsParameters.dxfScale() );
    }
 
    dxf->setForce2d( mWmsParameters.isForce2D() );
    QgsDxfExport::Flags flags;
    if ( mWmsParameters.noMText() )
      flags.setFlag( QgsDxfExport::Flag::FlagNoMText );
 
    if ( mWmsParameters.exportLinesWithZeroWidth() )
    {
      flags.setFlag( QgsDxfExport::Flag::FlagHairlineWidthExport );
    }
 
    dxf->setFlags( flags );
 
    return dxf;
  }
 
  std::unique_ptr<QgsMapRendererTask> QgsRenderer::getPdf( const QString &tmpFileName )
  {
    QgsMapSettings ms;
 
    QList<QgsMapLayer *> layers = mContext.layersToRender();
    configureLayers( layers, &ms );
 
    ms.setLayers( layers );
    ms.setExtent( mWmsParameters.bboxAsRectangle() );
    ms.setDestinationCrs( QgsCoordinateReferenceSystem::fromOgcWmsCrs( mWmsParameters.crs() ) );
    ms.setOutputSize( QSize( mWmsParameters.widthAsInt(), mWmsParameters.heightAsInt() ) );
    ms.setDpiTarget( mWmsParameters.dpiAsDouble() );
 
    QgsAbstractGeospatialPdfExporter::ExportDetails pdfExportDetails;
    if ( mWmsParameters.pdfExportMetadata() )
    {
      pdfExportDetails.author = QgsProject::instance()->metadata().author();
      pdfExportDetails.producer = u"QGIS %1"_s.arg( Qgis::version() );
      pdfExportDetails.creator = u"QGIS %1"_s.arg( Qgis::version() );
      pdfExportDetails.creationDateTime = QDateTime::currentDateTime();
      pdfExportDetails.subject = QgsProject::instance()->metadata().abstract();
      pdfExportDetails.title = QgsProject::instance()->metadata().title();
      pdfExportDetails.keywords = QgsProject::instance()->metadata().keywords();
    }
    pdfExportDetails.useIso32000ExtensionFormatGeoreferencing = mWmsParameters.pdfUseIso32000ExtensionFormatGeoreferencing();
    const bool geospatialPdf = mWmsParameters.pdfAppendGeoreference();
    auto pdf = std::make_unique<QgsMapRendererTask>( ms, tmpFileName, u"PDF"_s, false, QgsTask::Hidden, geospatialPdf, pdfExportDetails );
    if ( mWmsParameters.pdfAppendGeoreference() )
    {
      pdf->setSaveWorldFile( true );
    }
    return pdf;
  }
 
  static void infoPointToMapCoordinates( int i, int j, QgsPointXY *infoPoint, const QgsMapSettings &mapSettings )
  {
    //check if i, j are in the pixel range of the image
    if ( i < 0 || i > mapSettings.outputSize().width() )
    {
      QgsWmsParameter param( QgsWmsParameter::I );
      param.mValue = i;
      throw QgsBadRequestException( QgsServiceException::OGC_InvalidPoint, param );
    }
 
    if ( j < 0 || j > mapSettings.outputSize().height() )
    {
      QgsWmsParameter param( QgsWmsParameter::J );
      param.mValue = j;
      throw QgsBadRequestException( QgsServiceException::OGC_InvalidPoint, param );
    }
 
    double xRes = mapSettings.extent().width() / mapSettings.outputSize().width();
    double yRes = mapSettings.extent().height() / mapSettings.outputSize().height();
    infoPoint->setX( mapSettings.extent().xMinimum() + i * xRes + xRes / 2.0 );
    infoPoint->setY( mapSettings.extent().yMaximum() - j * yRes - yRes / 2.0 );
  }
 
  QByteArray QgsRenderer::getFeatureInfo( const QString &version )
  {
    // Verifying Mandatory parameters
    // The QUERY_LAYERS parameter is Mandatory
    if ( mWmsParameters.queryLayersNickname().isEmpty() )
    {
      throw QgsBadRequestException( QgsServiceException::QGIS_MissingParameterValue, mWmsParameters[QgsWmsParameter::QUERY_LAYERS] );
    }
 
    // The I/J parameters are Mandatory if they are not replaced by X/Y or FILTER or FILTER_GEOM
    const bool ijDefined = !mWmsParameters.i().isEmpty() && !mWmsParameters.j().isEmpty();
    const bool xyDefined = !mWmsParameters.x().isEmpty() && !mWmsParameters.y().isEmpty();
    const bool filtersDefined = !mWmsParameters.filters().isEmpty();
    const bool filterGeomDefined = !mWmsParameters.filterGeom().isEmpty();
 
    if ( !ijDefined && !xyDefined && !filtersDefined && !filterGeomDefined )
    {
      QgsWmsParameter parameter = mWmsParameters[QgsWmsParameter::I];
 
      if ( mWmsParameters.j().isEmpty() )
        parameter = mWmsParameters[QgsWmsParameter::J];
 
      throw QgsBadRequestException( QgsServiceException::QGIS_MissingParameterValue, parameter );
    }
 
    const QgsWmsParameters::Format infoFormat = mWmsParameters.infoFormat();
    if ( infoFormat == QgsWmsParameters::Format::NONE )
    {
      throw QgsBadRequestException( QgsServiceException::OGC_InvalidFormat, mWmsParameters[QgsWmsParameter::INFO_FORMAT] );
    }
 
    // create the mapSettings and the output image
    std::unique_ptr<QImage> outputImage( createImage( mContext.mapSize() ) );
 
    // init layer restorer before doing anything
    std::unique_ptr<QgsWmsRestorer> restorer;
    restorer = std::make_unique<QgsWmsRestorer>( mContext );
 
    // The CRS parameter is considered as mandatory in configureMapSettings
    // but in the case of filter parameter, CRS parameter has not to be mandatory
    bool mandatoryCrsParam = true;
    if ( filtersDefined && !ijDefined && !xyDefined && mWmsParameters.crs().isEmpty() )
    {
      mandatoryCrsParam = false;
    }
 
    // configure map settings (background, DPI, ...)
    QgsMapSettings mapSettings;
    mapSettings.setFlag( Qgis::MapSettingsFlag::RenderBlocking );
    configureMapSettings( outputImage.get(), mapSettings, mandatoryCrsParam );
 
    // compute scale denominator
    QgsScaleCalculator scaleCalc( ( outputImage->logicalDpiX() + outputImage->logicalDpiY() ) / 2, mapSettings.destinationCrs().mapUnits() );
    scaleCalc.setEllipsoid( mapSettings.ellipsoid() );
    const double scaleDenominator = scaleCalc.calculate( mWmsParameters.bboxAsRectangle(), outputImage->width() );
 
    // configure layers
    QgsWmsRenderContext context = mContext;
    context.setScaleDenominator( scaleDenominator );
 
    QList<QgsMapLayer *> layers = context.layersToRender();
    configureLayers( layers, &mapSettings );
 
    // add layers to map settings
    mapSettings.setLayers( layers );
 
#ifdef HAVE_SERVER_PYTHON_PLUGINS
    mContext.accessControl()->resolveFilterFeatures( mapSettings.layers() );
#endif
 
    QDomDocument result = featureInfoDocument( layers, mapSettings, outputImage.get(), version );
 
    QByteArray ba;
 
    if ( infoFormat == QgsWmsParameters::Format::TEXT )
      ba = convertFeatureInfoToText( result );
    else if ( infoFormat == QgsWmsParameters::Format::HTML )
      ba = convertFeatureInfoToHtml( result );
    else if ( infoFormat == QgsWmsParameters::Format::JSON )
      ba = convertFeatureInfoToJson( layers, result, mapSettings.destinationCrs() );
    else
      ba = result.toByteArray();
 
    return ba;
  }
 
  QImage *QgsRenderer::createImage( const QSize &size ) const
  {
    std::unique_ptr<QImage> image;
 
    // use alpha channel only if necessary because it slows down performance
    QgsWmsParameters::Format format = mWmsParameters.format();
    bool transparent = mWmsParameters.transparentAsBool();
 
    if ( transparent && format != QgsWmsParameters::JPG )
    {
      image = std::make_unique<QImage>( size, QImage::Format_ARGB32_Premultiplied );
      image->fill( 0 );
    }
    else
    {
      image = std::make_unique<QImage>( size, QImage::Format_RGB32 );
      image->fill( mWmsParameters.backgroundColorAsColor() );
    }
 
    // Check that image was correctly created
    if ( image->isNull() )
    {
      throw QgsException( u"createImage: image could not be created, check for out of memory conditions"_s );
    }
 
    const int dpm = static_cast<int>( mContext.dotsPerMm() * 1000.0 );
    image->setDotsPerMeterX( dpm );
    image->setDotsPerMeterY( dpm );
 
    return image.release();
  }
 
  void QgsRenderer::configureMapSettings( const QPaintDevice *paintDevice, QgsMapSettings &mapSettings, bool mandatoryCrsParam )
  {
    if ( !paintDevice )
    {
      throw QgsException( u"configureMapSettings: no paint device"_s );
    }
 
    mapSettings.setOutputSize( QSize( paintDevice->width(), paintDevice->height() ) );
    // Recalculate from input DPI: do not take the (integer) value from paint device
    // because it loose precision!
    mapSettings.setOutputDpi( mContext.dotsPerMm() * 25.4 );
 
    //map extent
    QgsRectangle mapExtent = mWmsParameters.bboxAsRectangle();
    if ( !mWmsParameters.bbox().isEmpty() && mapExtent.isEmpty() )
    {
      throw QgsBadRequestException( QgsServiceException::QGIS_InvalidParameterValue, mWmsParameters[QgsWmsParameter::BBOX] );
    }
 
    QString crs = mWmsParameters.crs();
    if ( crs.compare( "CRS:84", Qt::CaseInsensitive ) == 0 )
    {
      crs = QString( "EPSG:4326" );
      mapExtent.invert();
    }
    else if ( crs.isEmpty() && !mandatoryCrsParam )
    {
      crs = QString( "EPSG:4326" );
    }
 
    QgsCoordinateReferenceSystem outputCRS;
 
    //wms spec says that CRS parameter is mandatory.
    outputCRS = QgsCoordinateReferenceSystem::fromOgcWmsCrs( crs );
    if ( !outputCRS.isValid() )
    {
      QgsServiceException::ExceptionCode code;
      QgsWmsParameter parameter;
 
      if ( mWmsParameters.versionAsNumber() >= QgsProjectVersion( 1, 3, 0 ) )
      {
        code = QgsServiceException::OGC_InvalidCRS;
        parameter = mWmsParameters[QgsWmsParameter::CRS];
      }
      else
      {
        code = QgsServiceException::OGC_InvalidSRS;
        parameter = mWmsParameters[QgsWmsParameter::SRS];
      }
 
      throw QgsBadRequestException( code, parameter );
    }
 
    //then set destinationCrs
    mapSettings.setDestinationCrs( outputCRS );
 
    mapSettings.setTransformContext( mProject->transformContext() );
    mapSettings.setEllipsoid( mProject->ellipsoid() );
 
    // Change x- and y- of BBOX for WMS 1.3.0 if axis inverted
    if ( mWmsParameters.versionAsNumber() >= QgsProjectVersion( 1, 3, 0 ) && outputCRS.hasAxisInverted() )
    {
      mapExtent.invert();
    }
 
    mapSettings.setExtent( mapExtent );
 
    // set the extent buffer
    mapSettings.setExtentBuffer( mContext.mapTileBuffer( paintDevice->width() ) );
 
    /* Define the background color
     * Transparent or colored
     */
    QgsWmsParameters::Format format = mWmsParameters.format();
    bool transparent = mWmsParameters.transparentAsBool();
    QColor backgroundColor = mWmsParameters.backgroundColorAsColor();
 
    //set background color
    if ( transparent && format != QgsWmsParameters::JPG )
    {
      mapSettings.setBackgroundColor( QColor( 0, 0, 0, 0 ) );
    }
    else if ( backgroundColor.isValid() )
    {
      mapSettings.setBackgroundColor( backgroundColor );
    }
 
    // add context from project (global variables, ...)
    QgsExpressionContext context = mProject->createExpressionContext();
    context << QgsExpressionContextUtils::mapSettingsScope( mapSettings );
    mapSettings.setExpressionContext( context );
 
    // add labeling engine settings
    mapSettings.setLabelingEngineSettings( mProject->labelingEngineSettings() );
 
    mapSettings.setSelectiveMaskingSourceSets( mProject->selectiveMaskingSourceSetManager()->sets() );
 
    mapSettings.setScaleMethod( mProject->scaleMethod() );
 
    // enable rendering optimization
    mapSettings.setFlag( Qgis::MapSettingsFlag::UseRenderingOptimization );
 
    mapSettings.setFlag( Qgis::MapSettingsFlag::RenderMapTile, mContext.renderMapTiles() );
 
    // enable profiling
    if ( mContext.settings().logProfile() )
    {
      mapSettings.setFlag( Qgis::MapSettingsFlag::RecordProfile );
    }
 
    // set selection color
    mapSettings.setSelectionColor( mProject->selectionColor() );
 
    // Set WMS temporal properties
    // Note that this cannot parse multiple time instants while the vector dimensions implementation can
    const QString timeString { mWmsParameters.dimensionValues().value( u"TIME"_s, QString() ) };
    if ( !timeString.isEmpty() )
    {
      bool isValidTemporalRange { true };
      QgsDateTimeRange range;
      // First try with a simple date/datetime instant
      const QDateTime dt { QDateTime::fromString( timeString, Qt::DateFormat::ISODateWithMs ) };
      if ( dt.isValid() )
      {
        range = QgsDateTimeRange( dt, dt );
      }
      else // parse as an interval
      {
        try
        {
          range = QgsServerApiUtils::parseTemporalDateTimeInterval( timeString );
        }
        catch ( const QgsServerApiBadRequestException &ex )
        {
          isValidTemporalRange = false;
          QgsMessageLog::logMessage( u"Could not parse TIME parameter into a temporal range"_s, "Server", Qgis::MessageLevel::Warning );
        }
      }
 
      if ( isValidTemporalRange )
      {
        mIsTemporal = true;
        mapSettings.setIsTemporal( true );
        mapSettings.setTemporalRange( range );
      }
    }
  }
 
  QgsRenderContext QgsRenderer::configureDefaultRenderContext( QPainter *painter )
  {
    QgsRenderContext context = QgsRenderContext::fromQPainter( painter );
    context.setScaleFactor( mContext.dotsPerMm() );
    const double mmPerMapUnit = 1 / QgsServerProjectUtils::wmsDefaultMapUnitsPerMm( *mProject );
    context.setMapToPixel( QgsMapToPixel( 1 / ( mmPerMapUnit * context.scaleFactor() ) ) );
    QgsDistanceArea distanceArea = QgsDistanceArea();
    distanceArea.setSourceCrs( QgsCoordinateReferenceSystem( mWmsParameters.crs() ), mProject->transformContext() );
    distanceArea.setEllipsoid( Qgis::geoNone() );
    context.setDistanceArea( distanceArea );
    return context;
  }
 
  QDomDocument QgsRenderer::featureInfoDocument( QList<QgsMapLayer *> &layers, const QgsMapSettings &mapSettings, const QImage *outputImage, const QString &version ) const
  {
    const QStringList queryLayers = mContext.flattenedQueryLayers( mContext.parameters().queryLayersNickname() );
 
    bool ijDefined = ( !mWmsParameters.i().isEmpty() && !mWmsParameters.j().isEmpty() );
 
    bool xyDefined = ( !mWmsParameters.x().isEmpty() && !mWmsParameters.y().isEmpty() );
 
    bool filtersDefined = !mWmsParameters.filters().isEmpty();
 
    bool filterGeomDefined = !mWmsParameters.filterGeom().isEmpty();
 
    int featureCount = mWmsParameters.featureCountAsInt();
    if ( featureCount < 1 )
    {
      featureCount = 1;
    }
 
    int i = mWmsParameters.iAsInt();
    int j = mWmsParameters.jAsInt();
    if ( xyDefined && !ijDefined )
    {
      i = mWmsParameters.xAsInt();
      j = mWmsParameters.yAsInt();
    }
    int width = mWmsParameters.widthAsInt();
    int height = mWmsParameters.heightAsInt();
    if ( ( i != -1 && j != -1 && width != 0 && height != 0 ) && ( width != outputImage->width() || height != outputImage->height() ) )
    {
      i *= ( outputImage->width() / static_cast<double>( width ) );
      j *= ( outputImage->height() / static_cast<double>( height ) );
    }
 
    // init search variables
    std::unique_ptr<QgsRectangle> featuresRect;
    std::unique_ptr<QgsGeometry> filterGeom;
    std::unique_ptr<QgsPointXY> infoPoint;
 
    if ( i != -1 && j != -1 )
    {
      infoPoint = std::make_unique<QgsPointXY>();
      infoPointToMapCoordinates( i, j, infoPoint.get(), mapSettings );
    }
    else if ( filtersDefined )
    {
      featuresRect = std::make_unique<QgsRectangle>();
    }
 
    if ( filterGeomDefined )
    {
      filterGeom = std::make_unique<QgsGeometry>( QgsGeometry::fromWkt( mWmsParameters.filterGeom() ) );
    }
 
    QDomDocument result;
    const QDomNode header = result.createProcessingInstruction( u"xml"_s, u"version=\"1.0\" encoding=\"UTF-8\""_s );
    result.appendChild( header );
 
    QDomElement getFeatureInfoElement;
    QgsWmsParameters::Format infoFormat = mWmsParameters.infoFormat();
    if ( infoFormat == QgsWmsParameters::Format::GML )
    {
      getFeatureInfoElement = result.createElement( u"wfs:FeatureCollection"_s );
      getFeatureInfoElement.setAttribute( u"xmlns:wfs"_s, u"http://www.opengis.net/wfs"_s );
      getFeatureInfoElement.setAttribute( u"xmlns:ogc"_s, u"http://www.opengis.net/ogc"_s );
      getFeatureInfoElement.setAttribute( u"xmlns:gml"_s, u"http://www.opengis.net/gml"_s );
      getFeatureInfoElement.setAttribute( u"xmlns:ows"_s, u"http://www.opengis.net/ows"_s );
      getFeatureInfoElement.setAttribute( u"xmlns:xlink"_s, u"http://www.w3.org/1999/xlink"_s );
      getFeatureInfoElement.setAttribute( u"xmlns:qgs"_s, u"http://qgis.org/gml"_s );
      getFeatureInfoElement.setAttribute( u"xmlns:xsi"_s, u"http://www.w3.org/2001/XMLSchema-instance"_s );
      getFeatureInfoElement.setAttribute( u"xsi:schemaLocation"_s, u"http://www.opengis.net/wfs http://schemas.opengis.net/wfs/1.0.0/wfs.xsd http://qgis.org/gml"_s );
    }
    else
    {
      QString featureInfoElemName = QgsServerProjectUtils::wmsFeatureInfoDocumentElement( *mProject );
      if ( featureInfoElemName.isEmpty() )
      {
        featureInfoElemName = u"GetFeatureInfoResponse"_s;
      }
      QString featureInfoElemNs = QgsServerProjectUtils::wmsFeatureInfoDocumentElementNs( *mProject );
      if ( featureInfoElemNs.isEmpty() )
      {
        getFeatureInfoElement = result.createElement( featureInfoElemName );
      }
      else
      {
        getFeatureInfoElement = result.createElementNS( featureInfoElemNs, featureInfoElemName );
      }
      //feature info schema
      QString featureInfoSchema = QgsServerProjectUtils::wmsFeatureInfoSchema( *mProject );
      if ( !featureInfoSchema.isEmpty() )
      {
        getFeatureInfoElement.setAttribute( u"xmlns:xsi"_s, u"http://www.w3.org/2001/XMLSchema-instance"_s );
        getFeatureInfoElement.setAttribute( u"xsi:schemaLocation"_s, featureInfoSchema );
      }
    }
    result.appendChild( getFeatureInfoElement );
 
    //Render context is needed to determine feature visibility for vector layers
    QgsRenderContext renderContext = QgsRenderContext::fromMapSettings( mapSettings );
 
    bool sia2045 = QgsServerProjectUtils::wmsInfoFormatSia2045( *mProject );
 
    //layers can have assigned a different name for GetCapabilities
    QHash<QString, QString> layerAliasMap = QgsServerProjectUtils::wmsFeatureInfoLayerAliasMap( *mProject );
 
    for ( const QString &queryLayer : queryLayers )
    {
      bool validLayer = false;
      bool queryableLayer = true;
      for ( QgsMapLayer *layer : std::as_const( layers ) )
      {
        if ( queryLayer == mContext.layerNickname( *layer ) )
        {
          validLayer = true;
          queryableLayer = layer->flags().testFlag( QgsMapLayer::Identifiable );
          if ( !queryableLayer )
          {
            break;
          }
 
          QDomElement layerElement;
          if ( infoFormat == QgsWmsParameters::Format::GML )
          {
            layerElement = getFeatureInfoElement;
          }
          else
          {
            layerElement = result.createElement( u"Layer"_s );
            QString layerName = queryLayer;
 
            //check if the layer is given a different name for GetFeatureInfo output
            QHash<QString, QString>::const_iterator layerAliasIt = layerAliasMap.constFind( layerName );
            if ( layerAliasIt != layerAliasMap.constEnd() )
            {
              layerName = layerAliasIt.value();
            }
 
            layerElement.setAttribute( u"name"_s, layerName );
            const QString layerTitle = layer->serverProperties()->title();
            if ( !layerTitle.isEmpty() )
            {
              layerElement.setAttribute( u"title"_s, layerTitle );
            }
            else
            {
              layerElement.setAttribute( u"title"_s, layerName );
            }
            getFeatureInfoElement.appendChild( layerElement );
            if ( sia2045 ) //the name might not be unique after alias replacement
            {
              layerElement.setAttribute( u"id"_s, layer->id() );
            }
          }
 
          if ( layer->type() == Qgis::LayerType::Vector )
          {
            QgsVectorLayer *vectorLayer = qobject_cast<QgsVectorLayer *>( layer );
            if ( vectorLayer )
            {
              ( void ) featureInfoFromVectorLayer( vectorLayer, infoPoint.get(), featureCount, result, layerElement, mapSettings, renderContext, version, featuresRect.get(), filterGeom.get() );
              break;
            }
          }
          else if ( layer->type() == Qgis::LayerType::Raster )
          {
            QgsRasterLayer *rasterLayer = qobject_cast<QgsRasterLayer *>( layer );
            if ( !rasterLayer )
            {
              break;
            }
            if ( !infoPoint )
            {
              break;
            }
            QgsPointXY layerInfoPoint = mapSettings.mapToLayerCoordinates( layer, *( infoPoint.get() ) );
            if ( !rasterLayer->extent().contains( layerInfoPoint ) )
            {
              break;
            }
            if ( infoFormat == QgsWmsParameters::Format::GML )
            {
              layerElement = result.createElement( u"gml:featureMember"_s /*wfs:FeatureMember*/ );
              getFeatureInfoElement.appendChild( layerElement );
            }
            ( void ) featureInfoFromRasterLayer( rasterLayer, mapSettings, &layerInfoPoint, renderContext, result, layerElement, version );
          }
          else if ( layer->type() == Qgis::LayerType::Mesh )
          {
            QgsMeshLayer *meshLayer = qobject_cast<QgsMeshLayer *>( layer );
            QgsPointXY layerInfoPoint = mapSettings.mapToLayerCoordinates( layer, *( infoPoint.get() ) );
 
            const QgsTriangularMesh *mesh = meshLayer->triangularMesh();
            if ( !mesh )
            {
              meshLayer->updateTriangularMesh( renderContext.coordinateTransform() );
            }
            ( void ) featureInfoFromMeshLayer( meshLayer, mapSettings, &layerInfoPoint, renderContext, result, layerElement, version );
          }
        }
      }
      if ( !validLayer && !mContext.isValidLayer( queryLayer ) && !mContext.isValidGroup( queryLayer ) )
      {
        QgsWmsParameter param( QgsWmsParameter::LAYER );
        param.mValue = queryLayer;
        throw QgsBadRequestException( QgsServiceException::OGC_LayerNotDefined, param );
      }
      else if ( ( validLayer && !queryableLayer ) || ( !validLayer && mContext.isValidGroup( queryLayer ) ) )
      {
        QgsWmsParameter param( QgsWmsParameter::LAYER );
        param.mValue = queryLayer;
        // Check if this layer belongs to a group and the group has any queryable layers
        bool hasGroupAndQueryable { false };
        if ( !mContext.parameters().queryLayersNickname().contains( queryLayer ) )
        {
          // Find which group this layer belongs to
          const QStringList constNicks { mContext.parameters().queryLayersNickname() };
          for ( const QString &ql : constNicks )
          {
            if ( mContext.layerGroups().contains( ql ) )
            {
              const QList<QgsMapLayer *> constLayers { mContext.layerGroups()[ql] };
              for ( const QgsMapLayer *ml : constLayers )
              {
                if ( ( !ml->serverProperties()->shortName().isEmpty() && ml->serverProperties()->shortName() == queryLayer ) || ( ml->name() == queryLayer ) )
                {
                  param.mValue = ql;
                }
                if ( ml->flags().testFlag( QgsMapLayer::Identifiable ) )
                {
                  hasGroupAndQueryable = true;
                  break;
                }
              }
              break;
            }
          }
        }
        // Only throw if it's not a group or the group has no queryable children
        if ( !hasGroupAndQueryable )
        {
          throw QgsBadRequestException( QgsServiceException::OGC_LayerNotQueryable, param );
        }
      }
    }
 
    if ( featuresRect && !featuresRect->isNull() )
    {
      if ( infoFormat == QgsWmsParameters::Format::GML )
      {
        QDomElement bBoxElem = result.createElement( u"gml:boundedBy"_s );
        QDomElement boxElem;
        int gmlVersion = mWmsParameters.infoFormatVersion();
        if ( gmlVersion < 3 )
        {
          boxElem = QgsOgcUtils::rectangleToGMLBox( featuresRect.get(), result, 8 );
        }
        else
        {
          boxElem = QgsOgcUtils::rectangleToGMLEnvelope( featuresRect.get(), result, 8 );
        }
 
        QgsCoordinateReferenceSystem crs = mapSettings.destinationCrs();
        if ( crs.isValid() )
        {
          boxElem.setAttribute( u"srsName"_s, crs.authid() );
        }
        bBoxElem.appendChild( boxElem );
        getFeatureInfoElement.insertBefore( bBoxElem, QDomNode() ); //insert as first child
      }
      else
      {
        QDomElement bBoxElem = result.createElement( u"BoundingBox"_s );
        bBoxElem.setAttribute( u"CRS"_s, mapSettings.destinationCrs().authid() );
        bBoxElem.setAttribute( u"minx"_s, qgsDoubleToString( featuresRect->xMinimum(), 8 ) );
        bBoxElem.setAttribute( u"maxx"_s, qgsDoubleToString( featuresRect->xMaximum(), 8 ) );
        bBoxElem.setAttribute( u"miny"_s, qgsDoubleToString( featuresRect->yMinimum(), 8 ) );
        bBoxElem.setAttribute( u"maxy"_s, qgsDoubleToString( featuresRect->yMaximum(), 8 ) );
        getFeatureInfoElement.insertBefore( bBoxElem, QDomNode() ); //insert as first child
      }
    }
 
    if ( sia2045 && infoFormat == QgsWmsParameters::Format::XML )
    {
      convertFeatureInfoToSia2045( result );
    }
 
    return result;
  }
 
  bool QgsRenderer::featureInfoFromVectorLayer(
    QgsVectorLayer *layer,
    const QgsPointXY *infoPoint,
    int nFeatures,
    QDomDocument &infoDocument,
    QDomElement &layerElement,
    const QgsMapSettings &mapSettings,
    QgsRenderContext &renderContext,
    const QString &version,
    QgsRectangle *featureBBox,
    QgsGeometry *filterGeom
  ) const
  {
    if ( !layer )
    {
      return false;
    }
 
    QgsFeatureRequest fReq;
 
    // Transform filter geometry to layer CRS
    std::unique_ptr<QgsGeometry> layerFilterGeom;
    if ( filterGeom )
    {
      layerFilterGeom = std::make_unique<QgsGeometry>( *filterGeom );
      layerFilterGeom->transform( QgsCoordinateTransform( mapSettings.destinationCrs(), layer->crs(), fReq.transformContext() ) );
    }
 
    //we need a selection rect (0.01 of map width)
    QgsRectangle mapRect = mapSettings.extent();
    QgsRectangle layerRect = mapSettings.mapToLayerCoordinates( layer, mapRect );
 
 
    QgsRectangle searchRect;
 
    //info point could be 0 in case there is only an attribute filter
    if ( infoPoint )
    {
      searchRect = featureInfoSearchRect( layer, mapSettings, renderContext, *infoPoint );
    }
    else if ( layerFilterGeom )
    {
      searchRect = layerFilterGeom->boundingBox();
    }
    else if ( !mWmsParameters.bbox().isEmpty() )
    {
      searchRect = layerRect;
    }
 
    //do a select with searchRect and go through all the features
 
    QgsFeature feature;
    QgsAttributes featureAttributes;
    int featureCounter = 0;
    layer->updateFields();
    const QgsFields fields = layer->fields();
    bool addWktGeometry = ( QgsServerProjectUtils::wmsFeatureInfoAddWktGeometry( *mProject ) && mWmsParameters.withGeometry() );
    bool segmentizeWktGeometry = QgsServerProjectUtils::wmsFeatureInfoSegmentizeWktGeometry( *mProject );
 
    bool hasGeometry = QgsServerProjectUtils::wmsFeatureInfoAddWktGeometry( *mProject ) || addWktGeometry || featureBBox || layerFilterGeom;
    fReq.setFlags( ( ( hasGeometry ) ? Qgis::FeatureRequestFlag::NoFlags : Qgis::FeatureRequestFlag::NoGeometry ) | Qgis::FeatureRequestFlag::ExactIntersect );
 
    if ( !searchRect.isEmpty() )
    {
      fReq.setFilterRect( searchRect );
    }
    else
    {
      fReq.setFlags( fReq.flags() & ~static_cast<int>( Qgis::FeatureRequestFlag::ExactIntersect ) );
    }
 
 
    if ( layerFilterGeom )
    {
      fReq.setFilterExpression( QString( "intersects( $geometry, geom_from_wkt('%1') )" ).arg( layerFilterGeom->asWkt() ) );
    }
 
    Q_NOWARN_DEPRECATED_PUSH
    mFeatureFilter.filterFeatures( layer, fReq );
    Q_NOWARN_DEPRECATED_POP
 
#ifdef HAVE_SERVER_PYTHON_PLUGINS
    Q_NOWARN_DEPRECATED_PUSH
    mContext.accessControl()->filterFeatures( layer, fReq );
    Q_NOWARN_DEPRECATED_POP
 
    QStringList attributes;
    for ( const QgsField &field : fields )
    {
      attributes.append( field.name() );
    }
    attributes = mContext.accessControl()->layerAttributes( layer, attributes );
    fReq.setSubsetOfAttributes( attributes, layer->fields() );
#endif
 
    QgsFeatureIterator fit = layer->getFeatures( fReq );
    std::unique_ptr<QgsFeatureRenderer> r2( layer->renderer() ? layer->renderer()->clone() : nullptr );
    if ( r2 )
    {
      r2->startRender( renderContext, layer->fields() );
    }
 
    bool featureBBoxInitialized = false;
    while ( fit.nextFeature( feature ) )
    {
      if ( layer->wkbType() == Qgis::WkbType::NoGeometry && !searchRect.isEmpty() )
      {
        break;
      }
 
      ++featureCounter;
      if ( featureCounter > nFeatures )
      {
        break;
      }
 
      renderContext.expressionContext().setFeature( feature );
 
      if ( layer->wkbType() != Qgis::WkbType::NoGeometry && !searchRect.isEmpty() )
      {
        if ( !r2 )
        {
          continue;
        }
 
        //check if feature is rendered at all
        bool render = r2->willRenderFeature( feature, renderContext );
        if ( !render )
        {
          continue;
        }
      }
 
      QgsRectangle box;
      if ( layer->wkbType() != Qgis::WkbType::NoGeometry && hasGeometry )
      {
        box = mapSettings.layerExtentToOutputExtent( layer, feature.geometry().boundingBox() );
        if ( featureBBox ) //extend feature info bounding box if requested
        {
          if ( !featureBBoxInitialized && featureBBox->isEmpty() )
          {
            *featureBBox = box;
            featureBBoxInitialized = true;
          }
          else
          {
            featureBBox->combineExtentWith( box );
          }
        }
      }
 
      QgsCoordinateReferenceSystem outputCrs = layer->crs();
      if ( layer->crs() != mapSettings.destinationCrs() )
      {
        outputCrs = mapSettings.destinationCrs();
      }
 
      if ( mWmsParameters.infoFormat() == QgsWmsParameters::Format::GML )
      {
        bool withGeom = layer->wkbType() != Qgis::WkbType::NoGeometry && addWktGeometry;
        int gmlVersion = mWmsParameters.infoFormatVersion();
        QString typeName = mContext.layerNickname( *layer );
        QDomElement elem = createFeatureGML(
          &feature,
          layer,
          infoDocument,
          outputCrs,
          mapSettings,
          typeName,
          withGeom,
          gmlVersion
#ifdef HAVE_SERVER_PYTHON_PLUGINS
          ,
          &attributes
#endif
        );
        QDomElement featureMemberElem = infoDocument.createElement( u"gml:featureMember"_s /*wfs:FeatureMember*/ );
        featureMemberElem.appendChild( elem );
        layerElement.appendChild( featureMemberElem );
        continue;
      }
      else
      {
        QDomElement featureElement = infoDocument.createElement( u"Feature"_s );
        featureElement.setAttribute( u"id"_s, QgsServerFeatureId::getServerFid( feature, layer->dataProvider()->pkAttributeIndexes() ) );
        layerElement.appendChild( featureElement );
 
        featureAttributes = feature.attributes();
        QgsEditFormConfig editConfig = layer->editFormConfig();
        if ( QgsServerProjectUtils::wmsFeatureInfoUseAttributeFormSettings( *mProject ) && editConfig.layout() == Qgis::AttributeFormLayout::DragAndDrop )
        {
          writeAttributesTabLayout(
            editConfig,
            layer,
            fields,
            featureAttributes,
            infoDocument,
            featureElement,
            renderContext
#ifdef HAVE_SERVER_PYTHON_PLUGINS
            ,
            &attributes
#endif
          );
        }
        else
        {
          for ( int i = 0; i < featureAttributes.count(); ++i )
          {
            writeVectorLayerAttribute(
              i,
              layer,
              fields,
              featureAttributes,
              infoDocument,
              featureElement,
              renderContext
#ifdef HAVE_SERVER_PYTHON_PLUGINS
              ,
              &attributes
#endif
            );
          }
        }
 
        //add maptip attribute based on html/expression (in case there is no maptip attribute)
        QString mapTip = layer->mapTipTemplate();
        if ( !mapTip.isEmpty() && ( mWmsParameters.withMapTip() || mWmsParameters.htmlInfoOnlyMapTip() || QgsServerProjectUtils::wmsHTMLFeatureInfoUseOnlyMaptip( *mProject ) ) )
        {
          QDomElement maptipElem = infoDocument.createElement( u"Attribute"_s );
          maptipElem.setAttribute( u"name"_s, u"maptip"_s );
          QgsExpressionContext context { renderContext.expressionContext() };
          context.appendScope( QgsExpressionContextUtils::layerScope( layer ) );
          maptipElem.setAttribute( u"value"_s, QgsExpression::replaceExpressionText( mapTip, &context ) );
          featureElement.appendChild( maptipElem );
        }
 
        QgsExpression displayExpression = layer->displayExpression();
        if ( displayExpression.isValid() && mWmsParameters.withDisplayName() )
        {
          QDomElement displayElem = infoDocument.createElement( u"Attribute"_s );
          displayElem.setAttribute( u"name"_s, u"displayName"_s );
          QgsExpressionContext context { renderContext.expressionContext() };
          context.appendScope( QgsExpressionContextUtils::layerScope( layer ) );
          displayExpression.prepare( &context );
          displayElem.setAttribute( u"value"_s, displayExpression.evaluate( &context ).toString() );
          featureElement.appendChild( displayElem );
        }
 
        //append feature bounding box to feature info xml
        if ( QgsServerProjectUtils::wmsFeatureInfoAddWktGeometry( *mProject ) && layer->wkbType() != Qgis::WkbType::NoGeometry && hasGeometry )
        {
          QDomElement bBoxElem = infoDocument.createElement( u"BoundingBox"_s );
          bBoxElem.setAttribute( version == "1.1.1"_L1 ? "SRS" : "CRS", outputCrs.authid() );
          bBoxElem.setAttribute( u"minx"_s, qgsDoubleToString( box.xMinimum(), mContext.precision() ) );
          bBoxElem.setAttribute( u"maxx"_s, qgsDoubleToString( box.xMaximum(), mContext.precision() ) );
          bBoxElem.setAttribute( u"miny"_s, qgsDoubleToString( box.yMinimum(), mContext.precision() ) );
          bBoxElem.setAttribute( u"maxy"_s, qgsDoubleToString( box.yMaximum(), mContext.precision() ) );
          featureElement.appendChild( bBoxElem );
        }
 
        //also append the wkt geometry as an attribute
        if ( layer->wkbType() != Qgis::WkbType::NoGeometry && addWktGeometry && hasGeometry )
        {
          QgsGeometry geom = feature.geometry();
          if ( !geom.isNull() )
          {
            if ( layer->crs() != outputCrs )
            {
              QgsCoordinateTransform transform = mapSettings.layerTransform( layer );
              if ( transform.isValid() )
                geom.transform( transform );
            }
 
            if ( segmentizeWktGeometry )
            {
              const QgsAbstractGeometry *abstractGeom = geom.constGet();
              if ( abstractGeom )
              {
                if ( QgsWkbTypes::isCurvedType( abstractGeom->wkbType() ) )
                {
                  QgsAbstractGeometry *segmentizedGeom = abstractGeom->segmentize();
                  geom.set( segmentizedGeom );
                }
              }
            }
            QDomElement geometryElement = infoDocument.createElement( u"Attribute"_s );
            geometryElement.setAttribute( u"name"_s, u"geometry"_s );
            geometryElement.setAttribute( u"value"_s, geom.asWkt( mContext.precision() ) );
            geometryElement.setAttribute( u"type"_s, u"derived"_s );
            featureElement.appendChild( geometryElement );
          }
        }
      }
    }
    if ( r2 )
    {
      r2->stopRender( renderContext );
    }
 
    return true;
  }
 
  void QgsRenderer::writeAttributesTabGroup(
    const QgsAttributeEditorElement *group,
    QgsVectorLayer *layer,
    const QgsFields &fields,
    QgsAttributes &featureAttributes,
    QDomDocument &doc,
    QDomElement &parentElem,
    QgsRenderContext &renderContext,
    QStringList *attributes
  ) const
  {
    const QgsAttributeEditorContainer *container = dynamic_cast<const QgsAttributeEditorContainer *>( group );
    if ( container )
    {
      QString groupName = container->name();
      QDomElement nameElem;
 
      if ( !groupName.isEmpty() )
      {
        nameElem = doc.createElement( groupName );
        parentElem.appendChild( nameElem );
      }
 
      const QList<QgsAttributeEditorElement *> children = container->children();
      for ( const QgsAttributeEditorElement *child : children )
      {
        if ( child->type() == Qgis::AttributeEditorType::Container )
        {
          writeAttributesTabGroup( child, layer, fields, featureAttributes, doc, nameElem.isNull() ? parentElem : nameElem, renderContext );
        }
        else if ( child->type() == Qgis::AttributeEditorType::Field )
        {
          const QgsAttributeEditorField *editorField = dynamic_cast<const QgsAttributeEditorField *>( child );
          if ( editorField )
          {
            const int idx { fields.indexFromName( editorField->name() ) };
            if ( idx >= 0 )
            {
              writeVectorLayerAttribute( idx, layer, fields, featureAttributes, doc, nameElem.isNull() ? parentElem : nameElem, renderContext, attributes );
            }
          }
        }
      }
    }
  }
 
  void QgsRenderer::writeAttributesTabLayout(
    QgsEditFormConfig &config, QgsVectorLayer *layer, const QgsFields &fields, QgsAttributes &featureAttributes, QDomDocument &doc, QDomElement &featureElem, QgsRenderContext &renderContext, QStringList *attributes
  ) const
  {
    QgsAttributeEditorContainer *editorContainer = config.invisibleRootContainer();
    if ( !editorContainer )
    {
      return;
    }
 
    writeAttributesTabGroup( editorContainer, layer, fields, featureAttributes, doc, featureElem, renderContext, attributes );
  }
 
  void QgsRenderer::writeVectorLayerAttribute(
    int attributeIndex, QgsVectorLayer *layer, const QgsFields &fields, QgsAttributes &featureAttributes, QDomDocument &doc, QDomElement &featureElem, QgsRenderContext &renderContext, QStringList *attributes
  ) const
  {
#ifndef HAVE_SERVER_PYTHON_PLUGINS
    Q_UNUSED( attributes );
#endif
 
    if ( !layer )
    {
      return;
    }
 
    //skip attribute if it is explicitly excluded from WMS publication
    if ( fields.at( attributeIndex ).configurationFlags().testFlag( Qgis::FieldConfigurationFlag::HideFromWms ) )
    {
      return;
    }
#ifdef HAVE_SERVER_PYTHON_PLUGINS
    //skip attribute if it is excluded by access control
    if ( attributes && !attributes->contains( fields.at( attributeIndex ).name() ) )
    {
      return;
    }
#endif
 
    QString attributeName = layer->attributeDisplayName( attributeIndex );
    QDomElement attributeElement = doc.createElement( u"Attribute"_s );
    attributeElement.setAttribute( u"name"_s, attributeName );
    const QgsEditorWidgetSetup setup = layer->editorWidgetSetup( attributeIndex );
    attributeElement.setAttribute( u"value"_s, QgsExpression::replaceExpressionText( replaceValueMapAndRelation( layer, attributeIndex, featureAttributes[attributeIndex] ), &renderContext.expressionContext() ) );
    featureElem.appendChild( attributeElement );
  }
 
  bool QgsRenderer::featureInfoFromMeshLayer(
    QgsMeshLayer *layer, const QgsMapSettings &mapSettings, const QgsPointXY *infoPoint, const QgsRenderContext &renderContext, QDomDocument &infoDocument, QDomElement &layerElement, const QString &version
  ) const
  {
    Q_UNUSED( version )
    Q_UNUSED( mapSettings )
 
    if ( !infoPoint || !layer || !layer->dataProvider() )
    {
      return false;
    }
 
    const bool isTemporal = layer->temporalProperties()->isActive();
    QgsDateTimeRange range, layerRange;
    const QString dateFormat = u"yyyy-MM-ddTHH:mm:ss"_s;
 
    QList<QgsMeshDatasetIndex> datasetIndexList;
    const int activeScalarGroup = layer->rendererSettings().activeScalarDatasetGroup();
    const int activeVectorGroup = layer->rendererSettings().activeVectorDatasetGroup();
 
    const QList<int> allGroup = layer->enabledDatasetGroupsIndexes();
 
    if ( isTemporal )
    {
      range = renderContext.temporalRange();
      layerRange = static_cast<QgsMeshLayerTemporalProperties *>( layer->temporalProperties() )->timeExtent();
 
      if ( activeScalarGroup >= 0 )
      {
        QgsMeshDatasetIndex indice;
        indice = layer->activeScalarDatasetAtTime( range );
        datasetIndexList.append( indice );
      }
 
      if ( activeVectorGroup >= 0 && activeVectorGroup != activeScalarGroup )
        datasetIndexList.append( layer->activeVectorDatasetAtTime( range ) );
 
      for ( int groupIndex : allGroup )
      {
        if ( groupIndex != activeScalarGroup && groupIndex != activeVectorGroup )
          datasetIndexList.append( layer->datasetIndexAtTime( range, groupIndex ) );
      }
    }
    else
    {
      if ( activeScalarGroup >= 0 )
        datasetIndexList.append( layer->staticScalarDatasetIndex() );
      if ( activeVectorGroup >= 0 && activeVectorGroup != activeScalarGroup )
        datasetIndexList.append( layer->staticVectorDatasetIndex() );
 
      for ( int groupIndex : allGroup )
      {
        if ( groupIndex != activeScalarGroup && groupIndex != activeVectorGroup )
        {
          if ( !layer->datasetGroupMetadata( groupIndex ).isTemporal() )
            datasetIndexList.append( groupIndex );
        }
      }
    }
 
    const double searchRadius = Qgis::DEFAULT_SEARCH_RADIUS_MM * renderContext.scaleFactor() * renderContext.mapToPixel().mapUnitsPerPixel();
 
    double scalarDoubleValue = 0.0;
 
    for ( const QgsMeshDatasetIndex &index : datasetIndexList )
    {
      if ( !index.isValid() )
        continue;
 
      const QgsMeshDatasetGroupMetadata &groupMeta = layer->datasetGroupMetadata( index );
      QMap<QString, QString> derivedAttributes;
 
      QMap<QString, QString> attribute;
 
      if ( groupMeta.isScalar() )
      {
        const QgsMeshDatasetValue scalarValue = layer->datasetValue( index, *infoPoint, searchRadius );
        scalarDoubleValue = scalarValue.scalar();
        attribute.insert( u"Scalar Value"_s, std::isnan( scalarDoubleValue ) ? u"no data"_s : QLocale().toString( scalarDoubleValue ) );
      }
 
      if ( groupMeta.isVector() )
      {
        const QgsMeshDatasetValue vectorValue = layer->datasetValue( index, *infoPoint, searchRadius );
        const double vectorX = vectorValue.x();
        const double vectorY = vectorValue.y();
        if ( std::isnan( vectorX ) || std::isnan( vectorY ) )
        {
          attribute.insert( u"Vector Value"_s, u"no data"_s );
        }
        else
        {
          attribute.insert( u"Vector Magnitude"_s, QLocale().toString( vectorValue.scalar() ) );
          derivedAttributes.insert( u"Vector x-component"_s, QLocale().toString( vectorY ) );
          derivedAttributes.insert( u"Vector y-component"_s, QLocale().toString( vectorX ) );
        }
      }
 
      const QgsMeshDatasetMetadata &meta = layer->datasetMetadata( index );
 
      if ( groupMeta.isTemporal() )
        derivedAttributes.insert( u"Time Step"_s, layer->formatTime( meta.time() ) );
      derivedAttributes.insert( u"Source"_s, groupMeta.uri() );
 
      const QString resultName = groupMeta.name();
 
      QDomElement attributeElement = infoDocument.createElement( u"Attribute"_s );
      attributeElement.setAttribute( u"name"_s, resultName );
 
      QString value;
      if ( !QgsVariantUtils::isNull( scalarDoubleValue ) )
      {
        value = QString::number( scalarDoubleValue );
      }
 
      attributeElement.setAttribute( u"value"_s, value );
      layerElement.appendChild( attributeElement );
 
      if ( isTemporal )
      {
        QDomElement attributeElementTime = infoDocument.createElement( u"Attribute"_s );
        attributeElementTime.setAttribute( u"name"_s, u"Time"_s );
        if ( range.isInstant() )
        {
          value = range.begin().toString( dateFormat );
        }
        else
        {
          value = range.begin().toString( dateFormat ) + '/' + range.end().toString( dateFormat );
        }
        attributeElementTime.setAttribute( u"value"_s, value );
        layerElement.appendChild( attributeElementTime );
      }
    }
    return true;
  }
 
  bool QgsRenderer::featureInfoFromRasterLayer(
    QgsRasterLayer *layer, const QgsMapSettings &mapSettings, const QgsPointXY *infoPoint, const QgsRenderContext &renderContext, QDomDocument &infoDocument, QDomElement &layerElement, const QString &version
  ) const
  {
    Q_UNUSED( version )
 
    if ( !infoPoint || !layer || !layer->dataProvider() )
    {
      return false;
    }
 
    QgsMessageLog::logMessage( u"infoPoint: %1 %2"_s.arg( infoPoint->x() ).arg( infoPoint->y() ), u"Server"_s, Qgis::MessageLevel::Info );
 
    if ( !( layer->dataProvider()->capabilities() & Qgis::RasterInterfaceCapability::IdentifyValue ) && !( layer->dataProvider()->capabilities() & Qgis::RasterInterfaceCapability::IdentifyFeature ) )
    {
      return false;
    }
 
    const Qgis::RasterIdentifyFormat identifyFormat(
      static_cast<bool>( layer->dataProvider()->capabilities() & Qgis::RasterInterfaceCapability::IdentifyFeature ) ? Qgis::RasterIdentifyFormat::Feature : Qgis::RasterIdentifyFormat::Value
    );
 
    QgsRasterIdentifyResult identifyResult;
    if ( layer->crs() != mapSettings.destinationCrs() )
    {
      const QgsRectangle extent { mapSettings.extent() };
      const QgsCoordinateTransform transform { mapSettings.destinationCrs(), layer->crs(), mapSettings.transformContext() };
      if ( !transform.isValid() )
      {
        throw QgsBadRequestException(
          QgsServiceException::OGC_InvalidCRS, u"CRS transform error from %1 to %2 in layer %3"_s.arg( mapSettings.destinationCrs().authid() ).arg( layer->crs().authid() ).arg( layer->name() )
        );
      }
      identifyResult = layer->dataProvider()->identify( *infoPoint, identifyFormat, transform.transform( extent ), mapSettings.outputSize().width(), mapSettings.outputSize().height() );
    }
    else
    {
      identifyResult = layer->dataProvider()->identify( *infoPoint, identifyFormat, mapSettings.extent(), mapSettings.outputSize().width(), mapSettings.outputSize().height() );
    }
 
    if ( !identifyResult.isValid() )
      return false;
 
    QMap<int, QVariant> attributes = identifyResult.results();
 
    if ( mWmsParameters.infoFormat() == QgsWmsParameters::Format::GML )
    {
      QgsFeature feature;
      QgsFields fields;
      QgsCoordinateReferenceSystem layerCrs = layer->crs();
      int gmlVersion = mWmsParameters.infoFormatVersion();
      QString typeName = mContext.layerNickname( *layer );
 
      if ( identifyFormat == Qgis::RasterIdentifyFormat::Value )
      {
        feature.initAttributes( attributes.count() );
        int index = 0;
        for ( auto it = attributes.constBegin(); it != attributes.constEnd(); ++it )
        {
          fields.append( QgsField( layer->bandName( it.key() ), QMetaType::Type::Double ) );
          feature.setAttribute( index++, QString::number( it.value().toDouble() ) );
        }
        feature.setFields( fields );
        QDomElement elem = createFeatureGML( &feature, nullptr, infoDocument, layerCrs, mapSettings, typeName, false, gmlVersion, nullptr );
        layerElement.appendChild( elem );
      }
      else
      {
        const auto values = identifyResult.results();
        for ( auto it = values.constBegin(); it != values.constEnd(); ++it )
        {
          QVariant value = it.value();
          if ( value.userType() == QMetaType::Type::Bool && !value.toBool() )
          {
            // sublayer not visible or not queryable
            continue;
          }
 
          if ( value.userType() == QMetaType::Type::QString )
          {
            continue;
          }
 
          // list of feature stores for a single sublayer
          const QgsFeatureStoreList featureStoreList = it.value().value<QgsFeatureStoreList>();
 
          for ( const QgsFeatureStore &featureStore : featureStoreList )
          {
            const QgsFeatureList storeFeatures = featureStore.features();
            for ( const QgsFeature &feature : storeFeatures )
            {
              QDomElement elem = createFeatureGML( &feature, nullptr, infoDocument, layerCrs, mapSettings, typeName, false, gmlVersion, nullptr );
              layerElement.appendChild( elem );
            }
          }
        }
      }
    }
    else
    {
      if ( identifyFormat == Qgis::RasterIdentifyFormat::Value )
      {
        for ( auto it = attributes.constBegin(); it != attributes.constEnd(); ++it )
        {
          QDomElement attributeElement = infoDocument.createElement( u"Attribute"_s );
          attributeElement.setAttribute( u"name"_s, layer->bandName( it.key() ) );
 
          QString value;
          if ( !QgsVariantUtils::isNull( it.value() ) )
          {
            value = QString::number( it.value().toDouble() );
          }
 
          attributeElement.setAttribute( u"value"_s, value );
          layerElement.appendChild( attributeElement );
        }
      }
      else // feature
      {
        const auto values = identifyResult.results();
        for ( auto it = values.constBegin(); it != values.constEnd(); ++it )
        {
          QVariant value = it.value();
          if ( value.userType() == QMetaType::Type::Bool && !value.toBool() )
          {
            // sublayer not visible or not queryable
            continue;
          }
 
          if ( value.userType() == QMetaType::Type::QString )
          {
            continue;
          }
 
          // list of feature stores for a single sublayer
          const QgsFeatureStoreList featureStoreList = it.value().value<QgsFeatureStoreList>();
          for ( const QgsFeatureStore &featureStore : featureStoreList )
          {
            const QgsFeatureList storeFeatures = featureStore.features();
            for ( const QgsFeature &feature : storeFeatures )
            {
              for ( const auto &fld : feature.fields() )
              {
                const auto val { feature.attribute( fld.name() ) };
                if ( val.isValid() )
                {
                  QDomElement attributeElement = infoDocument.createElement( u"Attribute"_s );
                  attributeElement.setAttribute( u"name"_s, fld.name() );
                  attributeElement.setAttribute( u"value"_s, val.toString() );
                  layerElement.appendChild( attributeElement );
                }
              }
            }
          }
        }
      }
      //add maptip attribute based on html/expression
      QString mapTip = layer->mapTipTemplate();
      if ( !mapTip.isEmpty() && ( mWmsParameters.withMapTip() || mWmsParameters.htmlInfoOnlyMapTip() || QgsServerProjectUtils::wmsHTMLFeatureInfoUseOnlyMaptip( *mProject ) ) )
      {
        QDomElement maptipElem = infoDocument.createElement( u"Attribute"_s );
        maptipElem.setAttribute( u"name"_s, u"maptip"_s );
        QgsExpressionContext context { renderContext.expressionContext() };
        QgsExpressionContextScope *scope = QgsExpressionContextUtils::layerScope( layer );
        scope->addVariable( QgsExpressionContextScope::StaticVariable( u"layer_cursor_point"_s, QVariant::fromValue( QgsGeometry::fromPointXY( QgsPointXY( infoPoint->x(), infoPoint->y() ) ) ) ) );
        context.appendScope( scope );
        maptipElem.setAttribute( u"value"_s, QgsExpression::replaceExpressionText( mapTip, &context ) );
        layerElement.appendChild( maptipElem );
      }
    }
    return true;
  }
 
  bool QgsRenderer::testFilterStringSafety( const QString &filter ) const
  {
    //; too dangerous for sql injections
    if ( filter.contains( ";"_L1 ) )
    {
      return false;
    }
 
    QStringList tokens = filter.split( ' ', Qt::SkipEmptyParts );
    groupStringList( tokens, u"'"_s );
    groupStringList( tokens, u"\""_s );
 
    for ( auto tokenIt = tokens.constBegin(); tokenIt != tokens.constEnd(); ++tokenIt )
    {
      //allowlist of allowed characters and keywords
      if ( tokenIt->compare( ','_L1 ) == 0
           || tokenIt->compare( '('_L1 ) == 0
           || tokenIt->compare( ')'_L1 ) == 0
           || tokenIt->compare( '='_L1 ) == 0
           || tokenIt->compare( "!="_L1 ) == 0
           || tokenIt->compare( '<'_L1 ) == 0
           || tokenIt->compare( "<="_L1 ) == 0
           || tokenIt->compare( '>'_L1 ) == 0
           || tokenIt->compare( ">="_L1 ) == 0
           || tokenIt->compare( '%'_L1 ) == 0
           || tokenIt->compare( "IS"_L1, Qt::CaseInsensitive ) == 0
           || tokenIt->compare( "NOT"_L1, Qt::CaseInsensitive ) == 0
           || tokenIt->compare( "NULL"_L1, Qt::CaseInsensitive ) == 0
           || tokenIt->compare( "AND"_L1, Qt::CaseInsensitive ) == 0
           || tokenIt->compare( "OR"_L1, Qt::CaseInsensitive ) == 0
           || tokenIt->compare( "IN"_L1, Qt::CaseInsensitive ) == 0
           || tokenIt->compare( "LIKE"_L1, Qt::CaseInsensitive ) == 0
           || tokenIt->compare( "ILIKE"_L1, Qt::CaseInsensitive ) == 0
           || tokenIt->compare( "DMETAPHONE"_L1, Qt::CaseInsensitive ) == 0
           || tokenIt->compare( "SOUNDEX"_L1, Qt::CaseInsensitive ) == 0
           || mContext.settings().allowedExtraSqlTokens().contains( *tokenIt, Qt::CaseSensitivity::CaseInsensitive ) )
      {
        continue;
      }
 
      //numbers are OK
      bool isNumeric;
      ( void ) tokenIt->toDouble( &isNumeric );
      if ( isNumeric )
      {
        continue;
      }
 
      //numeric strings need to be quoted once either with single or with double quotes
 
      //empty strings are OK
      if ( *tokenIt == "''"_L1 )
      {
        continue;
      }
 
      //single quote
      if ( tokenIt->size() > 2
           && ( *tokenIt )[0] == QChar( '\'' )
           && ( *tokenIt )[tokenIt->size() - 1] == QChar( '\'' )
           && ( *tokenIt )[1] != QChar( '\'' )
           && ( *tokenIt )[tokenIt->size() - 2] != QChar( '\'' ) )
      {
        continue;
      }
 
      //double quote
      if ( tokenIt->size() > 2 && ( *tokenIt )[0] == QChar( '"' ) && ( *tokenIt )[tokenIt->size() - 1] == QChar( '"' ) && ( *tokenIt )[1] != QChar( '"' ) && ( *tokenIt )[tokenIt->size() - 2] != QChar( '"' ) )
      {
        continue;
      }
 
      return false;
    }
 
    return true;
  }
 
  void QgsRenderer::groupStringList( QStringList &list, const QString &groupString )
  {
    //group contents within single quotes together
    bool groupActive = false;
    int startGroup = -1;
    QString concatString;
 
    for ( int i = 0; i < list.size(); ++i )
    {
      QString &str = list[i];
      if ( str.startsWith( groupString ) )
      {
        startGroup = i;
        groupActive = true;
        concatString.clear();
      }
 
      if ( groupActive )
      {
        if ( i != startGroup )
        {
          concatString.append( " " );
        }
        concatString.append( str );
      }
 
      if ( str.endsWith( groupString ) )
      {
        int endGroup = i;
        groupActive = false;
 
        if ( startGroup != -1 )
        {
          list[startGroup] = concatString;
          for ( int j = startGroup + 1; j <= endGroup; ++j )
          {
            list.removeAt( startGroup + 1 );
            --i;
          }
        }
 
        concatString.clear();
        startGroup = -1;
      }
    }
  }
 
  void QgsRenderer::convertFeatureInfoToSia2045( QDomDocument &doc ) const
  {
    QDomDocument SIAInfoDoc;
    QDomElement infoDocElement = doc.documentElement();
    QDomElement SIAInfoDocElement = SIAInfoDoc.importNode( infoDocElement, false ).toElement();
    SIAInfoDoc.appendChild( SIAInfoDocElement );
 
    QString currentAttributeName;
    QString currentAttributeValue;
    QDomElement currentAttributeElem;
    QString currentLayerName;
    QDomElement currentLayerElem;
    QDomNodeList layerNodeList = infoDocElement.elementsByTagName( u"Layer"_s );
    for ( int i = 0; i < layerNodeList.size(); ++i )
    {
      currentLayerElem = layerNodeList.at( i ).toElement();
      currentLayerName = currentLayerElem.attribute( u"name"_s );
 
      QDomElement currentFeatureElem;
 
      QDomNodeList featureList = currentLayerElem.elementsByTagName( u"Feature"_s );
      if ( featureList.isEmpty() )
      {
        //raster?
        QDomNodeList attributeList = currentLayerElem.elementsByTagName( u"Attribute"_s );
        QDomElement rasterLayerElem;
        if ( !attributeList.isEmpty() )
        {
          rasterLayerElem = SIAInfoDoc.createElement( currentLayerName );
        }
        for ( int j = 0; j < attributeList.size(); ++j )
        {
          currentAttributeElem = attributeList.at( j ).toElement();
          currentAttributeName = currentAttributeElem.attribute( u"name"_s );
          currentAttributeValue = currentAttributeElem.attribute( u"value"_s );
          QDomElement outAttributeElem = SIAInfoDoc.createElement( currentAttributeName );
          QDomText outAttributeText = SIAInfoDoc.createTextNode( currentAttributeValue );
          outAttributeElem.appendChild( outAttributeText );
          rasterLayerElem.appendChild( outAttributeElem );
        }
        if ( !attributeList.isEmpty() )
        {
          SIAInfoDocElement.appendChild( rasterLayerElem );
        }
      }
      else //vector
      {
        //property attributes
        QSet<QString> layerPropertyAttributes;
        QString currentLayerId = currentLayerElem.attribute( u"id"_s );
        if ( !currentLayerId.isEmpty() )
        {
          QgsMapLayer *currentLayer = mProject->mapLayer( currentLayerId );
          if ( currentLayer )
          {
            QString WMSPropertyAttributesString = currentLayer->customProperty( u"WMSPropertyAttributes"_s ).toString();
            if ( !WMSPropertyAttributesString.isEmpty() )
            {
              QStringList propertyList = WMSPropertyAttributesString.split( u"//"_s );
              for ( auto propertyIt = propertyList.constBegin(); propertyIt != propertyList.constEnd(); ++propertyIt )
              {
                layerPropertyAttributes.insert( *propertyIt );
              }
            }
          }
        }
 
        QDomElement propertyRefChild; //child to insert the next property after (or
        for ( int j = 0; j < featureList.size(); ++j )
        {
          QDomElement SIAFeatureElem = SIAInfoDoc.createElement( currentLayerName );
          currentFeatureElem = featureList.at( j ).toElement();
          QDomNodeList attributeList = currentFeatureElem.elementsByTagName( u"Attribute"_s );
 
          for ( int k = 0; k < attributeList.size(); ++k )
          {
            currentAttributeElem = attributeList.at( k ).toElement();
            currentAttributeName = currentAttributeElem.attribute( u"name"_s );
            currentAttributeValue = currentAttributeElem.attribute( u"value"_s );
            if ( layerPropertyAttributes.contains( currentAttributeName ) )
            {
              QDomElement propertyElem = SIAInfoDoc.createElement( u"property"_s );
              QDomElement identifierElem = SIAInfoDoc.createElement( u"identifier"_s );
              QDomText identifierText = SIAInfoDoc.createTextNode( currentAttributeName );
              identifierElem.appendChild( identifierText );
              QDomElement valueElem = SIAInfoDoc.createElement( u"value"_s );
              QDomText valueText = SIAInfoDoc.createTextNode( currentAttributeValue );
              valueElem.appendChild( valueText );
              propertyElem.appendChild( identifierElem );
              propertyElem.appendChild( valueElem );
              if ( propertyRefChild.isNull() )
              {
                SIAFeatureElem.insertBefore( propertyElem, QDomNode() );
                propertyRefChild = propertyElem;
              }
              else
              {
                SIAFeatureElem.insertAfter( propertyElem, propertyRefChild );
              }
            }
            else
            {
              QDomElement SIAAttributeElem = SIAInfoDoc.createElement( currentAttributeName );
              QDomText SIAAttributeText = SIAInfoDoc.createTextNode( currentAttributeValue );
              SIAAttributeElem.appendChild( SIAAttributeText );
              SIAFeatureElem.appendChild( SIAAttributeElem );
            }
          }
          SIAInfoDocElement.appendChild( SIAFeatureElem );
        }
      }
    }
    doc = SIAInfoDoc;
  }
 
  QByteArray QgsRenderer::convertFeatureInfoToHtml( const QDomDocument &doc ) const
  {
    const bool onlyMapTip = mWmsParameters.htmlInfoOnlyMapTip() || QgsServerProjectUtils::wmsHTMLFeatureInfoUseOnlyMaptip( *mProject );
    QString featureInfoString = u"    <!DOCTYPE html>"_s;
    if ( !onlyMapTip )
    {
      featureInfoString.append( QStringLiteral( R"HTML(
 
    <head>
      <title>Information</title>
      <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
      <style>
        body {
          font-family: "Open Sans", "Calluna Sans", "Gill Sans MT", "Calibri", "Trebuchet MS", sans-serif;
        }
 
        table,
        th,
        td {
          width: 100%;
          border: 1px solid black;
          border-collapse: collapse;
          text-align: left;
          padding: 2px;
        }
 
        th {
          width: 25%;
          font-weight: bold;
        }
 
        .layer-title {
          font-weight: bold;
          padding: 2px;
        }
      </style>
    </head>
 
    <body>
    )HTML" ) );
    }
 
    const QDomNodeList layerList = doc.elementsByTagName( u"Layer"_s );
 
    //layer loop
    for ( int i = 0; i < layerList.size(); ++i )
    {
      const QDomElement layerElem = layerList.at( i ).toElement();
 
      //feature loop (for vector layers)
      const QDomNodeList featureNodeList = layerElem.elementsByTagName( u"Feature"_s );
      const QDomElement currentFeatureElement;
 
      if ( !featureNodeList.isEmpty() ) //vector layer
      {
        if ( !onlyMapTip )
        {
          const QString featureInfoLayerTitleString = u"  <div class='layer-title'>%1</div>"_s.arg( layerElem.attribute( u"title"_s ).toHtmlEscaped() );
          featureInfoString.append( featureInfoLayerTitleString );
        }
 
        for ( int j = 0; j < featureNodeList.size(); ++j )
        {
          const QDomElement featureElement = featureNodeList.at( j ).toElement();
          if ( !onlyMapTip )
          {
            featureInfoString.append( QStringLiteral( R"HTML(
      <table>)HTML" ) );
          }
 
          //attribute loop
          const QDomNodeList attributeNodeList = featureElement.elementsByTagName( u"Attribute"_s );
          for ( int k = 0; k < attributeNodeList.size(); ++k )
          {
            const QDomElement attributeElement = attributeNodeList.at( k ).toElement();
            const QString name = attributeElement.attribute( u"name"_s ).toHtmlEscaped();
            QString value = attributeElement.attribute( u"value"_s );
            if ( name != "maptip"_L1 )
            {
              value = value.toHtmlEscaped();
            }
 
            if ( !onlyMapTip )
            {
              const QString featureInfoAttributeString = QStringLiteral( R"HTML(
        <tr>
          <th>%1</th>
          <td>%2</td>
        </tr>)HTML" )
                                                           .arg( name, value );
 
              featureInfoString.append( featureInfoAttributeString );
            }
            else if ( name == "maptip"_L1 )
            {
              featureInfoString.append( QStringLiteral( R"HTML(
      %1)HTML" )
                                          .arg( value ) );
              break;
            }
          }
          if ( !onlyMapTip )
          {
            featureInfoString.append( QStringLiteral( R"HTML(
      </table>)HTML" ) );
          }
        }
      }
      else //no result or raster layer
      {
        const QDomNodeList attributeNodeList = layerElem.elementsByTagName( u"Attribute"_s );
 
        //  raster layer
        if ( !attributeNodeList.isEmpty() )
        {
          if ( !onlyMapTip )
          {
            const QString featureInfoLayerTitleString = u"  <div class='layer-title'>%1</div>"_s.arg( layerElem.attribute( u"title"_s ).toHtmlEscaped() );
            featureInfoString.append( featureInfoLayerTitleString );
 
            featureInfoString.append( QStringLiteral( R"HTML(
      <table>)HTML" ) );
          }
 
          for ( int j = 0; j < attributeNodeList.size(); ++j )
          {
            const QDomElement attributeElement = attributeNodeList.at( j ).toElement();
            const QString name = attributeElement.attribute( u"name"_s ).toHtmlEscaped();
            QString value = attributeElement.attribute( u"value"_s );
            if ( value.isEmpty() )
            {
              value = u"no data"_s;
            }
            if ( name != "maptip"_L1 )
            {
              value = value.toHtmlEscaped();
            }
 
            if ( !onlyMapTip )
            {
              const QString featureInfoAttributeString = QStringLiteral( R"HTML(
        <tr>
          <th>%1</th>
          <td>%2</td>
        </tr>)HTML" )
                                                           .arg( name, value );
 
 
              featureInfoString.append( featureInfoAttributeString );
            }
            else if ( name == "maptip"_L1 )
            {
              featureInfoString.append( QStringLiteral( R"HTML(
      %1)HTML" )
                                          .arg( value ) );
              break;
            }
          }
          if ( !onlyMapTip )
          {
            featureInfoString.append( QStringLiteral( R"HTML(
      </table>)HTML" ) );
          }
        }
      }
    }
 
    //end the html body
    if ( !onlyMapTip )
    {
      featureInfoString.append( QStringLiteral( R"HTML(
    </body>)HTML" ) );
    }
 
    return featureInfoString.toUtf8();
  }
 
  QByteArray QgsRenderer::convertFeatureInfoToText( const QDomDocument &doc ) const
  {
    QString featureInfoString;
 
    //the Text head
    featureInfoString.append( "GetFeatureInfo results\n" );
    featureInfoString.append( "\n" );
 
    QDomNodeList layerList = doc.elementsByTagName( u"Layer"_s );
 
    //layer loop
    for ( int i = 0; i < layerList.size(); ++i )
    {
      QDomElement layerElem = layerList.at( i ).toElement();
 
      featureInfoString.append( "Layer '" + layerElem.attribute( u"name"_s ) + "'\n" );
 
      //feature loop (for vector layers)
      QDomNodeList featureNodeList = layerElem.elementsByTagName( u"Feature"_s );
      QDomElement currentFeatureElement;
 
      if ( !featureNodeList.isEmpty() ) //vector layer
      {
        for ( int j = 0; j < featureNodeList.size(); ++j )
        {
          QDomElement featureElement = featureNodeList.at( j ).toElement();
          featureInfoString.append( "Feature " + featureElement.attribute( u"id"_s ) + "\n" );
 
          //attribute loop
          QDomNodeList attributeNodeList = featureElement.elementsByTagName( u"Attribute"_s );
          for ( int k = 0; k < attributeNodeList.size(); ++k )
          {
            QDomElement attributeElement = attributeNodeList.at( k ).toElement();
            featureInfoString.append( attributeElement.attribute( u"name"_s ) + " = '" + attributeElement.attribute( u"value"_s ) + "'\n" );
          }
        }
      }
      else //raster layer
      {
        QDomNodeList attributeNodeList = layerElem.elementsByTagName( u"Attribute"_s );
        for ( int j = 0; j < attributeNodeList.size(); ++j )
        {
          QDomElement attributeElement = attributeNodeList.at( j ).toElement();
          QString value = attributeElement.attribute( u"value"_s );
          if ( value.isEmpty() )
          {
            value = u"no data"_s;
          }
          featureInfoString.append( attributeElement.attribute( u"name"_s ) + " = '" + value + "'\n" );
        }
      }
 
      featureInfoString.append( "\n" );
    }
 
    return featureInfoString.toUtf8();
  }
 
  QByteArray QgsRenderer::convertFeatureInfoToJson( const QList<QgsMapLayer *> &layers, const QDomDocument &doc, const QgsCoordinateReferenceSystem &destCRS ) const
  {
    json jsonCollection {
      { "type", "FeatureCollection" },
      { "features", json::array() },
    };
 
    const bool withGeometry = ( QgsServerProjectUtils::wmsFeatureInfoAddWktGeometry( *mProject ) && mWmsParameters.withGeometry() );
    const bool withDisplayName = mWmsParameters.withDisplayName();
 
    const QDomNodeList layerList = doc.elementsByTagName( u"Layer"_s );
    for ( int i = 0; i < layerList.size(); ++i )
    {
      const QDomElement layerElem = layerList.at( i ).toElement();
      const QString layerName = layerElem.attribute( u"name"_s );
 
      QgsMapLayer *layer = nullptr;
      for ( QgsMapLayer *l : layers )
      {
        if ( mContext.layerNickname( *l ).compare( layerName ) == 0 )
        {
          layer = l;
        }
      }
 
      if ( !layer )
        continue;
 
      // check if the layers have been requested by something other than their layer name (like the group)
      // and if so, keep the highest ancestor as requestedWmsName
      QStringList requestedWmsNames = mContext.acceptableLayersToRender().value( layer );
      requestedWmsNames.removeAll( layerName );
      QString requestedWmsName;
      if ( !requestedWmsNames.isEmpty() )
      {
        requestedWmsName = requestedWmsNames.first();
      }
 
      if ( layer->type() == Qgis::LayerType::Vector )
      {
        QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( layer );
 
        // search features to export
        QgsFeatureList features;
        QgsAttributeList attributes;
        const QDomNodeList featuresNode = layerElem.elementsByTagName( u"Feature"_s );
        if ( featuresNode.isEmpty() )
          continue;
 
        QMap<QgsFeatureId, QString> fidMap;
        QMap<QgsFeatureId, QString> fidDisplayNameMap;
 
        for ( int j = 0; j < featuresNode.size(); ++j )
        {
          const QDomElement featureNode = featuresNode.at( j ).toElement();
          const QString fid = featureNode.attribute( u"id"_s );
          QgsFeature feature;
          const QString expression { QgsServerFeatureId::getExpressionFromServerFid( fid, static_cast<QgsVectorDataProvider *>( layer->dataProvider() ) ) };
          if ( expression.isEmpty() )
          {
            feature = vl->getFeature( fid.toLongLong() );
          }
          else
          {
            QgsFeatureRequest request { QgsExpression( expression ) };
            request.setFlags( Qgis::FeatureRequestFlag::NoGeometry );
            vl->getFeatures( request ).nextFeature( feature );
          }
 
          fidMap.insert( feature.id(), fid );
 
          QString wkt;
          if ( withGeometry )
          {
            const QDomNodeList attrs = featureNode.elementsByTagName( "Attribute" );
            for ( int k = 0; k < attrs.count(); k++ )
            {
              const QDomElement elm = attrs.at( k ).toElement();
              if ( elm.attribute( u"name"_s ).compare( "geometry" ) == 0 )
              {
                wkt = elm.attribute( "value" );
                break;
              }
            }
 
            if ( !wkt.isEmpty() )
            {
              // CRS in WMS parameters may be different from the layer
              feature.setGeometry( QgsGeometry::fromWkt( wkt ) );
            }
          }
 
          // Note: this is the feature expression display name, not the field alias
          if ( withDisplayName )
          {
            QString displayName;
            const QDomNodeList attrs = featureNode.elementsByTagName( "Attribute" );
            for ( int k = 0; k < attrs.count(); k++ )
            {
              const QDomElement elm = attrs.at( k ).toElement();
              if ( elm.attribute( u"name"_s ).compare( "displayName" ) == 0 )
              {
                displayName = elm.attribute( "value" );
                break;
              }
            }
            fidDisplayNameMap.insert( feature.id(), displayName );
          }
 
          features << feature;
 
          // search attributes to export (one time only)
          if ( !attributes.isEmpty() )
            continue;
 
          const QDomNodeList attributesNode = featureNode.elementsByTagName( u"Attribute"_s );
          for ( int k = 0; k < attributesNode.size(); ++k )
          {
            const QDomElement attributeElement = attributesNode.at( k ).toElement();
            const QString fieldName = attributeElement.attribute( u"name"_s );
            attributes << feature.fieldNameIndex( fieldName );
          }
        }
 
        // export
        QgsJsonExporter exporter( vl );
        exporter.setAttributeDisplayName( true );
        exporter.setAttributes( attributes );
        exporter.setIncludeGeometry( withGeometry );
        // Always add CRS information so that the export knows if it needs to transform geometries
        // to CRS84 in case the requested profile needs it, the feature geometries are already
        // in the CRS of the request, so no transformation is needed
        exporter.setTransformGeometries( false );
        exporter.setDestinationCrs( destCRS );
        // This is the CRS of the features that the exporter receives
        exporter.setSourceCrs( destCRS );
 
        QgsJsonUtils::addCrsInfo( jsonCollection, destCRS );
 
        for ( const auto &feature : std::as_const( features ) )
        {
          const QString id = u"%1.%2"_s.arg( layerName ).arg( fidMap.value( feature.id() ) );
          QVariantMap extraProperties;
          if ( withDisplayName )
          {
            extraProperties.insert( u"display_name"_s, fidDisplayNameMap.value( feature.id() ) );
          }
          QVariantMap extraMembers;
          extraMembers[MEMBERNAME_FEATURETYPE] = layerName;
 
          // if existing, add the requestedWmsName to extra members
          if ( !requestedWmsName.isEmpty() )
          {
            extraMembers[MEMBERNAME_QGIS_REQUESTEDWMSNAME] = requestedWmsName;
          }
 
          jsonCollection["features"].push_back( exporter.exportFeatureToJsonObject( feature, extraProperties, id, extraMembers ) );
        }
      }
      else // raster layer
      {
        auto properties = json::object();
        const QDomNodeList attributesNode = layerElem.elementsByTagName( u"Attribute"_s );
        for ( int j = 0; j < attributesNode.size(); ++j )
        {
          const QDomElement attrElmt = attributesNode.at( j ).toElement();
          const QString name = attrElmt.attribute( u"name"_s );
 
          QString value = attrElmt.attribute( u"value"_s );
          if ( value.isEmpty() )
          {
            value = u"null"_s;
          }
 
          properties[name.toStdString()] = value.toStdString();
        }
 
        json jsonFeature = { { "type", "Feature" }, { MEMBERNAME_FEATURETYPE, layerName.toStdString() }, { "id", layerName.toStdString() }, { "properties", properties } };
 
        if ( !requestedWmsName.isEmpty() )
        {
          jsonFeature[MEMBERNAME_QGIS_REQUESTEDWMSNAME] = requestedWmsName.toStdString();
        }
        jsonCollection["features"].push_back( jsonFeature );
      }
    }
#ifdef QGISDEBUG
    // This is only useful to generate human readable reference files for tests
    return QByteArray::fromStdString( jsonCollection.dump( 2 ) );
#else
    return QByteArray::fromStdString( jsonCollection.dump() );
#endif
  }
 
  QDomElement QgsRenderer::createFeatureGML(
    const QgsFeature *feat, QgsVectorLayer *layer, QDomDocument &doc, QgsCoordinateReferenceSystem &crs, const QgsMapSettings &mapSettings, const QString &typeName, bool withGeom, int version, QStringList *attributes
  ) const
  {
    //qgs:%TYPENAME%
    QDomElement typeNameElement = doc.createElement( "qgs:" + typeName /*qgs:%TYPENAME%*/ );
    QString fid;
    if ( layer && layer->dataProvider() )
      fid = QgsServerFeatureId::getServerFid( *feat, layer->dataProvider()->pkAttributeIndexes() );
    else
      fid = FID_TO_STRING( feat->id() );
 
    typeNameElement.setAttribute( u"fid"_s, u"%1.%2"_s.arg( typeName, fid ) );
 
    QgsCoordinateTransform transform;
    if ( layer && layer->crs() != crs )
    {
      transform = mapSettings.layerTransform( layer );
    }
 
    QgsGeometry geom = feat->geometry();
 
    QgsExpressionContext expressionContext;
    expressionContext << QgsExpressionContextUtils::globalScope() << QgsExpressionContextUtils::projectScope( mProject );
    if ( layer )
      expressionContext << QgsExpressionContextUtils::layerScope( layer );
    expressionContext.setFeature( *feat );
 
    QgsEditFormConfig editConfig { layer ? layer->editFormConfig() : QgsEditFormConfig() };
    const bool honorFormConfig { layer && QgsServerProjectUtils::wmsFeatureInfoUseAttributeFormSettings( *mProject ) && editConfig.layout() == Qgis::AttributeFormLayout::DragAndDrop };
 
    // always add bounding box info if feature contains geometry and has been
    // explicitly configured in the project
    if ( QgsServerProjectUtils::wmsFeatureInfoAddWktGeometry( *mProject ) && !geom.isNull() && geom.type() != Qgis::GeometryType::Unknown && geom.type() != Qgis::GeometryType::Null )
    {
      QgsRectangle box = feat->geometry().boundingBox();
      if ( transform.isValid() )
      {
        try
        {
          box = transform.transformBoundingBox( box );
        }
        catch ( QgsCsException &e )
        {
          QgsMessageLog::logMessage( u"Transform error caught: %1"_s.arg( e.what() ) );
        }
      }
 
      QDomElement bbElem = doc.createElement( u"gml:boundedBy"_s );
      QDomElement boxElem;
      if ( version < 3 )
      {
        boxElem = QgsOgcUtils::rectangleToGMLBox( &box, doc, mContext.precision() );
      }
      else
      {
        boxElem = QgsOgcUtils::rectangleToGMLEnvelope( &box, doc, mContext.precision() );
      }
 
      if ( crs.isValid() )
      {
        boxElem.setAttribute( u"srsName"_s, crs.authid() );
      }
      bbElem.appendChild( boxElem );
      typeNameElement.appendChild( bbElem );
    }
 
    // find if an attribute is in any form tab
    std::function<bool( const QString &, const QgsAttributeEditorElement * )> findAttributeInTree;
    findAttributeInTree = [&findAttributeInTree, &layer]( const QString &attributeName, const QgsAttributeEditorElement *group ) -> bool {
      const QgsAttributeEditorContainer *container = dynamic_cast<const QgsAttributeEditorContainer *>( group );
      if ( container )
      {
        const QList<QgsAttributeEditorElement *> children = container->children();
        for ( const QgsAttributeEditorElement *child : children )
        {
          switch ( child->type() )
          {
            case Qgis::AttributeEditorType::Container:
            {
              if ( findAttributeInTree( attributeName, child ) )
              {
                return true;
              }
              break;
            }
            case Qgis::AttributeEditorType::Field:
            {
              if ( child->name() == attributeName )
              {
                return true;
              }
              break;
            }
            case Qgis::AttributeEditorType::Relation:
            {
              const QgsAttributeEditorRelation *relationEditor = static_cast<const QgsAttributeEditorRelation *>( child );
              if ( relationEditor )
              {
                const QgsRelation &relation { relationEditor->relation() };
                if ( relation.referencedLayer() == layer )
                {
                  const QgsAttributeList &referencedFields { relation.referencedFields() };
                  for ( const auto &idx : std::as_const( referencedFields ) )
                  {
                    const QgsField f { layer->fields().at( idx ) };
                    if ( f.name() == attributeName )
                    {
                      return true;
                    }
                  }
                }
                else if ( relation.referencingLayer() == layer )
                {
                  const QgsAttributeList &referencingFields { relation.referencingFields() };
                  for ( const auto &idx : std::as_const( referencingFields ) )
                  {
                    const QgsField f { layer->fields().at( idx ) };
                    if ( f.name() == attributeName )
                    {
                      return true;
                    }
                  }
                }
              }
              break;
            }
            default:
              break;
          }
        }
      }
      return false;
    };
 
    if ( withGeom && !geom.isNull() )
    {
      //add geometry column (as gml)
 
      if ( transform.isValid() )
      {
        geom.transform( transform );
      }
 
      QDomElement geomElem = doc.createElement( u"qgs:geometry"_s );
      QDomElement gmlElem;
      if ( version < 3 )
      {
        gmlElem = QgsOgcUtils::geometryToGML( geom, doc, mContext.precision() );
      }
      else
      {
        gmlElem = QgsOgcUtils::geometryToGML( geom, doc, u"GML3"_s, mContext.precision() );
      }
 
      if ( !gmlElem.isNull() )
      {
        if ( crs.isValid() )
        {
          gmlElem.setAttribute( u"srsName"_s, crs.authid() );
        }
        geomElem.appendChild( gmlElem );
        typeNameElement.appendChild( geomElem );
      }
    }
 
    //read all allowed attribute values from the feature
    QgsAttributes featureAttributes = feat->attributes();
    QgsFields fields = feat->fields();
    for ( int i = 0; i < fields.count(); ++i )
    {
      QString attributeName = fields.at( i ).name();
      //skip attribute if it is explicitly excluded from WMS publication
      if ( fields.at( i ).configurationFlags().testFlag( Qgis::FieldConfigurationFlag::HideFromWms ) )
      {
        continue;
      }
      //skip attribute if it is excluded by access control
      if ( attributes && !attributes->contains( attributeName ) )
      {
        continue;
      }
 
      if ( honorFormConfig )
      {
        const QgsAttributeEditorContainer *editorContainer = editConfig.invisibleRootContainer();
        if ( !editorContainer || !findAttributeInTree( attributeName, editorContainer ) )
        {
          continue;
        }
      }
 
      QDomElement fieldElem = doc.createElement( "qgs:" + attributeName.replace( ' ', '_' ) );
 
      // For GML: skip formatter and return null value if the attribute value is null
      if ( mWmsParameters.infoFormat() == QgsWmsParameters::Format::GML && QgsVariantUtils::isNull( featureAttributes.at( i ) ) )
      {
        fieldElem.setAttribute( "xsi:nil"_L1, "true"_L1 );
      }
      else
      {
        QString fieldTextString = featureAttributes.at( i ).toString();
        if ( layer )
        {
          fieldTextString = QgsExpression::replaceExpressionText( replaceValueMapAndRelation( layer, i, fieldTextString ), &expressionContext );
        }
        QDomText fieldText = doc.createTextNode( fieldTextString );
        fieldElem.appendChild( fieldText );
      }
      typeNameElement.appendChild( fieldElem );
    }
 
    //add maptip attribute based on html/expression (in case there is no maptip attribute)
    if ( layer )
    {
      QString mapTip = layer->mapTipTemplate();
 
      if ( !mapTip.isEmpty() && ( mWmsParameters.withMapTip() || mWmsParameters.htmlInfoOnlyMapTip() || QgsServerProjectUtils::wmsHTMLFeatureInfoUseOnlyMaptip( *mProject ) ) )
      {
        QString fieldTextString = QgsExpression::replaceExpressionText( mapTip, &expressionContext );
        QDomElement fieldElem = doc.createElement( u"qgs:maptip"_s );
        QDomText maptipText = doc.createTextNode( fieldTextString );
        fieldElem.appendChild( maptipText );
        typeNameElement.appendChild( fieldElem );
      }
    }
 
    return typeNameElement;
  }
 
  QString QgsRenderer::replaceValueMapAndRelation( QgsVectorLayer *vl, int idx, const QVariant &attributeVal )
  {
    const QgsEditorWidgetSetup setup = vl->editorWidgetSetup( idx );
    QgsFieldFormatter *fieldFormatter = QgsApplication::fieldFormatterRegistry()->fieldFormatter( setup.type() );
    QString value( fieldFormatter->representValue( vl, idx, setup.config(), QVariant(), attributeVal ) );
 
    if ( setup.config().value( u"AllowMulti"_s ).toBool() && value.startsWith( '{'_L1 ) && value.endsWith( '}'_L1 ) )
    {
      value = value.mid( 1, value.size() - 2 );
    }
    return value;
  }
 
  QgsRectangle QgsRenderer::featureInfoSearchRect( QgsVectorLayer *ml, const QgsMapSettings &mapSettings, const QgsRenderContext &rct, const QgsPointXY &infoPoint ) const
  {
    if ( !ml )
    {
      return QgsRectangle();
    }
 
    double mapUnitTolerance = 0.0;
    if ( ml->geometryType() == Qgis::GeometryType::Polygon )
    {
      if ( !mWmsParameters.polygonTolerance().isEmpty() && mWmsParameters.polygonToleranceAsInt() > 0 )
      {
        mapUnitTolerance = mWmsParameters.polygonToleranceAsInt() * rct.mapToPixel().mapUnitsPerPixel();
      }
      else
      {
        mapUnitTolerance = mapSettings.extent().width() / 400.0;
      }
    }
    else if ( ml->geometryType() == Qgis::GeometryType::Line )
    {
      if ( !mWmsParameters.lineTolerance().isEmpty() && mWmsParameters.lineToleranceAsInt() > 0 )
      {
        mapUnitTolerance = mWmsParameters.lineToleranceAsInt() * rct.mapToPixel().mapUnitsPerPixel();
      }
      else
      {
        mapUnitTolerance = mapSettings.extent().width() / 200.0;
      }
    }
    else //points
    {
      if ( !mWmsParameters.pointTolerance().isEmpty() && mWmsParameters.pointToleranceAsInt() > 0 )
      {
        mapUnitTolerance = mWmsParameters.pointToleranceAsInt() * rct.mapToPixel().mapUnitsPerPixel();
      }
      else
      {
        mapUnitTolerance = mapSettings.extent().width() / 100.0;
      }
    }
 
    // Make sure the map unit tolerance is at least 1 pixel
    mapUnitTolerance = std::max( mapUnitTolerance, 1.0 * rct.mapToPixel().mapUnitsPerPixel() );
 
    QgsRectangle mapRectangle( infoPoint.x() - mapUnitTolerance, infoPoint.y() - mapUnitTolerance, infoPoint.x() + mapUnitTolerance, infoPoint.y() + mapUnitTolerance );
    return ( mapSettings.mapToLayerCoordinates( ml, mapRectangle ) );
  }
 
  QList<QgsMapLayer *> QgsRenderer::highlightLayers( QList<QgsWmsParametersHighlightLayer> params )
  {
    QList<QgsMapLayer *> highlightLayers;
 
    // try to create highlight layer for each geometry
    QString crs = mWmsParameters.crs();
    for ( const QgsWmsParametersHighlightLayer &param : params )
    {
      // create sld document from symbology
      QDomDocument sldDoc;
      QString errorMsg;
      int errorLine;
      int errorColumn;
      if ( !sldDoc.setContent( param.mSld, true, &errorMsg, &errorLine, &errorColumn ) )
      {
        QgsMessageLog::logMessage( u"Error parsing SLD for layer %1 at line %2, column %3:\n%4"_s.arg( param.mName ).arg( errorLine ).arg( errorColumn ).arg( errorMsg ), u"Server"_s, Qgis::MessageLevel::Warning );
        continue;
      }
 
      // create renderer from sld document
      std::unique_ptr<QgsFeatureRenderer> renderer;
      QDomElement el = sldDoc.documentElement();
      renderer = QgsFeatureRenderer::loadSld( el, param.mGeom.type(), errorMsg );
      if ( !renderer )
      {
        QgsMessageLog::logMessage( errorMsg, "Server", Qgis::MessageLevel::Info );
        continue;
      }
 
      // build url for vector layer
      const QString typeName = QgsWkbTypes::displayString( param.mGeom.wkbType() );
      QString url = typeName + "?crs=" + crs;
      if ( !param.mLabel.isEmpty() )
      {
        url += "&field=label:string";
      }
 
      // create vector layer
      const QgsVectorLayer::LayerOptions options { QgsProject::instance()->transformContext() };
      auto layer = std::make_unique<QgsVectorLayer>( url, param.mName, "memory"_L1, options );
      if ( !layer->isValid() )
      {
        continue;
      }
 
      // create feature with label if necessary
      QgsFeature fet( layer->fields() );
      if ( !param.mLabel.isEmpty() )
      {
        fet.setAttribute( 0, param.mLabel );
 
        // init labeling engine
        QgsPalLayerSettings palSettings;
        palSettings.fieldName = "label"; // defined in url
        palSettings.priority = 10;       // always drawn
        palSettings.placementSettings().setOverlapHandling( Qgis::LabelOverlapHandling::AllowOverlapIfRequired );
        palSettings.placementSettings().setAllowDegradedPlacement( true );
        palSettings.dist = param.mLabelDistance;
 
        if ( !qgsDoubleNear( param.mLabelRotation, 0 ) )
        {
          QgsPalLayerSettings::Property pR = QgsPalLayerSettings::Property::LabelRotation;
          palSettings.dataDefinedProperties().setProperty( pR, param.mLabelRotation );
        }
 
        Qgis::LabelPlacement placement = Qgis::LabelPlacement::AroundPoint;
        switch ( param.mGeom.type() )
        {
          case Qgis::GeometryType::Point:
          {
            if ( param.mHali.isEmpty() || param.mVali.isEmpty() || QgsWkbTypes::flatType( param.mGeom.wkbType() ) != Qgis::WkbType::Point )
            {
              placement = Qgis::LabelPlacement::AroundPoint;
              palSettings.lineSettings().setPlacementFlags( Qgis::LabelLinePlacementFlags() );
            }
            else //set label directly on point if there is hali/vali
            {
              QgsPointXY pt = param.mGeom.asPoint();
              QgsPalLayerSettings::Property pX = QgsPalLayerSettings::Property::PositionX;
              QVariant x( pt.x() );
              palSettings.dataDefinedProperties().setProperty( pX, x );
              QgsPalLayerSettings::Property pY = QgsPalLayerSettings::Property::PositionY;
              QVariant y( pt.y() );
              palSettings.dataDefinedProperties().setProperty( pY, y );
              QgsPalLayerSettings::Property pHali = QgsPalLayerSettings::Property::Hali;
              palSettings.dataDefinedProperties().setProperty( pHali, param.mHali );
              QgsPalLayerSettings::Property pVali = QgsPalLayerSettings::Property::Vali;
              palSettings.dataDefinedProperties().setProperty( pVali, param.mVali );
            }
 
            break;
          }
          case Qgis::GeometryType::Polygon:
          {
            QgsGeometry point = param.mGeom.pointOnSurface();
            QgsPointXY pt = point.asPoint();
            placement = Qgis::LabelPlacement::AroundPoint;
 
            QgsPalLayerSettings::Property pX = QgsPalLayerSettings::Property::PositionX;
            QVariant x( pt.x() );
            palSettings.dataDefinedProperties().setProperty( pX, x );
 
            QgsPalLayerSettings::Property pY = QgsPalLayerSettings::Property::PositionY;
            QVariant y( pt.y() );
            palSettings.dataDefinedProperties().setProperty( pY, y );
 
            QgsPalLayerSettings::Property pHali = QgsPalLayerSettings::Property::Hali;
            QVariant hali( "Center" );
            palSettings.dataDefinedProperties().setProperty( pHali, hali );
 
            QgsPalLayerSettings::Property pVali = QgsPalLayerSettings::Property::Vali;
            QVariant vali( "Half" );
            palSettings.dataDefinedProperties().setProperty( pVali, vali );
            break;
          }
          default:
          {
            placement = Qgis::LabelPlacement::Line;
            palSettings.lineSettings().setPlacementFlags( Qgis::LabelLinePlacementFlag::AboveLine | Qgis::LabelLinePlacementFlag::MapOrientation );
            break;
          }
        }
        palSettings.placement = placement;
        QgsTextFormat textFormat;
        QgsTextBufferSettings bufferSettings;
 
        if ( param.mColor.isValid() )
        {
          textFormat.setColor( param.mColor );
        }
 
        if ( param.mSize > 0 )
        {
          textFormat.setSize( param.mSize );
        }
 
        // no weight property in PAL settings or QgsTextFormat
        /* if ( param.fontWeight > 0 )
        {
        } */
 
        if ( !param.mFont.isEmpty() )
        {
          textFormat.setFont( param.mFont );
        }
 
        if ( param.mBufferColor.isValid() )
        {
          bufferSettings.setColor( param.mBufferColor );
        }
 
        if ( param.mBufferSize > 0 )
        {
          bufferSettings.setEnabled( true );
          bufferSettings.setSize( static_cast<double>( param.mBufferSize ) );
        }
 
        if ( param.mFrameSize > 0 )
        {
          QgsTextBackgroundSettings background;
          background.setEnabled( true );
          background.setSize( QSize( param.mFrameSize, param.mFrameSize ) );
          background.setType( QgsTextBackgroundSettings::ShapeRectangle );
          background.setStrokeColor( param.mFrameOutlineColor );
          background.setStrokeWidth( param.mFrameOutlineWidth );
          background.setFillColor( param.mFrameBackgroundColor );
          textFormat.setBackground( background );
        }
 
        textFormat.setBuffer( bufferSettings );
        palSettings.setFormat( textFormat );
 
        QgsVectorLayerSimpleLabeling *simpleLabeling = new QgsVectorLayerSimpleLabeling( palSettings );
        layer->setLabeling( simpleLabeling );
        layer->setLabelsEnabled( true );
      }
      fet.setGeometry( param.mGeom );
 
      // add feature to layer and set the SLD renderer
      layer->dataProvider()->addFeatures( QgsFeatureList() << fet );
      layer->setRenderer( renderer.release() );
 
      // keep the vector as an highlight layer
      if ( layer->isValid() )
      {
        highlightLayers.append( layer.release() );
      }
    }
 
    mTemporaryLayers.append( highlightLayers );
    return highlightLayers;
  }
 
  void QgsRenderer::removeTemporaryLayers()
  {
    qDeleteAll( mTemporaryLayers );
    mTemporaryLayers.clear();
  }
 
  QPainter *QgsRenderer::layersRendering( const QgsMapSettings &mapSettings, QImage *image ) const
  {
    QPainter *painter = nullptr;
 
    QgsFeatureFilterProviderGroup filters;
    filters.addProvider( &mFeatureFilter );
#ifdef HAVE_SERVER_PYTHON_PLUGINS
    mContext.accessControl()->resolveFilterFeatures( mapSettings.layers() );
    filters.addProvider( mContext.accessControl() );
#endif
    QgsMapRendererJobProxy renderJob( mContext.settings().parallelRendering(), mContext.settings().maxThreads(), &filters );
 
    renderJob.render( mapSettings, image, mContext.socketFeedback() );
    painter = renderJob.takePainter();
 
    logRenderingErrors( renderJob.errors() );
 
    if ( !renderJob.errors().isEmpty() && !mContext.settings().ignoreRenderingErrors() )
    {
      const QgsMapRendererJob::Error e = renderJob.errors().at( 0 );
 
      QString layerWMSName;
      QgsMapLayer *errorLayer = mProject->mapLayer( e.layerID );
      if ( errorLayer )
      {
        layerWMSName = mContext.layerNickname( *errorLayer );
      }
 
      QString errorMessage = u"Rendering error : '%1'"_s.arg( e.message );
      if ( !layerWMSName.isEmpty() )
      {
        errorMessage = u"Rendering error : '%1' in layer '%2'"_s.arg( e.message, layerWMSName );
      }
      throw QgsException( errorMessage );
    }
 
    return painter;
  }
 
  void QgsRenderer::setLayerOpacity( QgsMapLayer *layer, int opacity ) const
  {
    if ( opacity >= 0 && opacity <= 255 )
    {
      switch ( layer->type() )
      {
        case Qgis::LayerType::Vector:
        {
          QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( layer );
          vl->setOpacity( opacity / 255. );
          // Labeling
          if ( vl->labelsEnabled() && vl->labeling() )
          {
            QgsAbstractVectorLayerLabeling *labeling { vl->labeling() };
            labeling->multiplyOpacity( opacity / 255. );
          }
          break;
        }
 
        case Qgis::LayerType::Raster:
        {
          QgsRasterLayer *rl = qobject_cast<QgsRasterLayer *>( layer );
          QgsRasterRenderer *rasterRenderer = rl->renderer();
          rasterRenderer->setOpacity( opacity / 255. );
          break;
        }
 
        case Qgis::LayerType::VectorTile:
        {
          QgsVectorTileLayer *vl = qobject_cast<QgsVectorTileLayer *>( layer );
          vl->setOpacity( opacity / 255. );
          break;
        }
 
        case Qgis::LayerType::Mesh:
        case Qgis::LayerType::Plugin:
        case Qgis::LayerType::Annotation:
        case Qgis::LayerType::PointCloud:
        case Qgis::LayerType::Group:
        case Qgis::LayerType::TiledScene:
          break;
      }
    }
  }
 
  void QgsRenderer::setLayerFilter( QgsMapLayer *layer, const QList<QgsWmsParametersFilter> &filters )
  {
    if ( layer->type() == Qgis::LayerType::Vector )
    {
      QgsVectorLayer *filteredLayer = qobject_cast<QgsVectorLayer *>( layer );
      QStringList expList;
      for ( const QgsWmsParametersFilter &filter : filters )
      {
        if ( filter.mType == QgsWmsParametersFilter::OGC_FE )
        {
          // OGC filter
          QDomDocument filterXml;
 
          QXmlStreamReader xmlReader( filter.mFilter );
          xmlReader.addExtraNamespaceDeclaration( QXmlStreamNamespaceDeclaration( u"fes"_s, u"http://www.opengis.net/fes/2.0"_s ) );
          xmlReader.addExtraNamespaceDeclaration( QXmlStreamNamespaceDeclaration( u"ogc"_s, u"http://www.opengis.net/ogc"_s ) );
          if ( QDomDocument::ParseResult result = filterXml.setContent( &xmlReader, QDomDocument::ParseOption::UseNamespaceProcessing ); !result )
          {
            throw QgsBadRequestException(
              QgsServiceException::QGIS_InvalidParameterValue,
              u"Filter string rejected. Error %1:%2 : %3. The XML string was: %4"_s.arg( QString::number( result.errorLine ), QString::number( result.errorColumn ), result.errorMessage, filter.mFilter )
            );
          }
 
          QDomElement filterElem = filterXml.firstChildElement();
          std::unique_ptr<QgsExpression> filterExp( QgsOgcUtils::expressionFromOgcFilter( filterElem, filter.mVersion, filteredLayer ) );
 
          if ( filterExp )
          {
            expList << filterExp->dump();
          }
        }
        else if ( filter.mType == QgsWmsParametersFilter::SQL )
        {
          // QGIS (SQL) filter
          if ( !testFilterStringSafety( filter.mFilter ) )
          {
            throw QgsSecurityException(
              QStringLiteral(
                "The filter string %1"
                " has been rejected because of security reasons."
                " Note: Text strings have to be enclosed in single or double quotes."
                " A space between each word / special character is mandatory."
                " Allowed Keywords and special characters are"
                " IS,NOT,NULL,AND,OR,IN,=,<,>=,>,>=,!=,',',(,),DMETAPHONE,SOUNDEX%2."
                " Not allowed are semicolons in the filter expression."
              )
                .arg( filter.mFilter, mContext.settings().allowedExtraSqlTokens().isEmpty() ? QString() : mContext.settings().allowedExtraSqlTokens().join( ',' ).prepend( ',' ) )
            );
          }
 
          QString newSubsetString = filter.mFilter;
          if ( !filteredLayer->subsetString().isEmpty() )
          {
            newSubsetString.prepend( ") AND (" );
            newSubsetString.append( ")" );
            newSubsetString.prepend( filteredLayer->subsetString() );
            newSubsetString.prepend( "(" );
          }
          if ( !filteredLayer->setSubsetString( newSubsetString ) )
          {
            QgsMessageLog::logMessage( u"Error setting subset string from filter for layer %1, filter: %2"_s.arg( layer->name(), newSubsetString ), u"Server"_s, Qgis::MessageLevel::Warning );
            throw QgsBadRequestException( QgsServiceException::QGIS_InvalidParameterValue, u"Filter not valid for layer %1: check the filter syntax and the field names."_s.arg( layer->name() ) );
          }
        }
      }
 
      expList.append( dimensionFilter( filteredLayer ) );
 
      // Join and apply expressions provided by OGC filter and Dimensions
      QString exp;
      if ( expList.size() == 1 )
      {
        exp = expList[0];
      }
      else if ( expList.size() > 1 )
      {
        exp = u"( %1 )"_s.arg( expList.join( " ) AND ( "_L1 ) );
      }
      if ( !exp.isEmpty() )
      {
        auto expression = std::make_unique<QgsExpression>( exp );
        if ( expression )
        {
          Q_NOWARN_DEPRECATED_PUSH
          mFeatureFilter.setFilter( filteredLayer, *expression );
          Q_NOWARN_DEPRECATED_POP
        }
      }
    }
  }
 
  QStringList QgsRenderer::dimensionFilter( QgsVectorLayer *layer ) const
  {
    QStringList expList;
    // WMS Dimension filters
    QgsMapLayerServerProperties *serverProperties = static_cast<QgsMapLayerServerProperties *>( layer->serverProperties() );
    const QList<QgsMapLayerServerProperties::WmsDimensionInfo> wmsDims = serverProperties->wmsDimensions();
    if ( wmsDims.isEmpty() )
    {
      return expList;
    }
 
    QMap<QString, QString> dimParamValues = mContext.parameters().dimensionValues();
    for ( const QgsMapLayerServerProperties::WmsDimensionInfo &dim : wmsDims )
    {
      // Skip temporal properties for this layer, give precedence to the dimensions implementation
      if ( mIsTemporal && dim.name.toUpper() == "TIME"_L1 && layer->temporalProperties()->isActive() )
      {
        layer->temporalProperties()->setIsActive( false );
      }
      // Check field index
      int fieldIndex = layer->fields().indexOf( dim.fieldName );
      if ( fieldIndex == -1 )
      {
        continue;
      }
      // Check end field index
      int endFieldIndex = -1;
      if ( !dim.endFieldName.isEmpty() )
      {
        endFieldIndex = layer->fields().indexOf( dim.endFieldName );
        if ( endFieldIndex == -1 )
        {
          continue;
        }
      }
      // Apply dimension filtering
      if ( !dimParamValues.contains( dim.name.toUpper() ) )
      {
        // Default value based on type configured by user
        QVariant defValue;
        if ( dim.defaultDisplayType == Qgis::WmsDimensionDefaultDisplay::AllValues )
        {
          continue; // no filter by default for this dimension
        }
        else if ( dim.defaultDisplayType == Qgis::WmsDimensionDefaultDisplay::ReferenceValue )
        {
          defValue = dim.referenceValue();
        }
        else
        {
          // get unique values
          QSet<QVariant> uniqueValues = layer->uniqueValues( fieldIndex );
          if ( endFieldIndex != -1 )
          {
            uniqueValues.unite( layer->uniqueValues( endFieldIndex ) );
          }
          // sort unique values
          QList<QVariant> values = qgis::setToList( uniqueValues );
          std::sort( values.begin(), values.end() );
          if ( dim.defaultDisplayType == Qgis::WmsDimensionDefaultDisplay::MinValue )
          {
            defValue = values.first();
          }
          else if ( dim.defaultDisplayType == Qgis::WmsDimensionDefaultDisplay::MaxValue )
          {
            defValue = values.last();
          }
        }
        // build expression
        if ( endFieldIndex == -1 )
        {
          expList << QgsExpression::createFieldEqualityExpression( dim.fieldName, defValue );
        }
        else
        {
          QStringList expElems;
          expElems
            << QgsExpression::quotedColumnRef( dim.fieldName )
            << u"<="_s
            << QgsExpression::quotedValue( defValue )
            << u"AND"_s
            << QgsExpression::quotedColumnRef( dim.endFieldName )
            << u">="_s
            << QgsExpression::quotedValue( defValue );
          expList << expElems.join( ' ' );
        }
      }
      else
      {
        // Get field to convert value provided in parameters
        QgsField dimField = layer->fields().at( fieldIndex );
        // Value provided in parameters
        QString dimParamValue = dimParamValues[dim.name.toUpper()];
        // The expression list for this dimension
        QStringList dimExplist;
        // Multiple values are separated by ,
        QStringList dimValues = dimParamValue.split( ',' );
        for ( int i = 0; i < dimValues.size(); ++i )
        {
          QString dimValue = dimValues[i];
          // Trim value if necessary
          if ( dimValue.size() > 1 )
          {
            dimValue = dimValue.trimmed();
          }
          // Range value is separated by / for example 0/1
          if ( dimValue.contains( '/' ) )
          {
            QStringList rangeValues = dimValue.split( '/' );
            // Check range value size
            if ( rangeValues.size() != 2 )
            {
              continue; // throw an error
            }
            // Get range values
            QVariant rangeMin = QVariant( rangeValues[0] );
            QVariant rangeMax = QVariant( rangeValues[1] );
            // Convert and check range values
            if ( !dimField.convertCompatible( rangeMin ) )
            {
              continue; // throw an error
            }
            if ( !dimField.convertCompatible( rangeMax ) )
            {
              continue; // throw an error
            }
            // Build expression for this range
            QStringList expElems;
            if ( endFieldIndex == -1 )
            {
              // The field values are between min and max range
              expElems
                << QgsExpression::quotedColumnRef( dim.fieldName )
                << u">="_s
                << QgsExpression::quotedValue( rangeMin )
                << u"AND"_s
                << QgsExpression::quotedColumnRef( dim.fieldName )
                << u"<="_s
                << QgsExpression::quotedValue( rangeMax );
            }
            else
            {
              // The start field or the end field are lesser than min range
              // or the start field or the end field are greater than min range
              expElems
                << u"("_s
                << QgsExpression::quotedColumnRef( dim.fieldName )
                << u">="_s
                << QgsExpression::quotedValue( rangeMin )
                << u"OR"_s
                << QgsExpression::quotedColumnRef( dim.endFieldName )
                << u">="_s
                << QgsExpression::quotedValue( rangeMin )
                << u") AND ("_s
                << QgsExpression::quotedColumnRef( dim.fieldName )
                << u"<="_s
                << QgsExpression::quotedValue( rangeMax )
                << u"OR"_s
                << QgsExpression::quotedColumnRef( dim.endFieldName )
                << u"<="_s
                << QgsExpression::quotedValue( rangeMax )
                << u")"_s;
            }
            dimExplist << expElems.join( ' ' );
          }
          else
          {
            QVariant dimVariant = QVariant( dimValue );
            if ( !dimField.convertCompatible( dimVariant ) )
            {
              continue; // throw an error
            }
            // Build expression for this value
            if ( endFieldIndex == -1 )
            {
              // Field is equal to
              dimExplist << QgsExpression::createFieldEqualityExpression( dim.fieldName, dimVariant );
            }
            else
            {
              // The start field is lesser or equal to
              // and the end field is greater or equal to
              QStringList expElems;
              expElems
                << QgsExpression::quotedColumnRef( dim.fieldName )
                << u"<="_s
                << QgsExpression::quotedValue( dimVariant )
                << u"AND"_s
                << QgsExpression::quotedColumnRef( dim.endFieldName )
                << u">="_s
                << QgsExpression::quotedValue( dimVariant );
              dimExplist << expElems.join( ' ' );
            }
          }
        }
        // Build the expression for this dimension
        if ( dimExplist.size() == 1 )
        {
          expList << dimExplist;
        }
        else if ( dimExplist.size() > 1 )
        {
          expList << u"( %1 )"_s.arg( dimExplist.join( " ) OR ( "_L1 ) );
        }
      }
    }
    return expList;
  }
 
  void QgsRenderer::setLayerSelection( QgsMapLayer *layer, const QStringList &fids ) const
  {
    if ( !fids.empty() && layer->type() == Qgis::LayerType::Vector )
    {
      QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( layer );
 
      QgsFeatureRequest request;
      QgsServerFeatureId::updateFeatureRequestFromServerFids( request, fids, vl->dataProvider() );
      const QgsFeatureIds selectedIds = request.filterFids();
 
      if ( selectedIds.empty() )
      {
        vl->selectByExpression( request.filterExpression()->expression() );
      }
      else
      {
        vl->selectByIds( selectedIds );
      }
    }
  }
 
  void QgsRenderer::setLayerAccessControlFilter( QgsMapLayer *layer ) const
  {
#ifdef HAVE_SERVER_PYTHON_PLUGINS
    QgsOWSServerFilterRestorer::applyAccessControlLayerFilters( mContext.accessControl(), layer );
#else
    Q_UNUSED( layer )
#endif
  }
 
  void QgsRenderer::updateExtent( const QgsMapLayer *layer, QgsMapSettings &mapSettings ) const
  {
    QgsRectangle layerExtent = mapSettings.layerToMapCoordinates( layer, layer->extent() );
    QgsRectangle mapExtent = mapSettings.extent();
    if ( !layerExtent.isEmpty() )
    {
      mapExtent.combineExtentWith( layerExtent );
      mapSettings.setExtent( mapExtent );
    }
  }
 
  void QgsRenderer::annotationsRendering( QPainter *painter, const QgsMapSettings &mapSettings ) const
  {
    const QgsAnnotationManager *annotationManager = mProject->annotationManager();
    const QList<QgsAnnotation *> annotations = annotationManager->annotations();
 
    QgsRenderContext renderContext = QgsRenderContext::fromQPainter( painter );
    renderContext.setFlag( Qgis::RenderContextFlag::RenderBlocking );
    renderContext.setFeedback( mContext.socketFeedback() );
 
    for ( QgsAnnotation *annotation : annotations )
    {
      if ( mContext.socketFeedback() && mContext.socketFeedback()->isCanceled() )
        break;
      if ( !annotation || !annotation->isVisible() )
        continue;
 
      //consider item position
      double offsetX = 0;
      double offsetY = 0;
      if ( annotation->hasFixedMapPosition() )
      {
        QgsPointXY mapPos = annotation->mapPosition();
        if ( mapSettings.destinationCrs() != annotation->mapPositionCrs() )
        {
          QgsCoordinateTransform coordTransform( annotation->mapPositionCrs(), mapSettings.destinationCrs(), mapSettings.transformContext() );
          try
          {
            mapPos = coordTransform.transform( mapPos );
          }
          catch ( const QgsCsException &e )
          {
            QgsMessageLog::logMessage( u"Error transforming coordinates of annotation item: %1"_s.arg( e.what() ) );
          }
        }
        const QgsPointXY devicePos = mapSettings.mapToPixel().transform( mapPos );
        offsetX = devicePos.x();
        offsetY = devicePos.y();
      }
      else
      {
        const QPointF relativePos = annotation->relativePosition();
        offsetX = mapSettings.outputSize().width() * relativePos.x();
        offsetY = mapSettings.outputSize().height() * relativePos.y();
      }
 
      painter->save();
      painter->translate( offsetX, offsetY );
      annotation->render( renderContext );
      painter->restore();
    }
  }
 
  QImage *QgsRenderer::scaleImage( const QImage *image ) const
  {
    // Test if width / height ratio of image is the same as the ratio of
    // WIDTH / HEIGHT parameters. If not, the image has to be scaled (required
    // by WMS spec)
    QImage *scaledImage = nullptr;
    const int width = mWmsParameters.widthAsInt();
    const int height = mWmsParameters.heightAsInt();
    if ( width != image->width() || height != image->height() )
    {
      scaledImage = new QImage( image->scaled( width, height, Qt::IgnoreAspectRatio, Qt::SmoothTransformation ) );
    }
 
    return scaledImage;
  }
 
  void QgsRenderer::logRenderingErrors( const QgsMapRendererJob::Errors &errors ) const
  {
    QgsMapRendererJob::Errors::const_iterator it = errors.constBegin();
    for ( ; it != errors.constEnd(); ++it )
    {
      QString msg = QString( "Rendering error: %1" ).arg( it->message );
      if ( !it->layerID.isEmpty() )
      {
        msg += QString( " in layer %1" ).arg( it->layerID );
      }
      QgsMessageLog::logMessage( msg, "Server", Qgis::MessageLevel::Critical );
    }
  }
 
  void QgsRenderer::handlePrintErrors( const QgsLayout *layout ) const
  {
    if ( !layout )
    {
      return;
    }
 
    QList<QgsLayoutItemMap *> mapList;
    layout->layoutItems( mapList );
 
    //log rendering errors even if they are ignored
    QList<QgsLayoutItemMap *>::const_iterator mapIt = mapList.constBegin();
    for ( ; mapIt != mapList.constEnd(); ++mapIt )
    {
      logRenderingErrors( ( *mapIt )->renderingErrors() );
    }
 
    if ( mContext.settings().ignoreRenderingErrors() )
    {
      return;
    }
 
    mapIt = mapList.constBegin();
    for ( ; mapIt != mapList.constEnd(); ++mapIt )
    {
      if ( !( *mapIt )->renderingErrors().isEmpty() )
      {
        const QgsMapRendererJob::Error e = ( *mapIt )->renderingErrors().at( 0 );
        throw QgsException( u"Rendering error : '%1' in layer %2"_s.arg( e.message, e.layerID ) );
      }
    }
  }
 
  void QgsRenderer::configureLayers( QList<QgsMapLayer *> &layers, QgsMapSettings *settings )
  {
    const bool useSld = !mContext.parameters().sldBody().isEmpty();
 
    for ( auto layer : layers )
    {
      const QgsWmsParametersLayer param = mContext.parameters( *layer );
 
      if ( !mContext.layersToRender().contains( layer ) )
      {
        continue;
      }
 
      if ( mContext.isExternalLayer( param.mNickname ) )
      {
        if ( mContext.testFlag( QgsWmsRenderContext::UseOpacity ) )
        {
          setLayerOpacity( layer, param.mOpacity );
        }
        continue;
      }
 
      if ( useSld )
      {
        setLayerSld( layer, mContext.sld( *layer ) );
      }
      else
      {
        setLayerStyle( layer, mContext.style( *layer ) );
      }
 
      if ( mContext.testFlag( QgsWmsRenderContext::UseOpacity ) )
      {
        setLayerOpacity( layer, param.mOpacity );
      }
 
      if ( mContext.testFlag( QgsWmsRenderContext::UseFilter ) )
      {
        setLayerFilter( layer, param.mFilter );
      }
 
      if ( mContext.testFlag( QgsWmsRenderContext::SetAccessControl ) )
      {
        setLayerAccessControlFilter( layer );
      }
 
      if ( mContext.testFlag( QgsWmsRenderContext::UseSelection ) )
      {
        setLayerSelection( layer, param.mSelection );
      }
 
      if ( settings && mContext.updateExtent() )
      {
        updateExtent( layer, *settings );
      }
    }
 
    if ( mContext.testFlag( QgsWmsRenderContext::AddHighlightLayers ) )
    {
      layers = highlightLayers( mWmsParameters.highlightLayersParameters() ) << layers;
    }
  }
 
  void QgsRenderer::setLayerStyle( QgsMapLayer *layer, const QString &style ) const
  {
    if ( style.isEmpty() )
    {
      return;
    }
 
    bool rc = layer->styleManager()->setCurrentStyle( style );
    if ( !rc )
    {
      throw QgsBadRequestException( QgsServiceException::OGC_StyleNotDefined, u"Style '%1' does not exist for layer '%2'"_s.arg( style, layer->name() ) );
    }
  }
 
  void QgsRenderer::setLayerSld( QgsMapLayer *layer, const QDomElement &sld ) const
  {
    QString err;
    // Defined sld style name
    const QStringList styles = layer->styleManager()->styles();
    QString sldStyleName = "__sld_style";
    while ( styles.contains( sldStyleName ) )
    {
      sldStyleName.append( '@' );
    }
    layer->styleManager()->addStyleFromLayer( sldStyleName );
    layer->styleManager()->setCurrentStyle( sldStyleName );
    layer->readSld( sld, err );
    layer->setCustomProperty( "sldStyleName", sldStyleName );
  }
 
  QgsLegendSettings QgsRenderer::legendSettings()
  {
    // getting scale from bbox or default size
    QgsLegendSettings settings = mWmsParameters.legendSettings();
 
    if ( !mWmsParameters.bbox().isEmpty() )
    {
      QgsMapSettings mapSettings;
      mapSettings.setFlag( Qgis::MapSettingsFlag::RenderBlocking );
      std::unique_ptr<QImage> tmp( createImage( mContext.mapSize( false ) ) );
      configureMapSettings( tmp.get(), mapSettings );
      // QGIS 5.0 - require correct use of QgsRenderContext instead of these
      Q_NOWARN_DEPRECATED_PUSH
      settings.setMapScale( mapSettings.scale() );
      settings.setMapUnitsPerPixel( mapSettings.mapUnitsPerPixel() );
      Q_NOWARN_DEPRECATED_POP
    }
    else
    {
      // QGIS 5.0 - require correct use of QgsRenderContext instead of these
      Q_NOWARN_DEPRECATED_PUSH
      const double defaultMapUnitsPerPixel = QgsServerProjectUtils::wmsDefaultMapUnitsPerMm( *mContext.project() ) / mContext.dotsPerMm();
      settings.setMapUnitsPerPixel( defaultMapUnitsPerPixel );
      Q_NOWARN_DEPRECATED_POP
    }
 
    return settings;
  }
} // namespace QgsWms