qgsrasterdataprovider.h

Go to the documentation of this file.

/***************************************************************************
    qgsrasterdataprovider.h - DataProvider Interface for raster layers
     --------------------------------------
    Date                 : Mar 11, 2005
    Copyright            : (C) 2005 by Brendan Morley
    email                : morb at ozemail dot com dot au
 
    async legend fetcher : Sandro Santilli < strk at keybit dot net >
 
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/
 
/* Thank you to Marco Hugentobler for the original vector DataProvider */
 
#ifndef QGSRASTERDATAPROVIDER_H
#define QGSRASTERDATAPROVIDER_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include <cmath>
 
#include <QDateTime>
#include <QVariant>
#include <QImage>
 
#include "qgscolorrampshader.h"
#include "qgsdataprovider.h"
#include "qgsrasterattributetable.h"
#include "qgsfields.h"
#include "qgsrasterinterface.h"
#include "qgsrasterpyramid.h"
#include "qgsrasterrange.h"
#include "qgsrectangle.h"
#include "qgsrasteriterator.h"
#include "qgsrasterdataprovidertemporalcapabilities.h"
 
class QImage;
class QByteArray;
 
class QgsPointXY;
class QgsRasterIdentifyResult;
class QgsMapSettings;
 
class CORE_EXPORT QgsImageFetcher : public QObject
{
    Q_OBJECT
  public:
    QgsImageFetcher( QObject *parent = nullptr ) : QObject( parent ) {}
 
    virtual void start() = 0;
 
  signals:
 
    void finish( const QImage &legend );
    void progress( qint64 received, qint64 total );
    void error( const QString &msg );
};
 
 
class CORE_EXPORT QgsRasterDataProvider : public QgsDataProvider, public QgsRasterInterface
{
    Q_OBJECT
 
  public:
 
    enum ProviderCapability
    {
      NoProviderCapabilities = 0,       
      ReadLayerMetadata = 1 << 1, 
      WriteLayerMetadata = 1 << 2, 
      ProviderHintBenefitsFromResampling = 1 << 3, 
      ProviderHintCanPerformProviderResampling = 1 << 4, 
      ReloadData = 1 << 5, 
      DpiDependentData = 1 << 6, 
      NativeRasterAttributeTable = 1 << 7, 
    };
 
    Q_DECLARE_FLAGS( ProviderCapabilities, ProviderCapability )
 
    QgsRasterDataProvider();
 
    QgsRasterDataProvider( const QString &uri,
                           const QgsDataProvider::ProviderOptions &providerOptions = QgsDataProvider::ProviderOptions(),
                           QgsDataProvider::ReadFlags flags = QgsDataProvider::ReadFlags() );
 
    QgsRasterDataProvider *clone() const override = 0;
 
    virtual QgsRasterDataProvider::ProviderCapabilities providerCapabilities() const;
 
    /* It makes no sense to set input on provider */
    bool setInput( QgsRasterInterface *input ) override { Q_UNUSED( input ) return false; }
 
    QgsRectangle extent() const override = 0;
 
    Qgis::DataType dataType( int bandNo ) const override = 0;
 
    virtual QgsFields fields() const { return QgsFields(); };
 
    Qgis::DataType sourceDataType( int bandNo ) const override = 0;
 
    virtual Qgis::RasterColorInterpretation colorInterpretation( int bandNo ) const;
 
    QString colorName( Qgis::RasterColorInterpretation colorInterpretation ) const
    {
      // Modified copy from GDAL
      switch ( colorInterpretation )
      {
        case Qgis::RasterColorInterpretation::Undefined:
          return QStringLiteral( "Undefined" );
 
        case Qgis::RasterColorInterpretation::GrayIndex:
          return QStringLiteral( "Gray" );
 
        case Qgis::RasterColorInterpretation::PaletteIndex:
          return QStringLiteral( "Palette" );
 
        case Qgis::RasterColorInterpretation::RedBand:
          return QStringLiteral( "Red" );
 
        case Qgis::RasterColorInterpretation::GreenBand:
          return QStringLiteral( "Green" );
 
        case Qgis::RasterColorInterpretation::BlueBand:
          return QStringLiteral( "Blue" );
 
        case Qgis::RasterColorInterpretation::AlphaBand:
          return QStringLiteral( "Alpha" );
 
        case Qgis::RasterColorInterpretation::HueBand:
          return QStringLiteral( "Hue" );
 
        case Qgis::RasterColorInterpretation::SaturationBand:
          return QStringLiteral( "Saturation" );
 
        case Qgis::RasterColorInterpretation::LightnessBand:
          return QStringLiteral( "Lightness" );
 
        case Qgis::RasterColorInterpretation::CyanBand:
          return QStringLiteral( "Cyan" );
 
        case Qgis::RasterColorInterpretation::MagentaBand:
          return QStringLiteral( "Magenta" );
 
        case Qgis::RasterColorInterpretation::YellowBand:
          return QStringLiteral( "Yellow" );
 
        case Qgis::RasterColorInterpretation::BlackBand:
          return QStringLiteral( "Black" );
 
        case Qgis::RasterColorInterpretation::YCbCr_YBand:
          return QStringLiteral( "YCbCr_Y" );
 
        case Qgis::RasterColorInterpretation::YCbCr_CbBand:
          return QStringLiteral( "YCbCr_Cb" );
 
        case Qgis::RasterColorInterpretation::YCbCr_CrBand:
          return QStringLiteral( "YCbCr_Cr" );
 
        case Qgis::RasterColorInterpretation::ContinuousPalette:
          return QStringLiteral( "Continuous Palette" );
      }
      return QString();
    }
 
    virtual bool reload() { return true; }
 
    QString colorInterpretationName( int bandNo ) const override;
 
    virtual double bandScale( int bandNo ) const { Q_UNUSED( bandNo ) return 1.0; }
 
    virtual double bandOffset( int bandNo ) const { Q_UNUSED( bandNo ) return 0.0; }
 
    // TODO: remove or make protected all readBlock working with void*
 
    QgsRasterBlock *block( int bandNo, const QgsRectangle &boundingBox, int width, int height, QgsRasterBlockFeedback *feedback = nullptr ) override SIP_FACTORY;
 
    virtual bool sourceHasNoDataValue( int bandNo ) const { return mSrcHasNoDataValue.value( bandNo - 1 ); }
 
    virtual bool useSourceNoDataValue( int bandNo ) const { return mUseSrcNoDataValue.value( bandNo - 1 ); }
 
    virtual void setUseSourceNoDataValue( int bandNo, bool use );
 
    virtual double sourceNoDataValue( int bandNo ) const { return mSrcNoDataValue.value( bandNo - 1 ); }
 
    virtual void setUserNoDataValue( int bandNo, const QgsRasterRangeList &noData );
 
    virtual QgsRasterRangeList userNoDataValues( int bandNo ) const { return mUserNoDataValue.value( bandNo - 1 ); }
 
    virtual QList<QgsColorRampShader::ColorRampItem> colorTable( int bandNo ) const
    { Q_UNUSED( bandNo ) return QList<QgsColorRampShader::ColorRampItem>(); }
 
    QStringList subLayers() const override
    {
      return QStringList();
    }
 
    QgsRasterDataProviderTemporalCapabilities *temporalCapabilities() override;
    const QgsRasterDataProviderTemporalCapabilities *temporalCapabilities() const override SIP_SKIP;
 
    virtual bool supportsLegendGraphic() const { return false; }
 
    virtual QImage getLegendGraphic( double scale = 0, bool forceRefresh = false, const QgsRectangle *visibleExtent = nullptr ) SIP_SKIP
    {
      Q_UNUSED( scale )
      Q_UNUSED( forceRefresh )
      Q_UNUSED( visibleExtent )
      return QImage();
    }
 
    virtual QgsImageFetcher *getLegendGraphicFetcher( const QgsMapSettings *mapSettings ) SIP_FACTORY
    {
      Q_UNUSED( mapSettings )
      return nullptr;
    }
 
    virtual QString buildPyramids( const QList<QgsRasterPyramid> &pyramidList,
                                   const QString &resamplingMethod = "NEAREST",
                                   Qgis::RasterPyramidFormat format = Qgis::RasterPyramidFormat::GeoTiff,
                                   const QStringList &configOptions = QStringList(),
                                   QgsRasterBlockFeedback *feedback = nullptr )
    {
      Q_UNUSED( pyramidList )
      Q_UNUSED( resamplingMethod )
      Q_UNUSED( format )
      Q_UNUSED( configOptions )
      Q_UNUSED( feedback )
      return QStringLiteral( "FAILED_NOT_SUPPORTED" );
    }
 
    virtual QList<QgsRasterPyramid> buildPyramidList( const QList<int> &overviewList = QList<int>() )
    { Q_UNUSED( overviewList ) return QList<QgsRasterPyramid>(); }
 
    bool hasPyramids();
 
    virtual QString htmlMetadata() = 0;
 
    virtual QgsRasterIdentifyResult identify( const QgsPointXY &point, Qgis::RasterIdentifyFormat format, const QgsRectangle &boundingBox = QgsRectangle(), int width = 0, int height = 0, int dpi = 96 );
 
    virtual double sample( const QgsPointXY &point, int band,
                           bool *ok SIP_OUT = nullptr,
                           const QgsRectangle &boundingBox = QgsRectangle(), int width = 0, int height = 0, int dpi = 96 );
 
    virtual QString lastErrorTitle() = 0;
 
    virtual QString lastError() = 0;
 
    virtual QString lastErrorFormat();
 
    int dpi() const { return mDpi; }
 
    void setDpi( int dpi ) { mDpi = dpi; }
 
    QDateTime timestamp() const override { return mTimestamp; }
 
    QDateTime dataTimestamp() const override { return QDateTime(); }
 
    virtual bool isEditable() const { return false; }
 
    virtual bool setEditable( bool enabled ) { Q_UNUSED( enabled ) return false; }
 
    // TODO: add data type (may be different from band type)
 
    virtual bool write( void *data, int band, int width, int height, int xOffset, int yOffset )
    {
      Q_UNUSED( data )
      Q_UNUSED( band )
      Q_UNUSED( width )
      Q_UNUSED( height )
      Q_UNUSED( xOffset )
      Q_UNUSED( yOffset )
      return false;
    }
 
    bool writeBlock( QgsRasterBlock *block, int band, int xOffset = 0, int yOffset = 0 );
 
    static QgsRasterDataProvider *create( const QString &providerKey,
                                          const QString &uri,
                                          const QString &format, int nBands,
                                          Qgis::DataType type,
                                          int width, int height, double *geoTransform,
                                          const QgsCoordinateReferenceSystem &crs,
                                          const QStringList &createOptions = QStringList() );
 
    virtual bool setNoDataValue( int bandNo, double noDataValue ) { Q_UNUSED( bandNo ) Q_UNUSED( noDataValue ); return false; }
 
    virtual bool remove() { return false; }
 
    static QList<QPair<QString, QString> > pyramidResamplingMethods( const QString &providerKey );
 
    struct VirtualRasterInputLayers
    {
      QString name;
      QString uri;
      QString provider;
    };
 
    struct VirtualRasterParameters
    {
      QgsCoordinateReferenceSystem crs;
      QgsRectangle extent;
      int width;
      int height;
      QString formula;
      QList <QgsRasterDataProvider::VirtualRasterInputLayers> rInputLayers;
 
    };
 
    static QgsRasterDataProvider::VirtualRasterParameters decodeVirtualRasterProviderUri( const QString &uri, bool *ok = nullptr );
 
    static QString encodeVirtualRasterProviderUri( const VirtualRasterParameters &parts );
 
    virtual QString validateCreationOptions( const QStringList &createOptions, const QString &format )
    { Q_UNUSED( createOptions ) Q_UNUSED( format ); return QString(); }
 
    virtual QString validatePyramidsConfigOptions( Qgis::RasterPyramidFormat pyramidsFormat,
        const QStringList &configOptions, const QString &fileFormat )
    { Q_UNUSED( pyramidsFormat ) Q_UNUSED( configOptions ); Q_UNUSED( fileFormat ); return QString(); }
 
    static QString identifyFormatName( Qgis::RasterIdentifyFormat format );
 
    static Qgis::RasterIdentifyFormat identifyFormatFromName( const QString &formatName );
 
    static QString identifyFormatLabel( Qgis::RasterIdentifyFormat format );
 
    static Capability identifyFormatToCapability( Qgis::RasterIdentifyFormat format );
 
    virtual int stepWidth() const { return QgsRasterIterator::DEFAULT_MAXIMUM_TILE_WIDTH; }
 
    virtual int stepHeight() const { return QgsRasterIterator::DEFAULT_MAXIMUM_TILE_HEIGHT; }
 
    virtual QList< double > nativeResolutions() const;
 
    virtual bool ignoreExtents() const;
 
    enum TransformType
    {
      TransformImageToLayer,  
      TransformLayerToImage,  
    };
 
    virtual QgsPoint transformCoordinates( const QgsPoint &point, TransformType type );
 
 
    virtual bool enableProviderResampling( bool enable ) { Q_UNUSED( enable ); return false; }
 
    bool isProviderResamplingEnabled() const { return mProviderResamplingEnabled; }
 
    enum class ResamplingMethod
    {
      Nearest, 
      Bilinear, 
      Cubic,
      CubicSpline, 
      Lanczos, 
      Average, 
      Mode, 
      Gauss 
    };
 
    virtual bool setZoomedInResamplingMethod( ResamplingMethod method ) { Q_UNUSED( method ); return false; }
 
    ResamplingMethod zoomedInResamplingMethod() const { return mZoomedInResamplingMethod; }
 
    virtual bool setZoomedOutResamplingMethod( ResamplingMethod method ) { Q_UNUSED( method ); return false; }
 
    ResamplingMethod zoomedOutResamplingMethod() const { return mZoomedOutResamplingMethod; }
 
    virtual bool setMaxOversampling( double factor ) { Q_UNUSED( factor ); return false; }
 
    double maxOversampling() const { return mMaxOversampling; }
 
    void readXml( const QDomElement &filterElem ) override;
 
    void writeXml( QDomDocument &doc, QDomElement &parentElem ) const override;
 
    QgsRasterAttributeTable *attributeTable( int bandNumber ) const;
 
    void setAttributeTable( int bandNumber, QgsRasterAttributeTable *attributeTable SIP_TRANSFER );
 
    void removeAttributeTable( int bandNumber );
 
    bool writeFileBasedAttributeTable( int bandNumber, const QString &path, QString *errorMessage SIP_OUT = nullptr ) const;
 
    bool readFileBasedAttributeTable( int bandNumber, const QString &path, QString *errorMessage SIP_OUT = nullptr );
 
    virtual bool writeNativeAttributeTable( QString *errorMessage SIP_OUT = nullptr );  //#spellok
 
    virtual bool readNativeAttributeTable( QString *errorMessage SIP_OUT  = nullptr );
 
 
  signals:
 
    void statusChanged( const QString & ) const;
 
 
  protected:
 
    virtual bool readBlock( int bandNo, int xBlock, int yBlock, void *data ) SIP_SKIP
    { Q_UNUSED( bandNo ) Q_UNUSED( xBlock ); Q_UNUSED( yBlock ); Q_UNUSED( data ); return false; }
 
    virtual bool readBlock( int bandNo, QgsRectangle  const &viewExtent, int width, int height, void *data, QgsRasterBlockFeedback *feedback = nullptr ) SIP_SKIP
    { Q_UNUSED( bandNo ) Q_UNUSED( viewExtent ); Q_UNUSED( width ); Q_UNUSED( height ); Q_UNUSED( data ); Q_UNUSED( feedback ); return false; }
 
    bool userNoDataValuesContains( int bandNo, double value ) const;
 
    void copyBaseSettings( const QgsRasterDataProvider &other );
 
    int mDpi = -1;
 
    //bool hasNoDataValue ( int bandNo );
 
    QList<double> mSrcNoDataValue;
 
    QList<bool> mSrcHasNoDataValue;
 
    QList<bool> mUseSrcNoDataValue;
 
    QList< QgsRasterRangeList > mUserNoDataValue;
 
    mutable QgsRectangle mExtent;
 
    bool mProviderResamplingEnabled = false;
 
    ResamplingMethod mZoomedInResamplingMethod = ResamplingMethod::Nearest;
 
    ResamplingMethod mZoomedOutResamplingMethod = ResamplingMethod::Nearest;
 
    double mMaxOversampling = 2.0;
 
  private:
 
    std::unique_ptr< QgsRasterDataProviderTemporalCapabilities > mTemporalCapabilities;
 
    std::map<int, std::unique_ptr<QgsRasterAttributeTable>> mAttributeTables;
 
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsRasterDataProvider::ProviderCapabilities )
 
// clazy:excludeall=qstring-allocations
 
#endif