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 "qgsfields.h"
#include "qgsraster.h"
#include "qgsrasterinterface.h"
#include "qgsrasterpyramid.h"
#include "qgsrasterrange.h"
#include "qgsrectangle.h"
#include "qgsrasteriterator.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, 
    };

    Q_DECLARE_FLAGS( ProviderCapabilities, ProviderCapability )

    QgsRasterDataProvider();

    QgsRasterDataProvider( const QString &uri, const QgsDataProvider::ProviderOptions &options = QgsDataProvider::ProviderOptions() );

    QgsRasterInterface *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;

    Qgis::DataType sourceDataType( int bandNo ) const override = 0;

    virtual int colorInterpretation( int bandNo ) const
    {
      Q_UNUSED( bandNo );
      return QgsRaster::UndefinedColorInterpretation;
    }

    QString colorName( int colorInterpretation ) const
    {
      // Modified copy from GDAL
      switch ( colorInterpretation )
      {
        case QgsRaster::UndefinedColorInterpretation:
          return QStringLiteral( "Undefined" );

        case QgsRaster::GrayIndex:
          return QStringLiteral( "Gray" );

        case QgsRaster::PaletteIndex:
          return QStringLiteral( "Palette" );

        case QgsRaster::RedBand:
          return QStringLiteral( "Red" );

        case QgsRaster::GreenBand:
          return QStringLiteral( "Green" );

        case QgsRaster::BlueBand:
          return QStringLiteral( "Blue" );

        case QgsRaster::AlphaBand:
          return QStringLiteral( "Alpha" );

        case QgsRaster::HueBand:
          return QStringLiteral( "Hue" );

        case QgsRaster::SaturationBand:
          return QStringLiteral( "Saturation" );

        case QgsRaster::LightnessBand:
          return QStringLiteral( "Lightness" );

        case QgsRaster::CyanBand:
          return QStringLiteral( "Cyan" );

        case QgsRaster::MagentaBand:
          return QStringLiteral( "Magenta" );

        case QgsRaster::YellowBand:
          return QStringLiteral( "Yellow" );

        case QgsRaster::BlackBand:
          return QStringLiteral( "Black" );

        case QgsRaster::YCbCr_YBand:
          return QStringLiteral( "YCbCr_Y" );

        case QgsRaster::YCbCr_CbBand:
          return QStringLiteral( "YCbCr_Cb" );

        case QgsRaster::YCbCr_CrBand:
          return QStringLiteral( "YCbCr_Cr" );

        default:
          return QStringLiteral( "Unknown" );
      }
    }
    virtual bool reload() { return true; }

    virtual QString colorInterpretationName( int bandNo ) const
    {
      return colorName( colorInterpretation( bandNo ) );
    }

    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;

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

    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",
                                   QgsRaster::RasterPyramidsFormat format = QgsRaster::PyramidsGTiff,
                                   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( QList<int> overviewList = QList<int>() ) // clazy:exclude=function-args-by-ref
    { Q_UNUSED( overviewList ); return QList<QgsRasterPyramid>(); }

    bool hasPyramids();

    virtual QString htmlMetadata() = 0;

    //virtual QMap<int, QVariant> identify( const QgsPointXY & point, QgsRaster::IdentifyFormat format, const QgsRectangle &extent = QgsRectangle(), int width = 0, int height = 0 );
    virtual QgsRasterIdentifyResult identify( const QgsPointXY &point, QgsRaster::IdentifyFormat format, 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 );

    virtual QString validateCreationOptions( const QStringList &createOptions, const QString &format )
    { Q_UNUSED( createOptions ); Q_UNUSED( format ); return QString(); }

    virtual QString validatePyramidsConfigOptions( QgsRaster::RasterPyramidsFormat pyramidsFormat,
        const QStringList &configOptions, const QString &fileFormat )
    { Q_UNUSED( pyramidsFormat ); Q_UNUSED( configOptions ); Q_UNUSED( fileFormat ); return QString(); }

    static QString identifyFormatName( QgsRaster::IdentifyFormat format );
    static QgsRaster::IdentifyFormat identifyFormatFromName( const QString &formatName );
    static QString identifyFormatLabel( QgsRaster::IdentifyFormat format );
    static Capability identifyFormatToCapability( QgsRaster::IdentifyFormat format );

    virtual int stepWidth() const { return QgsRasterIterator::DEFAULT_MAXIMUM_TILE_WIDTH; }

    virtual int stepHeight() const { return QgsRasterIterator::DEFAULT_MAXIMUM_TILE_HEIGHT; }

  signals:

    void statusChanged( const QString & ) const;

  protected:

    virtual void readBlock( int bandNo, int xBlock, int yBlock, void *data ) SIP_SKIP
    { Q_UNUSED( bandNo ); Q_UNUSED( xBlock ); Q_UNUSED( yBlock ); Q_UNUSED( data ); }

    virtual void 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 ); }

    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;

};

Q_DECLARE_OPERATORS_FOR_FLAGS( QgsRasterDataProvider::ProviderCapabilities )

// clazy:excludeall=qstring-allocations

#endif