qgsrasterrendererregistry.cpp

Go to the documentation of this file.

/***************************************************************************
                         qgsrasterrendererregistry.cpp
                         -----------------------------
    begin                : January 2012
    copyright            : (C) 2012 by Marco Hugentobler
    email                : marco at sourcepole dot 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 "qgsrasterrendererregistry.h"
 
#include "qgsapplication.h"
#include "qgscolorrampimpl.h"
#include "qgscontrastenhancement.h"
#include "qgshillshaderenderer.h"
#include "qgsmultibandcolorrenderer.h"
#include "qgspalettedrasterrenderer.h"
#include "qgsrastercontourrenderer.h"
#include "qgsrasterdataprovider.h"
#include "qgsrastershader.h"
#include "qgsrastersinglecolorrenderer.h"
#include "qgsrastertransparency.h"
#include "qgssettingsentryimpl.h"
#include "qgssettingstree.h"
#include "qgssinglebandcolordatarenderer.h"
#include "qgssinglebandgrayrenderer.h"
#include "qgssinglebandpseudocolorrenderer.h"
 
#include <QIcon>
#include <QString>
 
using namespace Qt::StringLiterals;
 
const QgsSettingsEntryInteger *QgsRasterRendererRegistry::settingsDefaultRedBand
  = new QgsSettingsEntryInteger( u"default-red-band"_s, QgsSettingsTree::sTreeRaster, 1, u"Default band number assigned to the red channel when creating an RGB renderer for a multi-band raster."_s );
const QgsSettingsEntryInteger *QgsRasterRendererRegistry::settingsDefaultGreenBand
  = new QgsSettingsEntryInteger( u"default-green-band"_s, QgsSettingsTree::sTreeRaster, 2, u"Default band number assigned to the green channel when creating an RGB renderer for a multi-band raster."_s );
const QgsSettingsEntryInteger *QgsRasterRendererRegistry::settingsDefaultBlueBand
  = new QgsSettingsEntryInteger( u"default-blue-band"_s, QgsSettingsTree::sTreeRaster, 3, u"Default band number assigned to the blue channel when creating an RGB renderer for a multi-band raster."_s );
const QgsSettingsEntryBool *QgsRasterRendererRegistry::settingsUseStandardDeviation
  = new QgsSettingsEntryBool( u"use-standard-deviation"_s, QgsSettingsTree::sTreeRaster, false, u"If true, newly created raster renderers use a standard-deviation based contrast enhancement by default."_s );
const QgsSettingsEntryDouble *QgsRasterRendererRegistry::settingsDefaultStandardDeviation
  = new QgsSettingsEntryDouble( u"default-standard-deviation"_s, QgsSettingsTree::sTreeRaster, 2.0, u"Default standard deviation multiplier used to compute min/max values for raster contrast enhancement when \"use-standard-deviation\" is enabled."_s );
 
QgsRasterRendererRegistryEntry::QgsRasterRendererRegistryEntry(
  const QString &name, const QString &visibleName, QgsRasterRendererCreateFunc rendererFunction, QgsRasterRendererWidgetCreateFunc widgetFunction, Qgis::RasterRendererCapabilities capabilities
)
  : name( name )
  , visibleName( visibleName )
  , capabilities( capabilities )
  , rendererCreateFunction( rendererFunction )
  , widgetCreateFunction( widgetFunction )
{}
 
QIcon QgsRasterRendererRegistryEntry::icon()
{
  return QgsApplication::getThemeIcon( QString( "styleicons/%1.svg" ).arg( name ) );
}
 
QgsRasterRendererRegistry::QgsRasterRendererRegistry()
{
  // insert items in a particular order, which is returned in renderersList()
  insert( QgsRasterRendererRegistryEntry( u"multibandcolor"_s, QObject::tr( "Multiband color" ), QgsMultiBandColorRenderer::create, nullptr, Qgis::RasterRendererCapability::UsesMultipleBands ) );
  insert( QgsRasterRendererRegistryEntry( u"paletted"_s, QObject::tr( "Paletted/Unique values" ), QgsPalettedRasterRenderer::create, nullptr ) );
  insert( QgsRasterRendererRegistryEntry( u"singlebandgray"_s, QObject::tr( "Singleband gray" ), QgsSingleBandGrayRenderer::create, nullptr ) );
  insert( QgsRasterRendererRegistryEntry( u"singlebandpseudocolor"_s, QObject::tr( "Singleband pseudocolor" ), QgsSingleBandPseudoColorRenderer::create, nullptr ) );
  insert( QgsRasterRendererRegistryEntry( u"singlebandcolordata"_s, QObject::tr( "Singleband color data" ), QgsSingleBandColorDataRenderer::create, nullptr ) );
  insert( QgsRasterRendererRegistryEntry( u"singlecolor"_s, QObject::tr( "Single color" ), QgsRasterSingleColorRenderer::create, nullptr ) );
  insert( QgsRasterRendererRegistryEntry( u"hillshade"_s, QObject::tr( "Hillshade" ), QgsHillshadeRenderer::create, nullptr ) );
  insert( QgsRasterRendererRegistryEntry( u"contour"_s, QObject::tr( "Contours" ), QgsRasterContourRenderer::create, nullptr ) );
}
 
void QgsRasterRendererRegistry::insert( const QgsRasterRendererRegistryEntry &entry )
{
  mEntries.insert( entry.name, entry );
  mSortedEntries.append( entry.name );
}
 
void QgsRasterRendererRegistry::insertWidgetFunction( const QString &rendererName, QgsRasterRendererWidgetCreateFunc func )
{
  if ( !mEntries.contains( rendererName ) )
  {
    return;
  }
  mEntries[rendererName].widgetCreateFunction = func;
}
 
bool QgsRasterRendererRegistry::rendererData( const QString &rendererName, QgsRasterRendererRegistryEntry &data ) const
{
  const QHash< QString, QgsRasterRendererRegistryEntry >::const_iterator it = mEntries.find( rendererName );
  if ( it == mEntries.constEnd() )
  {
    return false;
  }
  data = it.value();
  return true;
}
 
QStringList QgsRasterRendererRegistry::renderersList() const
{
  return mSortedEntries;
}
 
QList< QgsRasterRendererRegistryEntry > QgsRasterRendererRegistry::entries() const
{
  QList< QgsRasterRendererRegistryEntry > result;
 
  QHash< QString, QgsRasterRendererRegistryEntry >::const_iterator it = mEntries.constBegin();
  for ( ; it != mEntries.constEnd(); ++it )
  {
    result.push_back( it.value() );
  }
  return result;
}
 
Qgis::RasterRendererCapabilities QgsRasterRendererRegistry::rendererCapabilities( const QString &rendererName ) const
{
  const QHash< QString, QgsRasterRendererRegistryEntry >::const_iterator it = mEntries.constFind( rendererName );
  if ( it != mEntries.constEnd() )
  {
    return it.value().capabilities;
  }
  return Qgis::RasterRendererCapabilities();
}
 
std::unique_ptr<QgsRasterRenderer> QgsRasterRendererRegistry::defaultRendererForDrawingStyle( Qgis::RasterDrawingStyle drawingStyle, QgsRasterDataProvider *provider ) const
{
  if ( !provider || provider->bandCount() < 1 )
  {
    return nullptr;
  }
 
  std::unique_ptr< QgsRasterRenderer > renderer;
  switch ( drawingStyle )
  {
    case Qgis::RasterDrawingStyle::PalettedColor:
    {
      const int grayBand = 1; //reasonable default
 
      // first preference -- use attribute table to generate classes
      const QgsRasterAttributeTable *attributeTable { provider->attributeTable( grayBand ) };
      if ( attributeTable && attributeTable->hasColor() )
      {
        std::unique_ptr<QgsColorRamp> ramp;
        const QgsPalettedRasterRenderer::MultiValueClassData classes = QgsPalettedRasterRenderer::rasterAttributeTableToClassData( provider->attributeTable( grayBand ), -1, ramp.get() );
        if ( !classes.empty() )
        {
          renderer = std::make_unique< QgsPalettedRasterRenderer >( provider, grayBand, classes );
        }
      }
 
      // second preference -- use raster color table to generate classes
      if ( !renderer )
      {
        QgsPalettedRasterRenderer::ClassData classes = QgsPalettedRasterRenderer::colorTableToClassData( provider->colorTable( grayBand ) );
        if ( !classes.empty() )
        {
          // If there is an attribute table (with no colors), try to get the labels for the colors
          if ( attributeTable
               && attributeTable->fieldsByUsage( Qgis::RasterAttributeTableFieldUsage::MinMax ).size() > 0
               && attributeTable->fieldsByUsage( Qgis::RasterAttributeTableFieldUsage::Name ).size() > 0 )
          {
            const QgsRasterAttributeTable::Field minMaxFld = attributeTable->fieldsByUsage( Qgis::RasterAttributeTableFieldUsage::MinMax ).first();
            const QgsRasterAttributeTable::Field nameFld = attributeTable->fieldsByUsage( Qgis::RasterAttributeTableFieldUsage::Name ).first();
            const int fieldValueIndex = attributeTable->fields().indexOf( minMaxFld );
            const int fieldNameIndex = attributeTable->fields().indexOf( nameFld );
            QMap<double, QString> ratLabelsMap;
            const QList<QList<QVariant>> constRatData = attributeTable->data();
            for ( const auto &row : constRatData )
            {
              const double fieldValue = row.value( fieldValueIndex ).toDouble();
              const QString fieldName = row.value( fieldNameIndex ).toString();
              ratLabelsMap.insert( fieldValue, fieldName );
            }
 
            for ( qsizetype i = 0; i < classes.size(); ++i )
            {
              QgsPalettedRasterRenderer::Class &classData = classes[i];
              if ( ratLabelsMap.contains( classData.value ) )
              {
                classData.label = ratLabelsMap.value( classData.value );
              }
            }
          }
          renderer = std::make_unique< QgsPalettedRasterRenderer >( provider, grayBand, classes );
        }
      }
 
      // last preference -- just fallback to single band gray renderer if we couldn't determine color palette
      if ( !renderer )
      {
        renderer = std::make_unique< QgsSingleBandGrayRenderer >( provider, grayBand );
 
        QgsContrastEnhancement *ce = new QgsContrastEnhancement( ( Qgis::DataType ) ( provider->dataType( grayBand ) ) );
 
        // Default contrast enhancement is set from QgsRasterLayer, it has already setContrastEnhancementAlgorithm(). Default enhancement must only be set if default style was not loaded (to avoid stats calculation).
        qgis::down_cast< QgsSingleBandGrayRenderer * >( renderer.get() )->setContrastEnhancement( ce );
      }
    }
    break;
 
    case Qgis::RasterDrawingStyle::MultiBandSingleBandGray:
    case Qgis::RasterDrawingStyle::SingleBandGray:
    {
      const int grayBand = 1;
 
      // If the raster band has an attribute table try to use it.
      QString ratErrorMessage;
      if ( QgsRasterAttributeTable *rat = provider->attributeTable( grayBand ); rat && rat->isValid( &ratErrorMessage ) )
      {
        renderer = rat->createRenderer( provider, grayBand );
      }
 
      if ( !ratErrorMessage.isEmpty() )
      {
        QgsDebugMsgLevel( u"Invalid RAT from band 1, RAT was not used to create the renderer: %1."_s.arg( ratErrorMessage ), 2 );
      }
 
      if ( !renderer )
      {
        renderer = std::make_unique< QgsSingleBandGrayRenderer >( provider, grayBand );
 
        QgsContrastEnhancement *ce = new QgsContrastEnhancement( ( Qgis::DataType ) ( provider->dataType( grayBand ) ) );
 
        // Default contrast enhancement is set from QgsRasterLayer, it has already setContrastEnhancementAlgorithm(). Default enhancement must only be set if default style was not loaded (to avoid stats calculation).
        qgis::down_cast< QgsSingleBandGrayRenderer * >( renderer.get() )->setContrastEnhancement( ce );
      }
      break;
    }
 
    case Qgis::RasterDrawingStyle::SingleBandPseudoColor:
    {
      const int bandNo = 1;
      double minValue = 0;
      double maxValue = 0;
      // TODO: avoid calculating statistics if not necessary (default style loaded)
      minMaxValuesForBand( bandNo, provider, minValue, maxValue );
      QgsRasterShader *shader = new QgsRasterShader( minValue, maxValue );
      renderer = std::make_unique< QgsSingleBandPseudoColorRenderer >( provider, bandNo, shader );
      break;
    }
    case Qgis::RasterDrawingStyle::MultiBandColor:
    {
      int redBand = settingsDefaultRedBand->value();
      if ( redBand < 0 || redBand > provider->bandCount() )
      {
        redBand = -1;
      }
      int greenBand = settingsDefaultGreenBand->value();
      if ( greenBand < 0 || greenBand > provider->bandCount() )
      {
        greenBand = -1;
      }
      int blueBand = settingsDefaultBlueBand->value();
      if ( blueBand < 0 || blueBand > provider->bandCount() )
      {
        blueBand = -1;
      }
 
      renderer = std::make_unique< QgsMultiBandColorRenderer >( provider, redBand, greenBand, blueBand );
      break;
    }
    case Qgis::RasterDrawingStyle::SingleBandColorData:
    {
      renderer = std::make_unique< QgsSingleBandColorDataRenderer >( provider, 1 );
      break;
    }
    default:
      return nullptr;
  }
 
  auto tr = std::make_unique< QgsRasterTransparency >();
  const int bandCount = renderer->usesBands().size();
  if ( bandCount == 1 )
  {
    tr->setTransparentSingleValuePixelList( {} );
  }
  else if ( bandCount == 3 )
  {
    tr->setTransparentThreeValuePixelList( {} );
  }
  renderer->setRasterTransparency( tr.release() );
  return renderer;
}
 
bool QgsRasterRendererRegistry::minMaxValuesForBand( int band, QgsRasterDataProvider *provider, double &minValue, double &maxValue ) const
{
  if ( !provider )
  {
    return false;
  }
 
  minValue = 0;
  maxValue = 0;
 
  if ( settingsUseStandardDeviation->value() )
  {
    const QgsRasterBandStats stats = provider->bandStatistics( band, Qgis::RasterBandStatistic::Mean | Qgis::RasterBandStatistic::StdDev );
 
    const double stdDevFactor = settingsDefaultStandardDeviation->value();
    const double diff = stdDevFactor * stats.stdDev;
    minValue = stats.mean - diff;
    maxValue = stats.mean + diff;
  }
  else
  {
    const QgsRasterBandStats stats = provider->bandStatistics( band, Qgis::RasterBandStatistic::Min | Qgis::RasterBandStatistic::Max );
    minValue = stats.minimumValue;
    maxValue = stats.maximumValue;
  }
  return true;
}