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 <cmath>
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgscolorrampshader.h"
#include "qgsdataprovider.h"
#include "qgsfields.h"
#include "qgsrasterattributetable.h"
#include "qgsrasterdataproviderelevationproperties.h"
#include "qgsrasterdataprovidertemporalcapabilities.h"
#include "qgsrasterinterface.h"
#include "qgsrasteriterator.h"
#include "qgsrasterpyramid.h"
#include "qgsrasterrange.h"
#include "qgsrectangle.h"
 
#include <QDateTime>
#include <QImage>
#include <QString>
#include <QVariant>
 
using namespace Qt::StringLiterals;
 
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:
    QgsRasterDataProvider();

    QgsRasterDataProvider(
      const QString &uri, const QgsDataProvider::ProviderOptions &providerOptions = QgsDataProvider::ProviderOptions(), Qgis::DataProviderReadFlags flags = Qgis::DataProviderReadFlags()
    );
 
    QgsRasterDataProvider *clone() const override = 0;
 

    virtual bool hasReportsDuringClose() const SIP_SKIP;

    virtual bool closeWithProgress( QgsFeedback *feedback ) SIP_SKIP;

    virtual Qgis::RasterProviderCapabilities 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;

    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;
    }

    virtual QSize maximumTileSize() const { return QSize( QgsRasterIterator::DEFAULT_MAXIMUM_TILE_WIDTH, QgsRasterIterator::DEFAULT_MAXIMUM_TILE_HEIGHT ); }
 
    // 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;
    QgsRasterDataProviderElevationProperties *elevationProperties() override;
    const QgsRasterDataProviderElevationProperties *elevationProperties() 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 u"FAILED_NOT_SUPPORTED"_s;
    }

    virtual QList<QgsRasterPyramid> buildPyramidList( const QList<int> &overviewList = QList<int>() )
    {
      Q_UNUSED( overviewList )
      return QList<QgsRasterPyramid>();
    }

    bool hasPyramids();

    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( const 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 );
 
    // TODO QGIS 5.0: rename createOptions to creationOptions for consistency with GDAL

    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 );
 
    // TODO QGIS 5.0: rename createOptions to creationOptions for consistency with GDAL

    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 Qgis::RasterInterfaceCapability 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; }

    virtual bool setZoomedInResamplingMethod( Qgis::RasterResamplingMethod method )
    {
      Q_UNUSED( method );
      return false;
    }

    Qgis::RasterResamplingMethod zoomedInResamplingMethod() const { return mZoomedInResamplingMethod; }

    virtual bool setZoomedOutResamplingMethod( Qgis::RasterResamplingMethod method )
    {
      Q_UNUSED( method );
      return false;
    }

    Qgis::RasterResamplingMethod 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 );

    // Note: This method is not const because GDAL init on demand
    virtual QString bandDescription( int bandNumber );
 
 
  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;

    Qgis::RasterResamplingMethod mZoomedInResamplingMethod = Qgis::RasterResamplingMethod::Nearest;

    Qgis::RasterResamplingMethod mZoomedOutResamplingMethod = Qgis::RasterResamplingMethod::Nearest;

    double mMaxOversampling = 2.0;
 
  private:
    std::unique_ptr< QgsRasterDataProviderTemporalCapabilities > mTemporalCapabilities;
 
    std::unique_ptr< QgsRasterDataProviderElevationProperties > mElevationProperties;
 
    std::map<int, std::unique_ptr<QgsRasterAttributeTable>> mAttributeTables;
};
 
// clazy:excludeall=qstring-allocations
 
#endif