qgsrendererrange.cpp

Go to the documentation of this file.

/***************************************************************************
    qgsrendererrange.cpp
    ---------------------
    begin                : September 2019
    copyright            : (C) 2019 by Denis Rouzaud
    email                : [email protected]
 ***************************************************************************
 *                                                                         *
 *   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 "qgsrendererrange.h"
 
#include "qgsclassificationmethod.h"
#include "qgssldexportcontext.h"
#include "qgssymbol.h"
 
#include <QLocale>
#include <QString>
#include <QUuid>
 
using namespace Qt::StringLiterals;
 
QgsRendererRange::QgsRendererRange( const QgsClassificationRange &range, QgsSymbol *symbol, bool render, const QString &uuid )
  : mLowerValue( range.lowerBound() )
  , mUpperValue( range.upperBound() )
  , mSymbol( symbol )
  , mLabel( range.label() )
  , mRender( render )
{
  mUuid = !uuid.isEmpty() ? uuid : QUuid::createUuid().toString();
}
 
QgsRendererRange::QgsRendererRange( double lowerValue, double upperValue, QgsSymbol *symbol, const QString &label, bool render, const QString &uuid )
  : mLowerValue( lowerValue )
  , mUpperValue( upperValue )
  , mSymbol( symbol )
  , mLabel( label )
  , mRender( render )
{
  mUuid = !uuid.isEmpty() ? uuid : QUuid::createUuid().toString();
}
 
QgsRendererRange::QgsRendererRange( const QgsRendererRange &range )
  : mLowerValue( range.mLowerValue )
  , mUpperValue( range.mUpperValue )
  , mSymbol( range.mSymbol ? range.mSymbol->clone() : nullptr )
  , mLabel( range.mLabel )
  , mRender( range.mRender )
  , mUuid( range.mUuid )
{}
 
QgsRendererRange::~QgsRendererRange() = default;
 
QgsRendererRange &QgsRendererRange::operator=( QgsRendererRange range )
{
  if ( &range == this )
    return *this;
 
  mLowerValue = range.mLowerValue;
  mUpperValue = range.mUpperValue;
  mSymbol.reset( range.mSymbol ? range.mSymbol->clone() : nullptr );
  mLabel = range.mLabel;
  mRender = range.mRender;
  mUuid = range.mUuid;
  return *this;
}
 
bool QgsRendererRange::operator<( const QgsRendererRange &other ) const
{
  return
    lowerValue() < other.lowerValue() ||
    ( qgsDoubleNear( lowerValue(), other.lowerValue() ) && upperValue() < other.upperValue() );
}
 
QString QgsRendererRange::uuid() const
{
  return mUuid;
}
 
double QgsRendererRange::lowerValue() const
{
  return mLowerValue;
}
 
double QgsRendererRange::upperValue() const
{
  return mUpperValue;
}
 
QgsSymbol *QgsRendererRange::symbol() const
{
  return mSymbol.get();
}
 
QString QgsRendererRange::label() const
{
  return mLabel;
}
 
void QgsRendererRange::setSymbol( QgsSymbol *s )
{
  if ( mSymbol.get() != s ) mSymbol.reset( s );
}
 
void QgsRendererRange::setLabel( const QString &label )
{
  mLabel = label;
}
 
void QgsRendererRange::setUpperValue( double upperValue )
{
  mUpperValue = upperValue;
}
 
void QgsRendererRange::setLowerValue( double lowerValue )
{
  mLowerValue = lowerValue;
}
 
bool QgsRendererRange::renderState() const
{
  return mRender;
}
 
void QgsRendererRange::setRenderState( bool render )
{
  mRender = render;
}
 
QString QgsRendererRange::dump() const
{
  return u"%1 - %2::%3::%4\n"_s.arg( mLowerValue ).arg( mUpperValue ).arg( mLabel, mSymbol ? mSymbol->dump() : u"(no symbol)"_s );
}
 
void QgsRendererRange::toSld( QDomDocument &doc, QDomElement &element, QVariantMap props, bool firstRange ) const
{
  QgsSldExportContext context;
  context.setExtraProperties( props );
  toSld( doc, element, props.value( u"attribute"_s, QString() ).toString(), context, firstRange );
}
 
bool QgsRendererRange::toSld( QDomDocument &doc, QDomElement &element, const QString &classAttribute, QgsSldExportContext &context, bool firstRange ) const
{
  if ( !mSymbol || classAttribute.isEmpty() )
    return false;
 
  QString attrName = classAttribute;
 
  QDomElement ruleElem = doc.createElement( u"se:Rule"_s );
 
  QDomElement nameElem = doc.createElement( u"se:Name"_s );
  nameElem.appendChild( doc.createTextNode( mLabel ) );
  ruleElem.appendChild( nameElem );
 
  QDomElement descrElem = doc.createElement( u"se:Description"_s );
  QDomElement titleElem = doc.createElement( u"se:Title"_s );
  QString descrStr = u"range: %1 - %2"_s.arg( qgsDoubleToString( mLowerValue ), qgsDoubleToString( mUpperValue ) );
  titleElem.appendChild( doc.createTextNode( !mLabel.isEmpty() ? mLabel : descrStr ) );
  descrElem.appendChild( titleElem );
  ruleElem.appendChild( descrElem );
 
  // create the ogc:Filter for the range
  QString filterFunc = u"\"%1\" %2 %3 AND \"%1\" <= %4"_s
                       .arg( attrName.replace( '\"', "\"\""_L1 ),
                             firstRange ? u">="_s : u">"_s,
                             qgsDoubleToString( mLowerValue ),
                             qgsDoubleToString( mUpperValue ) );
  QgsSymbolLayerUtils::createFunctionElement( doc, ruleElem, filterFunc, context );
 
  mSymbol->toSld( doc, ruleElem, context );
  if ( !QgsSymbolLayerUtils::hasSldSymbolizer( ruleElem ) )
  {
    // symbol could not be converted to SLD, or is an "empty" symbol. In this case we do not generate a rule, as
    // SLD spec requires a Symbolizer element to be present
    return false;
  }
 
  element.appendChild( ruleElem );
  return true;
}

 
 
const int QgsRendererRangeLabelFormat::MAX_PRECISION = 15;
const int QgsRendererRangeLabelFormat::MIN_PRECISION = -6;
 
QgsRendererRangeLabelFormat::QgsRendererRangeLabelFormat()
  : mFormat( u"%1 - %2"_s )
  , mReTrailingZeroes( "[.,]?0*$" )
  , mReNegativeZero( "^\\-0(?:[.,]0*)?$" )
{
}
 
QgsRendererRangeLabelFormat::QgsRendererRangeLabelFormat( const QString &format, int precision, bool trimTrailingZeroes )
  : mReTrailingZeroes( "[.,]?0*$" )
  , mReNegativeZero( "^\\-0(?:[.,]0*)?$" )
{
  setFormat( format );
  setPrecision( precision );
  setTrimTrailingZeroes( trimTrailingZeroes );
}
 
 
bool QgsRendererRangeLabelFormat::operator==( const QgsRendererRangeLabelFormat &other ) const
{
  return
    format() == other.format() &&
    precision() == other.precision() &&
    trimTrailingZeroes() == other.trimTrailingZeroes();
}
 
bool QgsRendererRangeLabelFormat::operator!=( const QgsRendererRangeLabelFormat &other ) const
{
  return !( *this == other );
}
 
void QgsRendererRangeLabelFormat::setPrecision( int precision )
{
  // Limit the range of decimal places to a reasonable range
  precision = std::clamp( precision, MIN_PRECISION, MAX_PRECISION );
  mPrecision = precision;
  mNumberScale = 1.0;
  mNumberSuffix.clear();
  while ( precision < 0 )
  {
    precision++;
    mNumberScale /= 10.0;
    mNumberSuffix.append( '0' );
  }
}
 
QString QgsRendererRangeLabelFormat::labelForRange( const QgsRendererRange &range ) const
{
  return labelForRange( range.lowerValue(), range.upperValue() );
}
 
QString QgsRendererRangeLabelFormat::formatNumber( double value ) const
{
  if ( mPrecision > 0 )
  {
    QString valueStr = QLocale().toString( value, 'f', mPrecision );
    if ( mTrimTrailingZeroes )
      valueStr = valueStr.remove( mReTrailingZeroes );
    if ( mReNegativeZero.match( valueStr ).hasMatch() )
      valueStr = valueStr.mid( 1 );
    return valueStr;
  }
  else
  {
    QString valueStr = QLocale().toString( value * mNumberScale, 'f', 0 );
    if ( valueStr == "-0"_L1 )
      valueStr = '0';
    if ( valueStr != "0"_L1 )
      valueStr = valueStr + mNumberSuffix;
    return valueStr;
  }
}
 
QString QgsRendererRangeLabelFormat::labelForRange( double lower, double upper ) const
{
  QString lowerStr = formatNumber( lower );
  QString upperStr = formatNumber( upper );
 
  QString legend( mFormat );
  return legend.replace( "%1"_L1, lowerStr ).replace( "%2"_L1, upperStr );
}
 
void QgsRendererRangeLabelFormat::setFromDomElement( QDomElement &element )
{
  mFormat = element.attribute( u"format"_s,
                               element.attribute( u"prefix"_s, u" "_s ) + "%1" +
                               element.attribute( u"separator"_s, u" - "_s ) + "%2" +
                               element.attribute( u"suffix"_s, u" "_s )
                             );
  setPrecision( element.attribute( u"decimalplaces"_s, u"4"_s ).toInt() );
  mTrimTrailingZeroes = element.attribute( u"trimtrailingzeroes"_s, u"false"_s ) == "true"_L1;
}
 
void QgsRendererRangeLabelFormat::saveToDomElement( QDomElement &element )
{
  element.setAttribute( u"format"_s, mFormat );
  element.setAttribute( u"decimalplaces"_s, mPrecision );
  element.setAttribute( u"trimtrailingzeroes"_s, mTrimTrailingZeroes ? u"true"_s : u"false"_s );
}