api/3.30/qgsplot_8cpp_source.html

/***************************************************************************

                         qgsplot.cpp

                         ---------------

    begin                : March 2022

    copyright            : (C) 2022 by Nyall Dawson

    email                : nyall dot dawson at gmail 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 "qgsplot.h"

#include "qgslinesymbol.h"

#include "qgsfillsymbol.h"

#include "qgsfillsymbollayer.h"

#include "qgslinesymbollayer.h"

#include "qgstextrenderer.h"

#include "qgsbasicnumericformat.h"

#include "qgssymbollayerutils.h"

#include "qgsapplication.h"

#include "qgsnumericformatregistry.h"

#include "qgsexpressioncontextutils.h"

#include <functional>


QgsPlot::~QgsPlot() = default;


bool QgsPlot::writeXml( QDomElement &, QDomDocument &, const QgsReadWriteContext & ) const

{

  return true;

}


bool QgsPlot::readXml( const QDomElement &, const QgsReadWriteContext & )

{

  return true;

}


// QgsPlotAxis


QgsPlotAxis::QgsPlotAxis()

{

  // setup default style

  mNumericFormat.reset( QgsPlotDefaultSettings::axisLabelNumericFormat() );

  mGridMinorSymbol.reset( QgsPlotDefaultSettings::axisGridMinorSymbol() );

  mGridMajorSymbol.reset( QgsPlotDefaultSettings::axisGridMajorSymbol() );

}


QgsPlotAxis::~QgsPlotAxis() = default;


bool QgsPlotAxis::writeXml( QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context ) const

{

  element.setAttribute( QStringLiteral( "gridIntervalMinor" ), qgsDoubleToString( mGridIntervalMinor ) );

  element.setAttribute( QStringLiteral( "gridIntervalMajor" ), qgsDoubleToString( mGridIntervalMajor ) );

  element.setAttribute( QStringLiteral( "labelInterval" ), qgsDoubleToString( mLabelInterval ) );


  QDomElement numericFormatElement = document.createElement( QStringLiteral( "numericFormat" ) );

  mNumericFormat->writeXml( numericFormatElement, document, context );

  element.appendChild( numericFormatElement );


  QDomElement gridMajorElement = document.createElement( QStringLiteral( "gridMajorSymbol" ) );

  gridMajorElement.appendChild( QgsSymbolLayerUtils::saveSymbol( QString(), mGridMajorSymbol.get(), document, context ) );

  element.appendChild( gridMajorElement );

  QDomElement gridMinorElement = document.createElement( QStringLiteral( "gridMinorSymbol" ) );

  gridMinorElement.appendChild( QgsSymbolLayerUtils::saveSymbol( QString(), mGridMinorSymbol.get(), document, context ) );

  element.appendChild( gridMinorElement );


  QDomElement textFormatElement = document.createElement( QStringLiteral( "textFormat" ) );

  textFormatElement.appendChild( mLabelTextFormat.writeXml( document, context ) );

  element.appendChild( textFormatElement );


  return true;

}


bool QgsPlotAxis::readXml( const QDomElement &element, const QgsReadWriteContext &context )

{

  mGridIntervalMinor = element.attribute( QStringLiteral( "gridIntervalMinor" ) ).toDouble();

  mGridIntervalMajor = element.attribute( QStringLiteral( "gridIntervalMajor" ) ).toDouble();

  mLabelInterval = element.attribute( QStringLiteral( "labelInterval" ) ).toDouble();


  const QDomElement numericFormatElement = element.firstChildElement( QStringLiteral( "numericFormat" ) );

  mNumericFormat.reset( QgsApplication::numericFormatRegistry()->createFromXml( numericFormatElement, context ) );


  const QDomElement gridMajorElement = element.firstChildElement( QStringLiteral( "gridMajorSymbol" ) ).firstChildElement( QStringLiteral( "symbol" ) );

  mGridMajorSymbol.reset( QgsSymbolLayerUtils::loadSymbol< QgsLineSymbol >( gridMajorElement, context ) );

  const QDomElement gridMinorElement = element.firstChildElement( QStringLiteral( "gridMinorSymbol" ) ).firstChildElement( QStringLiteral( "symbol" ) );

  mGridMinorSymbol.reset( QgsSymbolLayerUtils::loadSymbol< QgsLineSymbol >( gridMinorElement, context ) );


  const QDomElement textFormatElement = element.firstChildElement( QStringLiteral( "textFormat" ) );

  mLabelTextFormat.readXml( textFormatElement, context );


  return true;

}


QgsNumericFormat *QgsPlotAxis::numericFormat() const

{

  return mNumericFormat.get();

}


void QgsPlotAxis::setNumericFormat( QgsNumericFormat *format )

{

  mNumericFormat.reset( format );

}


QgsLineSymbol *QgsPlotAxis::gridMajorSymbol()

{

  return mGridMajorSymbol.get();

}


void QgsPlotAxis::setGridMajorSymbol( QgsLineSymbol *symbol )

{

  mGridMajorSymbol.reset( symbol );

}


QgsLineSymbol *QgsPlotAxis::gridMinorSymbol()

{

  return mGridMinorSymbol.get();

}


void QgsPlotAxis::setGridMinorSymbol( QgsLineSymbol *symbol )

{

  mGridMinorSymbol.reset( symbol );

}


QgsTextFormat QgsPlotAxis::textFormat() const

{

  return mLabelTextFormat;

}


void QgsPlotAxis::setTextFormat( const QgsTextFormat &format )

{

  mLabelTextFormat = format;

}


//

// Qgs2DPlot

//


Qgs2DPlot::Qgs2DPlot()

  : mMargins( 2, 2, 2, 2 )

{

  // setup default style

  mChartBackgroundSymbol.reset( QgsPlotDefaultSettings::chartBackgroundSymbol() );

  mChartBorderSymbol.reset( QgsPlotDefaultSettings::chartBorderSymbol() );

}


bool Qgs2DPlot::writeXml( QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context ) const

{

  QgsPlot::writeXml( element, document, context );


  element.setAttribute( QStringLiteral( "minX" ), qgsDoubleToString( mMinX ) );

  element.setAttribute( QStringLiteral( "maxX" ), qgsDoubleToString( mMaxX ) );

  element.setAttribute( QStringLiteral( "minY" ), qgsDoubleToString( mMinY ) );

  element.setAttribute( QStringLiteral( "maxY" ), qgsDoubleToString( mMaxY ) );


  QDomElement xAxisElement = document.createElement( QStringLiteral( "xAxis" ) );

  mXAxis.writeXml( xAxisElement, document, context );

  element.appendChild( xAxisElement );

  QDomElement yAxisElement = document.createElement( QStringLiteral( "yAxis" ) );

  mYAxis.writeXml( yAxisElement, document, context );

  element.appendChild( yAxisElement );


  QDomElement backgroundElement = document.createElement( QStringLiteral( "backgroundSymbol" ) );

  backgroundElement.appendChild( QgsSymbolLayerUtils::saveSymbol( QString(), mChartBackgroundSymbol.get(), document, context ) );

  element.appendChild( backgroundElement );

  QDomElement borderElement = document.createElement( QStringLiteral( "borderSymbol" ) );

  borderElement.appendChild( QgsSymbolLayerUtils::saveSymbol( QString(), mChartBorderSymbol.get(), document, context ) );

  element.appendChild( borderElement );


  element.setAttribute( QStringLiteral( "margins" ), mMargins.toString() );


  return true;

}


bool Qgs2DPlot::readXml( const QDomElement &element, const QgsReadWriteContext &context )

{

  QgsPlot::readXml( element, context );


  mMinX = element.attribute( QStringLiteral( "minX" ) ).toDouble();

  mMaxX = element.attribute( QStringLiteral( "maxX" ) ).toDouble();

  mMinY = element.attribute( QStringLiteral( "minY" ) ).toDouble();

  mMaxY = element.attribute( QStringLiteral( "maxY" ) ).toDouble();


  const QDomElement xAxisElement = element.firstChildElement( QStringLiteral( "xAxis" ) );

  mXAxis.readXml( xAxisElement, context );

  const QDomElement yAxisElement = element.firstChildElement( QStringLiteral( "yAxis" ) );

  mYAxis.readXml( yAxisElement, context );


  const QDomElement backgroundElement = element.firstChildElement( QStringLiteral( "backgroundSymbol" ) ).firstChildElement( QStringLiteral( "symbol" ) );

  mChartBackgroundSymbol.reset( QgsSymbolLayerUtils::loadSymbol< QgsFillSymbol >( backgroundElement, context ) );

  const QDomElement borderElement = element.firstChildElement( QStringLiteral( "borderSymbol" ) ).firstChildElement( QStringLiteral( "symbol" ) );

  mChartBorderSymbol.reset( QgsSymbolLayerUtils::loadSymbol< QgsFillSymbol >( borderElement, context ) );


  mMargins = QgsMargins::fromString( element.attribute( QStringLiteral( "margins" ) ) );


  return true;

}


void Qgs2DPlot::render( QgsRenderContext &context )

{

  QgsExpressionContextScope *plotScope = new QgsExpressionContextScope( QStringLiteral( "plot" ) );

  const QgsExpressionContextScopePopper scopePopper( context.expressionContext(), plotScope );


  mChartBackgroundSymbol->startRender( context );

  mChartBorderSymbol->startRender( context );

  mXAxis.gridMinorSymbol()->startRender( context );

  mYAxis.gridMinorSymbol()->startRender( context );

  mXAxis.gridMajorSymbol()->startRender( context );

  mYAxis.gridMajorSymbol()->startRender( context );


  const double firstMinorXGrid = std::ceil( mMinX / mXAxis.gridIntervalMinor() ) * mXAxis.gridIntervalMinor();

  const double firstMajorXGrid = std::ceil( mMinX / mXAxis.gridIntervalMajor() ) * mXAxis.gridIntervalMajor();

  const double firstMinorYGrid = std::ceil( mMinY / mYAxis.gridIntervalMinor() ) * mYAxis.gridIntervalMinor();

  const double firstMajorYGrid = std::ceil( mMinY / mYAxis.gridIntervalMajor() ) * mYAxis.gridIntervalMajor();

  const double firstXLabel = std::ceil( mMinX / mXAxis.labelInterval() ) * mXAxis.labelInterval();

  const double firstYLabel = std::ceil( mMinY / mYAxis.labelInterval() ) * mYAxis.labelInterval();


  const QRectF plotArea = interiorPlotArea( context );


  const double xTolerance = mXAxis.gridIntervalMinor() / 100000;

  const double yTolerance = mYAxis.gridIntervalMinor() / 100000;


  QgsNumericFormatContext numericContext;


  // calculate text metrics

  double maxYAxisLabelWidth = 0;

  plotScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "plot_axis" ), QStringLiteral( "y" ), true ) );

  for ( double currentY = firstYLabel; currentY <= mMaxY && !qgsDoubleNear( currentY, mMaxY, yTolerance ); currentY += mYAxis.labelInterval() )

  {

    plotScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "plot_axis_value" ), currentY, true ) );

    const QString text = mYAxis.numericFormat()->formatDouble( currentY, numericContext );

    maxYAxisLabelWidth = std::max( maxYAxisLabelWidth, QgsTextRenderer::textWidth( context, mYAxis.textFormat(), { text } ) );

  }


  const double chartAreaLeft = plotArea.left();

  const double chartAreaRight = plotArea.right();

  const double chartAreaTop = plotArea.top();

  const double chartAreaBottom = plotArea.bottom();


  // chart background

  mChartBackgroundSymbol->renderPolygon( QPolygonF(

  {

    QPointF( chartAreaLeft, chartAreaTop ),

    QPointF( chartAreaRight, chartAreaTop ),

    QPointF( chartAreaRight, chartAreaBottom ),

    QPointF( chartAreaLeft, chartAreaBottom ),

    QPointF( chartAreaLeft, chartAreaTop )

  } ), nullptr, nullptr, context );


  const double xScale = ( chartAreaRight - chartAreaLeft ) / ( mMaxX - mMinX );

  const double yScale = ( chartAreaBottom - chartAreaTop ) / ( mMaxY - mMinY );


  constexpr int MAX_OBJECTS = 1000;


  // grid lines


  // x

  plotScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "plot_axis" ), QStringLiteral( "x" ), true ) );

  double nextMajorXGrid = firstMajorXGrid;

  int objectNumber = 0;

  for ( double currentX = firstMinorXGrid; objectNumber < MAX_OBJECTS && ( currentX <= mMaxX && !qgsDoubleNear( currentX, mMaxX, xTolerance ) ); currentX += mXAxis.gridIntervalMinor(), ++objectNumber )

  {

    bool isMinor = true;

    if ( qgsDoubleNear( currentX, nextMajorXGrid, xTolerance ) )

    {

      isMinor = false;

      nextMajorXGrid += mXAxis.gridIntervalMajor();

    }


    plotScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "plot_axis_value" ), currentX, true ) );


    QgsLineSymbol *currentGridSymbol = isMinor ? mXAxis.gridMinorSymbol() : mXAxis.gridMajorSymbol();

    currentGridSymbol->renderPolyline( QPolygonF(

                                         QVector<QPointF>

    {

      QPointF( ( currentX - mMinX ) * xScale + chartAreaLeft, chartAreaBottom ),

      QPointF( ( currentX - mMinX ) * xScale + chartAreaLeft, chartAreaTop )

    } ), nullptr, context );

  }


  // y

  plotScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "plot_axis" ), QStringLiteral( "y" ), true ) );

  double nextMajorYGrid = firstMajorYGrid;

  objectNumber = 0;

  for ( double currentY = firstMinorYGrid; objectNumber < MAX_OBJECTS && ( currentY <= mMaxY && !qgsDoubleNear( currentY, mMaxY, yTolerance ) ); currentY += mYAxis.gridIntervalMinor(), ++objectNumber )

  {

    bool isMinor = true;

    if ( qgsDoubleNear( currentY, nextMajorYGrid, yTolerance ) )

    {

      isMinor = false;

      nextMajorYGrid += mYAxis.gridIntervalMajor();

    }


    plotScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "plot_axis_value" ), currentY, true ) );


    QgsLineSymbol *currentGridSymbol = isMinor ? mYAxis.gridMinorSymbol() : mYAxis.gridMajorSymbol();

    currentGridSymbol->renderPolyline( QPolygonF(

                                         QVector<QPointF>

    {

      QPointF( chartAreaLeft, chartAreaBottom - ( currentY - mMinY ) * yScale ),

      QPointF( chartAreaRight, chartAreaBottom - ( currentY - mMinY ) * yScale )

    } ), nullptr, context );

  }


  // axis labels


  // x

  plotScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "plot_axis" ), QStringLiteral( "x" ), true ) );

  objectNumber = 0;

  for ( double currentX = firstXLabel; objectNumber < MAX_OBJECTS && ( currentX <= mMaxX || qgsDoubleNear( currentX, mMaxX, xTolerance ) ); currentX += mXAxis.labelInterval(), ++objectNumber )

  {

    plotScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "plot_axis_value" ), currentX, true ) );

    const QString text = mXAxis.numericFormat()->formatDouble( currentX, numericContext );

    QgsTextRenderer::drawText( QPointF( ( currentX - mMinX ) * xScale + chartAreaLeft, mSize.height() - context.convertToPainterUnits( mMargins.bottom(), Qgis::RenderUnit::Millimeters ) ),

                               0, Qgis::TextHorizontalAlignment::Center, { text }, context, mXAxis.textFormat() );

  }


  // y

  plotScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "plot_axis" ), QStringLiteral( "y" ), true ) );

  objectNumber = 0;

  for ( double currentY = firstYLabel; objectNumber < MAX_OBJECTS && ( currentY <= mMaxY || qgsDoubleNear( currentY, mMaxY, yTolerance ) ); currentY += mYAxis.labelInterval(), ++objectNumber )

  {

    plotScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "plot_axis_value" ), currentY, true ) );

    const QString text = mYAxis.numericFormat()->formatDouble( currentY, numericContext );

    const double height = QgsTextRenderer::textHeight( context, mYAxis.textFormat(), { text } );

    QgsTextRenderer::drawText( QPointF(

                                 maxYAxisLabelWidth + context.convertToPainterUnits( mMargins.left(), Qgis::RenderUnit::Millimeters ),

                                 chartAreaBottom - ( currentY - mMinY ) * yScale + height / 2 ),

                               0, Qgis::TextHorizontalAlignment::Right, { text }, context, mYAxis.textFormat(), false );

  }


  // give subclasses a chance to draw their content

  renderContent( context, plotArea );


  // border

  mChartBorderSymbol->renderPolygon( QPolygonF(

  {

    QPointF( chartAreaLeft, chartAreaTop ),

    QPointF( chartAreaRight, chartAreaTop ),

    QPointF( chartAreaRight, chartAreaBottom ),

    QPointF( chartAreaLeft, chartAreaBottom ),

    QPointF( chartAreaLeft, chartAreaTop )

  } ), nullptr, nullptr, context );


  mChartBackgroundSymbol->stopRender( context );

  mChartBorderSymbol->stopRender( context );

  mXAxis.gridMinorSymbol()->stopRender( context );

  mYAxis.gridMinorSymbol()->stopRender( context );

  mXAxis.gridMajorSymbol()->stopRender( context );

  mYAxis.gridMajorSymbol()->stopRender( context );

}


void Qgs2DPlot::renderContent( QgsRenderContext &, const QRectF & )

{


}


Qgs2DPlot::~Qgs2DPlot() = default;


QSizeF Qgs2DPlot::size() const

{

  return mSize;

}


void Qgs2DPlot::setSize( QSizeF size )

{

  mSize = size;

}


QRectF Qgs2DPlot::interiorPlotArea( QgsRenderContext &context ) const

{

  QgsExpressionContextScope *plotScope = new QgsExpressionContextScope( QStringLiteral( "plot" ) );

  const QgsExpressionContextScopePopper scopePopper( context.expressionContext(), plotScope );


  const double firstMinorYGrid = std::ceil( mMinY / mYAxis.gridIntervalMinor() ) * mYAxis.gridIntervalMinor();

  const double firstXLabel = std::ceil( mMinX / mXAxis.labelInterval() ) * mXAxis.labelInterval();


  QgsNumericFormatContext numericContext;


  const double xTolerance = mXAxis.gridIntervalMinor() / 100000;

  const double yTolerance = mYAxis.gridIntervalMinor() / 100000;


  constexpr int MAX_LABELS = 1000;


  // calculate text metrics

  int labelNumber = 0;

  double maxXAxisLabelHeight = 0;

  plotScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "plot_axis" ), QStringLiteral( "x" ), true ) );

  for ( double currentX = firstXLabel; labelNumber < MAX_LABELS && ( currentX <= mMaxX || qgsDoubleNear( currentX, mMaxX, xTolerance ) ); currentX += mXAxis.labelInterval(), labelNumber++ )

  {

    plotScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "plot_axis_value" ), currentX, true ) );

    const QString text = mXAxis.numericFormat()->formatDouble( currentX, numericContext );

    maxXAxisLabelHeight = std::max( maxXAxisLabelHeight, QgsTextRenderer::textHeight( context, mXAxis.textFormat(), { text } ) );

  }


  double maxYAxisLabelWidth = 0;

  labelNumber = 0;

  plotScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "plot_axis" ), QStringLiteral( "y" ), true ) );

  for ( double currentY = firstMinorYGrid; labelNumber < MAX_LABELS && ( currentY <= mMaxY || qgsDoubleNear( currentY, mMaxY, yTolerance ) ); currentY += mYAxis.gridIntervalMinor(), labelNumber ++ )

  {

    plotScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "plot_axis_value" ), currentY, true ) );

    const QString text = mYAxis.numericFormat()->formatDouble( currentY, numericContext );

    maxYAxisLabelWidth = std::max( maxYAxisLabelWidth, QgsTextRenderer::textWidth( context, mYAxis.textFormat(), { text } ) );

  }


  const double leftTextSize = maxYAxisLabelWidth + context.convertToPainterUnits( 1, Qgis::RenderUnit::Millimeters );

  const double rightTextSize = 0;

  const double bottomTextSize = maxXAxisLabelHeight + context.convertToPainterUnits( 0.5, Qgis::RenderUnit::Millimeters );

  const double topTextSize = 0;


  const double leftMargin = context.convertToPainterUnits( mMargins.left(), Qgis::RenderUnit::Millimeters ) + leftTextSize;

  const double rightMargin = context.convertToPainterUnits( mMargins.right(), Qgis::RenderUnit::Millimeters ) + rightTextSize;

  const double topMargin = context.convertToPainterUnits( mMargins.top(), Qgis::RenderUnit::Millimeters ) + topTextSize;

  const double bottomMargin = context.convertToPainterUnits( mMargins.bottom(), Qgis::RenderUnit::Millimeters ) + bottomTextSize;


  return QRectF( leftMargin, topMargin, mSize.width() - rightMargin - leftMargin, mSize.height() - bottomMargin - topMargin );

}


void Qgs2DPlot::calculateOptimisedIntervals( QgsRenderContext &context )

{

  // aim for about 40% coverage of label text to available space

  constexpr double IDEAL_WIDTH = 0.4;

  constexpr double TOLERANCE = 0.04;

  constexpr int MAX_LABELS = 1000;


  const double leftMargin = context.convertToPainterUnits( mMargins.left(), Qgis::RenderUnit::Millimeters );

  const double rightMargin = context.convertToPainterUnits( mMargins.right(), Qgis::RenderUnit::Millimeters );

  const double topMargin = context.convertToPainterUnits( mMargins.top(), Qgis::RenderUnit::Millimeters );

  const double bottomMargin = context.convertToPainterUnits( mMargins.bottom(), Qgis::RenderUnit::Millimeters );


  const double availableWidth = mSize.width() - leftMargin - rightMargin;

  const double availableHeight = mSize.height() - topMargin - bottomMargin;


  QgsNumericFormatContext numericContext;


  auto refineIntervalForAxis = [&]( double axisMinimum, double axisMaximum,

                                    const std::function< double( double ) > &sizeForLabel,

                                    double availableSize, double idealSizePercent, double sizeTolerancePercent,

                                    double & labelInterval, double & majorInterval, double & minorInterval )

  {

    auto roundBase10 = []( double value )->double

    {

      return std::pow( 10, std::floor( std::log10( value ) ) );

    };


    // if the current interval is good enough, don't change it!

    double totalSize = 0;

    int initialLabelCount = 0;

    {

      const double firstLabelPos = std::ceil( axisMinimum / labelInterval ) * labelInterval;


      for ( double currentPos = firstLabelPos; initialLabelCount <= MAX_LABELS && currentPos <= axisMaximum; currentPos += labelInterval, ++initialLabelCount )

      {

        totalSize += sizeForLabel( currentPos );

      }

    }


    // we consider the current interval as "good enough" if it results in somewhere between 20-60% label text coverage over the size

    if ( initialLabelCount >= MAX_LABELS || ( totalSize  / availableSize < ( idealSizePercent - sizeTolerancePercent ) ) || ( totalSize  / availableSize > ( idealSizePercent + sizeTolerancePercent ) ) )

    {

      // we start with trying to fit 30 labels in and then raise the interval till we're happy

      int numberLabelsInitial = std::floor( availableSize / 30 );


      double labelIntervalTest = ( axisMaximum - axisMinimum ) / numberLabelsInitial;

      double baseValue = roundBase10( labelIntervalTest );

      double candidate = baseValue;

      int currentMultiplier = 1;


      int numberLabels = 0;

      while ( true )

      {

        const double firstLabelPosition = std::ceil( axisMinimum / candidate ) * candidate;

        double totalSize = 0;

        numberLabels = 0;

        for ( double currentPos = firstLabelPosition; currentPos <= axisMaximum; currentPos += candidate )

        {

          totalSize += sizeForLabel( currentPos );

          numberLabels += 1;


          if ( numberLabels > MAX_LABELS ) // avoid hangs if candidate size is very small

            break;

        }


        if ( numberLabels <= MAX_LABELS && totalSize <= availableSize * idealSizePercent )

          break;


        if ( currentMultiplier == 1 )

          currentMultiplier = 2;

        else if ( currentMultiplier == 2 )

          currentMultiplier = 5;

        else if ( currentMultiplier == 5 )

        {

          baseValue *= 10;

          currentMultiplier = 1;

        }


        candidate = baseValue * currentMultiplier;

      }

      labelInterval = candidate;

      if ( numberLabels < 10 )

      {

        minorInterval = labelInterval / 2;

        majorInterval = minorInterval * 4;

      }

      else

      {

        minorInterval = labelInterval;

        majorInterval = minorInterval * 5;

      }

    }

  };


  {

    double labelIntervalX = mXAxis.labelInterval();

    double majorIntervalX = mXAxis.gridIntervalMajor();

    double minorIntervalX = mXAxis.gridIntervalMinor();

    refineIntervalForAxis( mMinX, mMaxX, [ = ]( double position ) -> double

    {

      const QString text = mXAxis.numericFormat()->formatDouble( position, numericContext );

      return QgsTextRenderer::textWidth( context,  mXAxis.textFormat(), { text } );


    }, availableWidth,

    IDEAL_WIDTH, TOLERANCE, labelIntervalX, majorIntervalX, minorIntervalX );

    mXAxis.setLabelInterval( labelIntervalX );

    mXAxis.setGridIntervalMajor( majorIntervalX );

    mXAxis.setGridIntervalMinor( minorIntervalX );

  }


  {

    double labelIntervalY = mYAxis.labelInterval();

    double majorIntervalY = mYAxis.gridIntervalMajor();

    double minorIntervalY = mYAxis.gridIntervalMinor();

    refineIntervalForAxis( mMinY, mMaxY, [ = ]( double position ) -> double

    {

      const QString text = mYAxis.numericFormat()->formatDouble( position, numericContext );

      return QgsTextRenderer::textHeight( context, mYAxis.textFormat(), { text } );

    }, availableHeight,

    IDEAL_WIDTH, TOLERANCE, labelIntervalY, majorIntervalY, minorIntervalY );

    mYAxis.setLabelInterval( labelIntervalY );

    mYAxis.setGridIntervalMajor( majorIntervalY );

    mYAxis.setGridIntervalMinor( minorIntervalY );

  }

}


QgsFillSymbol *Qgs2DPlot::chartBackgroundSymbol()

{

  return mChartBackgroundSymbol.get();

}


void Qgs2DPlot::setChartBackgroundSymbol( QgsFillSymbol *symbol )

{

  mChartBackgroundSymbol.reset( symbol );

}


QgsFillSymbol *Qgs2DPlot::chartBorderSymbol()

{

  return mChartBorderSymbol.get();

}


void Qgs2DPlot::setChartBorderSymbol( QgsFillSymbol *symbol )

{

  mChartBorderSymbol.reset( symbol );

}


const QgsMargins &Qgs2DPlot::margins() const

{

  return mMargins;

}


void Qgs2DPlot::setMargins( const QgsMargins &margins )

{

  mMargins = margins;

}


//

// QgsPlotDefaultSettings

//


QgsNumericFormat *QgsPlotDefaultSettings::axisLabelNumericFormat()

{

  return new QgsBasicNumericFormat();

}


QgsLineSymbol *QgsPlotDefaultSettings::axisGridMajorSymbol()

{

  std::unique_ptr< QgsSimpleLineSymbolLayer > gridMajor = std::make_unique< QgsSimpleLineSymbolLayer >( QColor( 20, 20, 20, 150 ), 0.1 );

  gridMajor->setPenCapStyle( Qt::FlatCap );

  return new QgsLineSymbol( QgsSymbolLayerList( { gridMajor.release() } ) );

}


QgsLineSymbol *QgsPlotDefaultSettings::axisGridMinorSymbol()

{

  std::unique_ptr< QgsSimpleLineSymbolLayer > gridMinor = std::make_unique< QgsSimpleLineSymbolLayer >( QColor( 20, 20, 20, 50 ), 0.1 );

  gridMinor->setPenCapStyle( Qt::FlatCap );

  return new QgsLineSymbol( QgsSymbolLayerList( { gridMinor.release() } ) );

}


QgsFillSymbol *QgsPlotDefaultSettings::chartBackgroundSymbol()

{

  std::unique_ptr< QgsSimpleFillSymbolLayer > chartFill = std::make_unique< QgsSimpleFillSymbolLayer >( QColor( 255, 255, 255 ) );

  return new QgsFillSymbol( QgsSymbolLayerList( { chartFill.release() } ) );

}


QgsFillSymbol *QgsPlotDefaultSettings::chartBorderSymbol()

{

  std::unique_ptr< QgsSimpleLineSymbolLayer > chartBorder = std::make_unique< QgsSimpleLineSymbolLayer >( QColor( 20, 20, 20 ), 0.1 );

  return new QgsFillSymbol( QgsSymbolLayerList( { chartBorder.release() } ) );

}

Qgs2DPlot::calculateOptimisedIntervals
void calculateOptimisedIntervals(QgsRenderContext &context)
Automatically sets the grid and label intervals to optimal values for display in the given render con...
Definition: qgsplot.cpp:424

Qgs2DPlot::writeXml
bool writeXml(QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context) const override
Writes the plot's properties into an XML element.
Definition: qgsplot.cpp:152

Qgs2DPlot::setSize
void setSize(QSizeF size)
Sets the overall size of the plot (including titles and over components which sit outside the plot ar...
Definition: qgsplot.cpp:370

Qgs2DPlot::margins
const QgsMargins & margins() const
Returns the margins of the plot area (in millimeters)
Definition: qgsplot.cpp:570

Qgs2DPlot::~Qgs2DPlot
~Qgs2DPlot() override

Qgs2DPlot::render
void render(QgsRenderContext &context)
Renders the plot.
Definition: qgsplot.cpp:204

Qgs2DPlot::setChartBorderSymbol
void setChartBorderSymbol(QgsFillSymbol *symbol)
Sets the symbol used to render the border of the chart.
Definition: qgsplot.cpp:565

Qgs2DPlot::Qgs2DPlot
Qgs2DPlot()
Constructor for Qgs2DPlot.
Definition: qgsplot.cpp:144

Qgs2DPlot::readXml
bool readXml(const QDomElement &element, const QgsReadWriteContext &context) override
Reads the plot's properties from an XML element.
Definition: qgsplot.cpp:180

Qgs2DPlot::chartBorderSymbol
QgsFillSymbol * chartBorderSymbol()
Returns the symbol used to render the border of the chart.
Definition: qgsplot.cpp:560

Qgs2DPlot::size
QSizeF size() const
Returns the overall size of the plot (in millimeters) (including titles and other components which si...
Definition: qgsplot.cpp:365

Qgs2DPlot::setMargins
void setMargins(const QgsMargins &margins)
Sets the margins of the plot area (in millimeters)
Definition: qgsplot.cpp:575

Qgs2DPlot::interiorPlotArea
QRectF interiorPlotArea(QgsRenderContext &context) const
Returns the area of the plot which corresponds to the actual plot content (excluding all titles and o...
Definition: qgsplot.cpp:375

Qgs2DPlot::setChartBackgroundSymbol
void setChartBackgroundSymbol(QgsFillSymbol *symbol)
Sets the fill symbol used to render the background of the chart.
Definition: qgsplot.cpp:555

Qgs2DPlot::renderContent
virtual void renderContent(QgsRenderContext &context, const QRectF &plotArea)
Renders the plot content.
Definition: qgsplot.cpp:358

Qgs2DPlot::chartBackgroundSymbol
QgsFillSymbol * chartBackgroundSymbol()
Returns the fill symbol used to render the background of the chart.
Definition: qgsplot.cpp:550

QgsApplication::numericFormatRegistry
static QgsNumericFormatRegistry * numericFormatRegistry()
Gets the registry of available numeric formats.
Definition: qgsapplication.cpp:2558

QgsBasicNumericFormat
A numeric formatter which returns a simple text representation of a value.
Definition: qgsbasicnumericformat.h:32

QgsExpressionContextScopePopper
RAII class to pop scope from an expression context on destruction.
Definition: qgsexpressioncontextutils.h:389

QgsExpressionContextScope
Single scope for storing variables and functions for use within a QgsExpressionContext.
Definition: qgsexpressioncontext.h:118

QgsExpressionContextScope::addVariable
void addVariable(const QgsExpressionContextScope::StaticVariable &variable)
Adds a variable into the context scope.
Definition: qgsexpressioncontext.cpp:102

QgsFillSymbol
A fill symbol type, for rendering Polygon and MultiPolygon geometries.
Definition: qgsfillsymbol.h:30

QgsLineSymbol
A line symbol type, for rendering LineString and MultiLineString geometries.
Definition: qgslinesymbol.h:30

QgsLineSymbol::renderPolyline
void renderPolyline(const QPolygonF &points, const QgsFeature *f, QgsRenderContext &context, int layer=-1, bool selected=false)
Renders the symbol along the line joining points, using the given render context.
Definition: qgslinesymbol.cpp:232

QgsMargins
The QgsMargins class defines the four margins of a rectangle.
Definition: qgsmargins.h:38

QgsMargins::top
double top() const
Returns the top margin.
Definition: qgsmargins.h:78

QgsMargins::fromString
static QgsMargins fromString(const QString &string)
Returns a QgsMargins object decoded from a string, or a null QgsMargins if the string could not be in...
Definition: qgsmargins.cpp:27

QgsMargins::right
double right() const
Returns the right margin.
Definition: qgsmargins.h:84

QgsMargins::bottom
double bottom() const
Returns the bottom margin.
Definition: qgsmargins.h:90

QgsMargins::toString
QString toString() const
Returns the margins encoded to a string.
Definition: qgsmargins.cpp:18

QgsMargins::left
double left() const
Returns the left margin.
Definition: qgsmargins.h:72

QgsNumericFormatContext
A context for numeric formats.
Definition: qgsnumericformat.h:35

QgsNumericFormat
A numeric formatter allows for formatting a numeric value for display, using a variety of different f...
Definition: qgsnumericformat.h:260

QgsNumericFormat::formatDouble
virtual QString formatDouble(double value, const QgsNumericFormatContext &context) const =0
Returns a formatted string representation of a numeric double value.

QgsPlotAxis::gridMinorSymbol
QgsLineSymbol * gridMinorSymbol()
Returns the line symbol used to render the minor lines in the axis grid.
Definition: qgsplot.cpp:119

QgsPlotAxis::readXml
bool readXml(const QDomElement &element, const QgsReadWriteContext &context)
Reads the axis' properties from an XML element.
Definition: qgsplot.cpp:79

QgsPlotAxis::setGridMajorSymbol
void setGridMajorSymbol(QgsLineSymbol *symbol)
Sets the symbol used to render the major lines in the axis grid.
Definition: qgsplot.cpp:114

QgsPlotAxis::~QgsPlotAxis
~QgsPlotAxis()

QgsPlotAxis::gridIntervalMinor
double gridIntervalMinor() const
Returns the interval of minor grid lines for the axis.
Definition: qgsplot.h:104

QgsPlotAxis::gridIntervalMajor
double gridIntervalMajor() const
Returns the interval of major grid lines for the axis.
Definition: qgsplot.h:118

QgsPlotAxis::setNumericFormat
void setNumericFormat(QgsNumericFormat *format)
Sets the numeric format used for the axis labels.
Definition: qgsplot.cpp:104

QgsPlotAxis::textFormat
QgsTextFormat textFormat() const
Returns the text format used for the axis labels.
Definition: qgsplot.cpp:129

QgsPlotAxis::setGridIntervalMajor
void setGridIntervalMajor(double interval)
Sets the interval of major grid lines for the axis.
Definition: qgsplot.h:125

QgsPlotAxis::setGridIntervalMinor
void setGridIntervalMinor(double interval)
Sets the interval of minor grid lines for the axis.
Definition: qgsplot.h:111

QgsPlotAxis::setLabelInterval
void setLabelInterval(double interval)
Sets the interval of labels for the axis.
Definition: qgsplot.h:139

QgsPlotAxis::labelInterval
double labelInterval() const
Returns the interval of labels for the axis.
Definition: qgsplot.h:132

QgsPlotAxis::gridMajorSymbol
QgsLineSymbol * gridMajorSymbol()
Returns the line symbol used to render the major lines in the axis grid.
Definition: qgsplot.cpp:109

QgsPlotAxis::setTextFormat
void setTextFormat(const QgsTextFormat &format)
Sets the text format used for the axis labels.
Definition: qgsplot.cpp:134

QgsPlotAxis::QgsPlotAxis
QgsPlotAxis()
Definition: qgsplot.cpp:45

QgsPlotAxis::writeXml
bool writeXml(QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context) const
Writes the axis' properties into an XML element.
Definition: qgsplot.cpp:55

QgsPlotAxis::setGridMinorSymbol
void setGridMinorSymbol(QgsLineSymbol *symbol)
Sets the symbol used to render the minor lines in the axis grid.
Definition: qgsplot.cpp:124

QgsPlotAxis::numericFormat
QgsNumericFormat * numericFormat() const
Returns the numeric format used for the axis labels.
Definition: qgsplot.cpp:99

QgsPlotDefaultSettings::chartBorderSymbol
static QgsFillSymbol * chartBorderSymbol()
Returns the default fill symbol to use for the chart area border.
Definition: qgsplot.cpp:609

QgsPlotDefaultSettings::axisLabelNumericFormat
static QgsNumericFormat * axisLabelNumericFormat()
Returns the default numeric format to use for plot axis labels.
Definition: qgsplot.cpp:584

QgsPlotDefaultSettings::axisGridMinorSymbol
static QgsLineSymbol * axisGridMinorSymbol()
Returns the default line symbol to use for axis minor grid lines.
Definition: qgsplot.cpp:596

QgsPlotDefaultSettings::chartBackgroundSymbol
static QgsFillSymbol * chartBackgroundSymbol()
Returns the default fill symbol to use for the chart area background fill.
Definition: qgsplot.cpp:603

QgsPlotDefaultSettings::axisGridMajorSymbol
static QgsLineSymbol * axisGridMajorSymbol()
Returns the default line symbol to use for axis major grid lines.
Definition: qgsplot.cpp:589

QgsPlot::~QgsPlot
virtual ~QgsPlot()

QgsPlot::readXml
virtual bool readXml(const QDomElement &element, const QgsReadWriteContext &context)
Reads the plot's properties from an XML element.
Definition: qgsplot.cpp:37

QgsPlot::writeXml
virtual bool writeXml(QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context) const
Writes the plot's properties into an XML element.
Definition: qgsplot.cpp:32

QgsReadWriteContext
The class is used as a container of context for various read/write operations on other objects.
Definition: qgsreadwritecontext.h:35

QgsRenderContext
Contains information about the context of a rendering operation.
Definition: qgsrendercontext.h:61

QgsRenderContext::convertToPainterUnits
double convertToPainterUnits(double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property=Qgis::RenderSubcomponentProperty::Generic) const
Converts a size from the specified units to painter units (pixels).
Definition: qgsrendercontext.cpp:364

QgsRenderContext::expressionContext
QgsExpressionContext & expressionContext()
Gets the expression context.
Definition: qgsrendercontext.h:652

QgsSymbolLayerUtils::saveSymbol
static QDomElement saveSymbol(const QString &symbolName, const QgsSymbol *symbol, QDomDocument &doc, const QgsReadWriteContext &context)
Writes a symbol definition to XML.
Definition: qgssymbollayerutils.cpp:1403

QgsSymbol::stopRender
void stopRender(QgsRenderContext &context)
Ends the rendering process.
Definition: qgssymbol.cpp:873

QgsSymbol::startRender
void startRender(QgsRenderContext &context, const QgsFields &fields=QgsFields())
Begins the rendering process for the symbol.
Definition: qgssymbol.cpp:825

QgsTextFormat
Container for all settings relating to text rendering.
Definition: qgstextformat.h:41

QgsTextFormat::readXml
void readXml(const QDomElement &elem, const QgsReadWriteContext &context)
Read settings from a DOM element.
Definition: qgstextformat.cpp:501

QgsTextFormat::writeXml
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context) const
Write settings into a DOM element.
Definition: qgstextformat.cpp:696

QgsTextRenderer::textWidth
static double textWidth(const QgsRenderContext &context, const QgsTextFormat &format, const QStringList &textLines, QFontMetricsF *fontMetrics=nullptr)
Returns the width of a text based on a given format.
Definition: qgstextrenderer.cpp:589

QgsTextRenderer::drawText
static void drawText(const QRectF &rect, double rotation, Qgis::TextHorizontalAlignment alignment, const QStringList &textLines, QgsRenderContext &context, const QgsTextFormat &format, bool drawAsOutlines=true, Qgis::TextVerticalAlignment vAlignment=Qgis::TextVerticalAlignment::Top, Qgis::TextRendererFlags flags=Qgis::TextRendererFlags(), Qgis::TextLayoutMode mode=Qgis::TextLayoutMode::Rectangle)
Draws text within a rectangle using the specified settings.
Definition: qgstextrenderer.cpp:82

QgsTextRenderer::textHeight
static double textHeight(const QgsRenderContext &context, const QgsTextFormat &format, const QStringList &textLines, Qgis::TextLayoutMode mode=Qgis::TextLayoutMode::Point, QFontMetricsF *fontMetrics=nullptr, Qgis::TextRendererFlags flags=Qgis::TextRendererFlags(), double maxLineWidth=0)
Returns the height of a text based on a given format.
Definition: qgstextrenderer.cpp:618

qgsDoubleToString
QString qgsDoubleToString(double a, int precision=17)
Returns a string representation of a double.
Definition: qgis.h:3448

qgsDoubleNear
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition: qgis.h:3509

qgsapplication.h

qgsbasicnumericformat.h

qgsexpressioncontextutils.h

qgsfillsymbol.h

qgsfillsymbollayer.h

qgslinesymbol.h

qgslinesymbollayer.h

qgsnumericformatregistry.h

qgsplot.h

QgsSymbolLayerList
QList< QgsSymbolLayer * > QgsSymbolLayerList
Definition: qgssymbol.h:29

qgssymbollayerutils.h

qgstextrenderer.h

QgsExpressionContextScope::StaticVariable
Single variable definition for use within a QgsExpressionContextScope.
Definition: qgsexpressioncontext.h:125