src/core/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
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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 <QDateTime>

#include "qgslogger.h"
#include "qgsrectangle.h"
#include "qgsdataprovider.h"
#include "qgscolorrampshader.h"
#include "qgsrasterpyramid.h"
#include "qgscoordinatereferencesystem.h"
#include "qgsrasterbandstats.h"
#include "cpl_conv.h"
#include <cmath>

class QImage;
class QgsPoint;
class QByteArray;

#define TINY_VALUE  std::numeric_limits<double>::epsilon() * 20


class CORE_EXPORT QgsRasterDataProvider : public QgsDataProvider
{

    Q_OBJECT

  public:

    enum Capability
    {
      NoCapabilities =          0,
      Identify =                1,
      ExactMinimumMaximum =     1 << 1,
      ExactResolution =         1 << 2,
      EstimatedMinimumMaximum = 1 << 3,
      BuildPyramids =           1 << 4,
      Histogram =               1 << 5,
      Size =                    1 << 6  // has fixed source type
    };

    // This is modified copy of GDALDataType
    enum DataType
    {          UnknownDataType = 0,           Byte = 1,         UInt16 = 2,           Int16 = 3,      UInt32 = 4,        Int32 = 5,        Float32 = 6,        Float64 = 7,                        CInt16 = 8,                        CInt32 = 9,                      CFloat32 = 10,                      CFloat64 = 11, ARGBDataType = 12,
      TypeCount = 13          /* maximum type # + 1 */
    };

    // This is modified copy of GDALColorInterp
    enum ColorInterpretation
    {
      UndefinedColorInterpretation = 0,                                      GrayIndex = 1,          PaletteIndex = 2,                         RedBand = 3,                       GreenBand = 4,                        BlueBand = 5,              AlphaBand = 6,                          HueBand = 7,                   SaturationBand = 8,                    LightnessBand = 9,                        CyanBand = 10,                     MagentaBand = 11,                      YellowBand = 12,                       BlackBand = 13,                                    YCbCr_YBand = 14,                                      YCbCr_CbBand = 15,                                      YCbCr_CrBand = 16,                              ColorInterpretationMax = 16
    };

    // Progress types
    enum RasterProgressType
    {
      ProgressHistogram = 0,
      ProgressPyramids  = 1,
      ProgressStatistics = 2
    };

    QgsRasterDataProvider();

    QgsRasterDataProvider( QString const & uri );

    virtual ~QgsRasterDataProvider() {};


    virtual void addLayers( QStringList const & layers,
                            QStringList  const & styles = QStringList() ) = 0;

    virtual QStringList supportedImageEncodings() = 0;

    virtual QString imageEncoding() const = 0;

    virtual void setImageEncoding( QString  const & mimeType ) = 0;

    virtual void setImageCrs( QString const & crs ) = 0;


    // TODO: Document this better.
    virtual QImage* draw( QgsRectangle  const & viewExtent, int pixelWidth, int pixelHeight ) = 0;

    virtual int capabilities() const
    {
      return QgsRasterDataProvider::NoCapabilities;
    }

    QString capabilitiesString() const;


    // TODO: Get the supported formats by this provider

    // TODO: Get the file masks supported by this provider, suitable for feeding into the file open dialog box

    virtual int dataType( int bandNo ) const
    {
      return srcDataType( bandNo );
    }

    virtual int srcDataType( int bandNo ) const
    {
      Q_UNUSED( bandNo );
      return QgsRasterDataProvider::UnknownDataType;
    }

    int typeSize( int dataType ) const
    {
      // modified copy from GDAL
      switch ( dataType )
      {
        case Byte:
          return 8;

        case UInt16:
        case Int16:
          return 16;

        case UInt32:
        case Int32:
        case Float32:
        case CInt16:
          return 32;

        case Float64:
        case CInt32:
        case CFloat32:
          return 64;

        case CFloat64:
          return 128;

        case ARGBDataType:
          return 32;

        default:
          return 0;
      }
    }
    int dataTypeSize( int bandNo ) const
    {
      return typeSize( dataType( bandNo ) );
    }

    virtual int bandCount() const
    {
      return 1;
    }

    virtual int colorInterpretation( int theBandNo ) const
    {
      Q_UNUSED( theBandNo );
      return QgsRasterDataProvider::UndefinedColorInterpretation;
    }

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

        case GrayIndex:
          return "Gray";

        case PaletteIndex:
          return "Palette";

        case RedBand:
          return "Red";

        case GreenBand:
          return "Green";

        case BlueBand:
          return "Blue";

        case AlphaBand:
          return "Alpha";

        case HueBand:
          return "Hue";

        case SaturationBand:
          return "Saturation";

        case LightnessBand:
          return "Lightness";

        case CyanBand:
          return "Cyan";

        case MagentaBand:
          return "Magenta";

        case YellowBand:
          return "Yellow";

        case BlackBand:
          return "Black";

        case YCbCr_YBand:
          return "YCbCr_Y";

        case YCbCr_CbBand:
          return "YCbCr_Cb";

        case YCbCr_CrBand:
          return "YCbCr_Cr";

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

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

    virtual int xBlockSize() const { return 0; }
    virtual int yBlockSize() const { return 0; }

    virtual int xSize() const { return 0; }
    virtual int ySize() const { return 0; }

    // TODO clarify what happens on the last block (the part outside raster)
    virtual void readBlock( int bandNo, int xBlock, int yBlock, void *data )
    { 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 )
    { Q_UNUSED( bandNo ); Q_UNUSED( viewExtent ); Q_UNUSED( width ); Q_UNUSED( height ); Q_UNUSED( data ); }

    virtual void readBlock( int bandNo, QgsRectangle  const & viewExtent, int width, int height, QgsCoordinateReferenceSystem theSrcCRS, QgsCoordinateReferenceSystem theDestCRS, void *data );
    
    /* Read a value from a data block at a given index. */
    virtual double readValue( void *data, int type, int index );

    virtual double noDataValue() const { return 0; }

    virtual double minimumValue( int bandNo ) const { Q_UNUSED( bandNo ); return 0; }
    virtual double maximumValue( int bandNo ) const { Q_UNUSED( bandNo ); return 0; }

    virtual QList<QgsColorRampShader::ColorRampItem> colorTable( int bandNo ) const
    { Q_UNUSED( bandNo ); return QList<QgsColorRampShader::ColorRampItem>(); }

    // Defined in parent
    virtual QStringList subLayers() const
    {
      return QStringList();
    }

    virtual void populateHistogram( int theBandNoInt,
                                    QgsRasterBandStats & theBandStats,
                                    int theBinCountInt = 256,
                                    bool theIgnoreOutOfRangeFlag = true,
                                    bool theThoroughBandScanFlag = false
                                  )
    { Q_UNUSED( theBandNoInt ); Q_UNUSED( theBandStats ); Q_UNUSED( theBinCountInt ); Q_UNUSED( theIgnoreOutOfRangeFlag ); Q_UNUSED( theThoroughBandScanFlag ); }

    virtual QString buildPyramids( const QList<QgsRasterPyramid>  & thePyramidList,
                                   const QString &  theResamplingMethod = "NEAREST",
                                   bool theTryInternalFlag = false )
    { Q_UNUSED( thePyramidList ); Q_UNUSED( theResamplingMethod ); Q_UNUSED( theTryInternalFlag ); return "FAILED_NOT_SUPPORTED"; };

    virtual QList<QgsRasterPyramid> buildPyramidList() { return QList<QgsRasterPyramid>(); };

    virtual QgsRasterBandStats bandStatistics( int theBandNo );

    QString  generateBandName( int theBandNumber )
    {
      return tr( "Band" ) + QString( " %1" ) .arg( theBandNumber,  1 + ( int ) log10(( float ) bandCount() ), 10, QChar( '0' ) );
    };

    virtual QString metadata() = 0;

    virtual bool identify( const QgsPoint & point, QMap<QString, QString>& results );

    virtual QString identifyAsText( const QgsPoint& point ) = 0;

    virtual QString identifyAsHtml( const QgsPoint& point ) = 0;

    virtual QString lastErrorTitle() = 0;

    virtual QString lastError() = 0;

    virtual QString lastErrorFormat();

    //virtual void buildSupportedRasterFileFilter( QString & theFileFiltersString ) ;

    //virtual bool isValidRasterFileName( QString const & theFileNameQString, QString & retErrMsg ) { return false; } ;

    //virtual bool isValidRasterFileName( const QString & theFileNameQString ) { return false; };


    int dpi() const {return mDpi;}

    void setDpi( int dpi ) {mDpi = dpi;}

    bool isNoDataValueValid() const { return mValidNoDataValue; }

    static QStringList cStringList2Q_( char ** stringList );

    static QString makeTableCell( QString const & value );
    static QString makeTableCells( QStringList const & values );

    QByteArray noValueBytes( int theBandNo );

    virtual QDateTime timestamp() const { return mTimestamp; }

    virtual QDateTime dataTimestamp() const { return QDateTime(); }

  signals:
    void progress( int theType, double theProgress, QString theMessage );

  protected:
    int mDpi;

    QList<double> mNoDataValue;

    bool mValidNoDataValue;

    QgsRectangle mExtent;
};

#endif