qgsrendererrange.cpp

Go to the documentation of this file.

/***************************************************************************
    qgsrendererrange.cpp
    ---------------------
    begin                : September 2019
    copyright            : (C) 2019 by Denis Rouzaud
    email                : denis@opengis.ch
 ***************************************************************************
 *                                                                         *
 *   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 "qgssymbol.h"
#include "qgssldexportcontext.h"
 
#include <QLocale>
#include <QUuid>
 
 
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( const QgsClassificationRange &range, QgsSymbol *symbol, bool render, const QString &uuid ) {…}
 
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( double lowerValue, double upperValue, QgsSymbol *symbol, const QString &label, bool render, const QString &uuid ) {…}
 
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( const QgsRendererRange &range ) {…}
 
QgsRendererRange::~QgsRendererRange() = default;
 
QgsRendererRange &QgsRendererRange::operator=( QgsRendererRange range )
{
  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;
}
QgsRendererRange &QgsRendererRange::operator=( QgsRendererRange range ) {…}
 
bool QgsRendererRange::operator<( const QgsRendererRange &other ) const
{
  return
    lowerValue() < other.lowerValue() ||
    ( qgsDoubleNear( lowerValue(), other.lowerValue() ) && upperValue() < other.upperValue() );
}
bool QgsRendererRange::operator<( const QgsRendererRange &other ) const {…}
 
QString QgsRendererRange::uuid() const
{
  return mUuid;
}
QString QgsRendererRange::uuid() const {…}
 
double QgsRendererRange::lowerValue() const
{
  return mLowerValue;
}
double QgsRendererRange::lowerValue() const {…}
 
double QgsRendererRange::upperValue() const
{
  return mUpperValue;
}
double QgsRendererRange::upperValue() const {…}
 
QgsSymbol *QgsRendererRange::symbol() const
{
  return mSymbol.get();
}
QgsSymbol *QgsRendererRange::symbol() const {…}
 
QString QgsRendererRange::label() const
{
  return mLabel;
}
QString QgsRendererRange::label() const {…}
 
void QgsRendererRange::setSymbol( QgsSymbol *s )
{
  if ( mSymbol.get() != s ) mSymbol.reset( s );
}
void QgsRendererRange::setSymbol( QgsSymbol *s ) {…}
 
void QgsRendererRange::setLabel( const QString &label )
{
  mLabel = label;
}
void QgsRendererRange::setLabel( const QString &label ) {…}
 
void QgsRendererRange::setUpperValue( double upperValue )
{
  mUpperValue = upperValue;
}
void QgsRendererRange::setUpperValue( double upperValue ) {…}
 
void QgsRendererRange::setLowerValue( double lowerValue )
{
  mLowerValue = lowerValue;
}
void QgsRendererRange::setLowerValue( double lowerValue ) {…}
 
bool QgsRendererRange::renderState() const
{
  return mRender;
}
bool QgsRendererRange::renderState() const {…}
 
void QgsRendererRange::setRenderState( bool render )
{
  mRender = render;
}
void QgsRendererRange::setRenderState( bool render ) {…}
 
QString QgsRendererRange::dump() const
{
  return QStringLiteral( "%1 - %2::%3::%4\n" ).arg( mLowerValue ).arg( mUpperValue ).arg( mLabel, mSymbol ? mSymbol->dump() : QStringLiteral( "(no symbol)" ) );
}
QString QgsRendererRange::dump() const {…}
 
void QgsRendererRange::toSld( QDomDocument &doc, QDomElement &element, QVariantMap props, bool firstRange ) const
{
  QgsSldExportContext context;
  context.setExtraProperties( props );
  toSld( doc, element, props.value( QStringLiteral( "attribute" ), QString() ).toString(), context, firstRange );
}
void QgsRendererRange::toSld( QDomDocument &doc, QDomElement &element, QVariantMap props, bool firstRange ) const {…}
 
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( QStringLiteral( "se:Rule" ) );
 
  QDomElement nameElem = doc.createElement( QStringLiteral( "se:Name" ) );
  nameElem.appendChild( doc.createTextNode( mLabel ) );
  ruleElem.appendChild( nameElem );
 
  QDomElement descrElem = doc.createElement( QStringLiteral( "se:Description" ) );
  QDomElement titleElem = doc.createElement( QStringLiteral( "se:Title" ) );
  QString descrStr = QStringLiteral( "range: %1 - %2" ).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 = QStringLiteral( "\"%1\" %2 %3 AND \"%1\" <= %4" )
                       .arg( attrName.replace( '\"', QLatin1String( "\"\"" ) ),
                             firstRange ? QStringLiteral( ">=" ) : QStringLiteral( ">" ),
                             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;
}
bool QgsRendererRange::toSld( QDomDocument &doc, QDomElement &element, const QString &classAttribute, QgsSldExportContext &context, bool firstRange ) const {…}
 
 
 
const int QgsRendererRangeLabelFormat::MAX_PRECISION = 15;
const int QgsRendererRangeLabelFormat::MIN_PRECISION = -6;
 
QgsRendererRangeLabelFormat::QgsRendererRangeLabelFormat()
  : mFormat( QStringLiteral( "%1 - %2" ) )
  , mReTrailingZeroes( "[.,]?0*$" )
  , mReNegativeZero( "^\\-0(?:[.,]0*)?$" )
{
}
QgsRendererRangeLabelFormat::QgsRendererRangeLabelFormat() {…}
 
QgsRendererRangeLabelFormat::QgsRendererRangeLabelFormat( const QString &format, int precision, bool trimTrailingZeroes )
  : mReTrailingZeroes( "[.,]?0*$" )
  , mReNegativeZero( "^\\-0(?:[.,]0*)?$" )
{
  setFormat( format );
  setPrecision( precision );
  setTrimTrailingZeroes( trimTrailingZeroes );
}
QgsRendererRangeLabelFormat::QgsRendererRangeLabelFormat( const QString &format, int precision, bool 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 {…}
 
bool QgsRendererRangeLabelFormat::operator!=( const QgsRendererRangeLabelFormat &other ) const
{
  return !( *this == other );
}
bool QgsRendererRangeLabelFormat::operator!=( const QgsRendererRangeLabelFormat &other ) const {…}
 
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' );
  }
}
void QgsRendererRangeLabelFormat::setPrecision( int precision ) {…}
 
QString QgsRendererRangeLabelFormat::labelForRange( const QgsRendererRange &range ) const
{
  return labelForRange( range.lowerValue(), range.upperValue() );
}
QString QgsRendererRangeLabelFormat::labelForRange( const QgsRendererRange &range ) const {…}
 
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 == QLatin1String( "-0" ) )
      valueStr = '0';
    if ( valueStr != QLatin1String( "0" ) )
      valueStr = valueStr + mNumberSuffix;
    return valueStr;
  }
}
QString QgsRendererRangeLabelFormat::formatNumber( double value ) const {…}
 
QString QgsRendererRangeLabelFormat::labelForRange( double lower, double upper ) const
{
  QString lowerStr = formatNumber( lower );
  QString upperStr = formatNumber( upper );
 
  QString legend( mFormat );
  return legend.replace( QLatin1String( "%1" ), lowerStr ).replace( QLatin1String( "%2" ), upperStr );
}
QString QgsRendererRangeLabelFormat::labelForRange( double lower, double upper ) const {…}
 
void QgsRendererRangeLabelFormat::setFromDomElement( QDomElement &element )
{
  mFormat = element.attribute( QStringLiteral( "format" ),
                               element.attribute( QStringLiteral( "prefix" ), QStringLiteral( " " ) ) + "%1" +
                               element.attribute( QStringLiteral( "separator" ), QStringLiteral( " - " ) ) + "%2" +
                               element.attribute( QStringLiteral( "suffix" ), QStringLiteral( " " ) )
                             );
  setPrecision( element.attribute( QStringLiteral( "decimalplaces" ), QStringLiteral( "4" ) ).toInt() );
  mTrimTrailingZeroes = element.attribute( QStringLiteral( "trimtrailingzeroes" ), QStringLiteral( "false" ) ) == QLatin1String( "true" );
}
void QgsRendererRangeLabelFormat::setFromDomElement( QDomElement &element ) {…}
 
void QgsRendererRangeLabelFormat::saveToDomElement( QDomElement &element )
{
  element.setAttribute( QStringLiteral( "format" ), mFormat );
  element.setAttribute( QStringLiteral( "decimalplaces" ), mPrecision );
  element.setAttribute( QStringLiteral( "trimtrailingzeroes" ), mTrimTrailingZeroes ? QStringLiteral( "true" ) : QStringLiteral( "false" ) );
}
void QgsRendererRangeLabelFormat::saveToDomElement( QDomElement &element ) {…}