src/core/raster/qgsrasterlayer.h

Go to the documentation of this file.

/***************************************************************************
                        qgsrasterlayer.h  -  description
                              -------------------
 begin                : Fri Jun 28 2002
 copyright            : (C) 2004 by T.Sutton, Gary E.Sherman, Steve Halasz
 email                : [email protected]
***************************************************************************/
/*
 * Peter J. Ersts - contributed to the refactoring and maintenance of this class
 * B. Morley - added functions to convert this class to a data provider interface
 * Frank Warmerdam - contributed bug fixes and migrated class to use all GDAL_C_API calls
 */
/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/
/* $Id$ */
#ifndef QGSRASTERLAYER_H
#define QGSRASTERLAYER_H

//
// Includes
//

#include <QColor>
#include <QDateTime>
#include <QVector>
#include <QList>
#include <QMap>

#include "qgis.h"
#include "qgspoint.h"
#include "qgsmaplayer.h"
#include "qgsrasterviewport.h"
#include "qgscontrastenhancement.h"
#include "qgsrastertransparency.h"
#include "qgsrastershader.h"
#include "qgscolorrampshader.h"
#include "qgsrastershaderfunction.h"
#include "qgsrasterdataprovider.h"

//
// Forward declarations
//
class QgsMapToPixel;
class QgsRectangle;
class QgsRasterBandStats;
class QgsRasterPyramid;
class QImage;
class QPixmap;
class QSlider;
class QLibrary;

class CORE_EXPORT QgsRasterLayer : public QgsMapLayer
{
    Q_OBJECT
  public:
    QgsRasterLayer( const QString & path = QString::null,
                    const QString &  baseName = QString::null,
                    bool loadDefaultStyleFlag = true );

    QgsRasterLayer( int dummy,
                    const QString & baseName = QString(),
                    const QString & path = QString(),
                    const QString & providerLib = QString(),
                    const QStringList & layers = QStringList(),
                    const QStringList & styles = QStringList(),
                    const QString & format = QString(),
                    const QString & crs = QString() );


    ~QgsRasterLayer();


    //
    // Enums, structs and typedefs
    //
    enum ColorShadingAlgorithm
    {
      UndefinedShader,
      PseudoColorShader,
      FreakOutShader,
      ColorRampShader,
      UserDefinedShader
    };

    enum DrawingStyle
    {
      UndefinedDrawingStyle,
      SingleBandGray,                 // a single band image drawn as a range of gray colors
      SingleBandPseudoColor,          // a single band image drawn using a pseudocolor algorithm
      PalettedColor,                  //a "Palette" image drawn using color table
      PalettedSingleBandGray,        // a "Palette" layer drawn in gray scale
      PalettedSingleBandPseudoColor, // a "Palette" layerdrawn using a pseudocolor algorithm
      PalettedMultiBandColor,         // currently not supported
      MultiBandSingleGandGray,        // a layer containing 2 or more bands, but a single band drawn as a range of gray colors
      //added in 1.6 to fix naming glitch
      MultiBandSingleBandGray = MultiBandSingleGandGray, // a layer containing 2 or more bands, but a single band drawn as a range of gray colors
      MultiBandSingleBandPseudoColor, //a layer containing 2 or more bands, but a single band drawn using a pseudocolor algorithm
      MultiBandColor,                  //a layer containing 2 or more bands, mapped to RGB color space. In the case of a multiband with only two bands, one band will be mapped to more than one color.
      SingleBandColorDataStyle         // ARGB values rendered directly
    };

    enum LayerType
    {
      GrayOrUndefined,
      Palette,
      Multiband,
      ColorLayer
    } ;

    typedef QList<QgsContrastEnhancement> ContrastEnhancementList;

    typedef QList<QgsRasterPyramid> RasterPyramidList;

    typedef QList<QgsRasterBandStats> RasterStatsList;

    //
    // Static methods:
    //
    static void buildSupportedRasterFileFilter( QString & fileFilters );

    static bool isValidRasterFileName( const QString & theFileNameQString, QString &retError );
    static bool isValidRasterFileName( const QString & theFileNameQString );
    //static QStringList subLayers( GDALDatasetH dataset );


    static QDateTime lastModified( const QString &  name );

    // Keep this for now, it is used by Python interface!!!
    static void registerGdalDrivers();

    //
    // Non Static inline methods
    //

    void init();

    // For backward compatibility (Python) get rid of it once python is updated
    void setDataProvider( const QString & provider,
                          const QStringList & layers,
                          const QStringList & styles,
                          const QString & format,
                          const QString & crs );
    void setDataProvider( const QString & provider,
                          const QStringList & layers,
                          const QStringList & styles,
                          const QString & format,
                          const QString & crs,
                          bool loadDefaultStyleFlag );

    static QLibrary* loadProviderLibrary( QString theProviderKey );
    static QgsRasterDataProvider* loadProvider( QString theProviderKey, QString theDataSource = 0 );


    QString blueBandName() const { return mBlueBandName; }

    QgsRasterLayer::ColorShadingAlgorithm colorShadingAlgorithm() const { return mColorShadingAlgorithm; }

    QgsContrastEnhancement::ContrastEnhancementAlgorithm contrastEnhancementAlgorithm() { return mContrastEnhancementAlgorithm; }

    QString contrastEnhancementAlgorithmAsString() const;

    DrawingStyle drawingStyle() { return mDrawingStyle; }

    QString grayBandName() const { return mGrayBandName; }

    QString greenBandName() const { return mGreenBandName; }

    bool hasPyramids() { return mHasPyramids; }

    bool hasUserDefinedGrayMinimumMaximum() const { return mUserDefinedGrayMinimumMaximum; }

    bool hasUserDefinedRGBMinimumMaximum() const { return mUserDefinedRGBMinimumMaximum; }

    int height() { return mHeight; }

    bool invertHistogram() const { return mInvertColor; }

    bool isNoDataValueValid() const { return mValidNoDataValue; }

    bool isGrayMinimumMaximumEstimated() const { return mGrayMinimumMaximumEstimated; }

    bool isRGBMinimumMaximumEstimated() const { return mRGBMinimumMaximumEstimated; }

    double noDataValue( bool* isValid = 0 ) { if ( isValid ) { *isValid = mValidNoDataValue;} return mNoDataValue; }

    QgsRasterTransparency* rasterTransparency() { return &mRasterTransparency; }

    QgsRasterShader* rasterShader() { return mRasterShader; }

    LayerType rasterType() { return mRasterType; }

    QString redBandName() const { return mRedBandName; }


    void setDrawingStyle( const DrawingStyle &  theDrawingStyle ) { mDrawingStyle = theDrawingStyle; }

    void setGrayMinimumMaximumEstimated( bool theBool ) { mGrayMinimumMaximumEstimated = theBool; }

    void setInvertHistogram( bool theFlag ) { mInvertColor = theFlag; }

    void setRGBMinimumMaximumEstimated( bool theBool ) { mRGBMinimumMaximumEstimated = theBool; }

    void setStandardDeviations( double theStandardDeviations ) { mStandardDeviations = theStandardDeviations; }

    void setUserDefinedGrayMinimumMaximum( bool theBool ) { mUserDefinedGrayMinimumMaximum = theBool; }

    void setUserDefinedRGBMinimumMaximum( bool theBool ) { mUserDefinedRGBMinimumMaximum = theBool; }

    double standardDeviations() const { return mStandardDeviations; }

    QString transparentBandName() const { return mTransparencyBandName; }

    bool usesProvider();

    int width() { return mWidth; }

    //
    // Non Static methods
    //
    unsigned int bandCount();

    const  QString bandName( int theBandNoInt );

    int bandNumber( const QString & theBandName );

    const  QgsRasterBandStats bandStatistics( int );

    const  QgsRasterBandStats bandStatistics( const QString & );

    RasterPyramidList buildPyramidList();

    QString colorShadingAlgorithmAsString() const;

    void computeMinimumMaximumEstimates( int theBand, double* theMinMax );

    void computeMinimumMaximumEstimates( QString theBand, double* theMinMax );

    void computeMinimumMaximumEstimates( int theBand, double& theMin, double& theMax );

    void computeMinimumMaximumFromLastExtent( int theBand, double* theMinMax );

    void computeMinimumMaximumFromLastExtent( QString theBand, double* theMinMax );

    void computeMinimumMaximumFromLastExtent( int theBand, double& theMin, double& theMax );

    QgsContrastEnhancement* contrastEnhancement( unsigned int theBand );

    bool copySymbologySettings( const QgsMapLayer& theOther );

    QList<QgsColorRampShader::ColorRampItem>* colorTable( int theBandNoInt );

    QgsRasterDataProvider* dataProvider();

    const QgsRasterDataProvider* dataProvider() const;

    virtual void reload();

    bool draw( QgsRenderContext& rendererContext );

    void draw( QPainter * theQPainter,
               QgsRasterViewPort * myRasterViewPort,
               const QgsMapToPixel* theQgsMapToPixel = 0 );

    QString drawingStyleAsString() const;

    bool hasCompatibleSymbology( const QgsMapLayer& theOther ) const;

    bool hasStatistics( int theBandNoInt );

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

    QString identifyAsText( const QgsPoint & point );

    QString identifyAsHtml( const QgsPoint & point );

    bool isEditable() const;

    QString lastError();

    QString lastErrorTitle();

    QPixmap legendAsPixmap();

    QPixmap legendAsPixmap( bool );

    QPixmap legendAsPixmap( int theLabelCount );

    double maximumValue( unsigned int theBand );

    double maximumValue( QString theBand );

    QString metadata();

    double minimumValue( unsigned int theBand );

    double minimumValue( QString theBand );

    QPixmap paletteAsPixmap( int theBand = 1 );

    QString providerKey() const;

    double rasterUnitsPerPixel();

    // Keep this for QgsRasterLayerProperties
    bool readColorTable( int theBandNumber, QList<QgsColorRampShader::ColorRampItem>* theList );

    void resetNoDataValue();

    void setBlueBandName( const QString & theBandName );

    void setColorShadingAlgorithm( QgsRasterLayer::ColorShadingAlgorithm theShaderAlgorithm );

    void setColorShadingAlgorithm( QString theShaderAlgorithm );

    void setContrastEnhancementAlgorithm( QgsContrastEnhancement::ContrastEnhancementAlgorithm theAlgorithm,
                                          bool theGenerateLookupTableFlag = true );

    void setContrastEnhancementAlgorithm( QString theAlgorithm, bool theGenerateLookupTableFlag = true );

    void setContrastEnhancementFunction( QgsContrastEnhancementFunction* theFunction );

    void setDrawingStyle( const QString & theDrawingStyleQString );

    void setGrayBandName( const QString & theBandName );

    void setGreenBandName( const QString & theBandName );

    void setMaximumValue( unsigned int theBand, double theValue, bool theGenerateLookupTableFlag = true );

    void setMaximumValue( QString theBand, double theValue, bool theGenerateLookupTableFlag = true );

    void setMinimumMaximumUsingLastExtent();

    void setMinimumMaximumUsingDataset();

    void setMinimumValue( unsigned int theBand, double theValue, bool theGenerateLookupTableFlag = true );

    void setMinimumValue( QString theBand, double theValue, bool theGenerateLookupTableFlag = true );

    void setNoDataValue( double theNoData );

    void setRasterShaderFunction( QgsRasterShaderFunction* theFunction );

    void setRedBandName( const QString & theBandName );

    void setTransparentBandName( const QString & theBandName );

    void showProgress( int theValue );

    QStringList subLayers() const;

    void thumbnailAsPixmap( QPixmap * theQPixmap );
    void thumbnailAsImage( QImage * thepImage );

    void triggerRepaint();

    //
    // Virtural methods
    //
    virtual void setLayerOrder( const QStringList & layers );

    virtual void setSubLayerVisibility( const QString & name, bool vis );

    virtual QDateTime timestamp() const { return mDataProvider->timestamp() ; }

  public slots:
    QString buildPyramids( const RasterPyramidList &,
                           const QString &  theResamplingMethod = "NEAREST",
                           bool theTryInternalFlag = false );

    void populateHistogram( int theBandNoInt,
                            int theBinCountInt = 256,
                            bool theIgnoreOutOfRangeFlag = true,
                            bool theThoroughBandScanFlag = false );

    void showStatusMessage( const QString & theMessage );

    void updateProgress( int, int );

    void onProgress( int, double, QString );

  signals:
    void progressUpdate( int theValue );

    void dataChanged();

  protected:

    bool readSymbology( const QDomNode& node, QString& errorMessage );

    bool readXml( QDomNode & layer_node );

    bool writeSymbology( QDomNode&, QDomDocument& doc, QString& errorMessage ) const;

    bool writeXml( QDomNode & layer_node, QDomDocument & doc );

  private:
    //
    // Private methods
    //
    void drawSingleBandColorData( QPainter * theQPainter,
                                  QgsRasterViewPort * theRasterViewPort,
                                  const QgsMapToPixel* theQgsMapToPixel,
                                  int theBandNoInt );

    void drawMultiBandColor( QPainter * theQPainter,
                             QgsRasterViewPort * theRasterViewPort,
                             const QgsMapToPixel* theQgsMapToPixel );

    void drawMultiBandSingleBandGray( QPainter * theQPainter,
                                      QgsRasterViewPort * theRasterViewPort,
                                      const QgsMapToPixel* theQgsMapToPixel,
                                      int theBandNoInt );

    void drawMultiBandSingleBandPseudoColor( QPainter * theQPainter,
        QgsRasterViewPort * theRasterViewPort,
        const QgsMapToPixel* theQgsMapToPixel,
        int theBandNoInt );

    void drawPalettedSingleBandColor( QPainter * theQPainter,
                                      QgsRasterViewPort * theRasterViewPort,
                                      const QgsMapToPixel* theQgsMapToPixel,
                                      int theBandNoInt );

    void drawPalettedSingleBandGray( QPainter * theQPainter,
                                     QgsRasterViewPort * theRasterViewPort,
                                     const QgsMapToPixel* theQgsMapToPixel,
                                     int theBandNoInt );

    void drawPalettedSingleBandPseudoColor( QPainter * theQPainter,
                                            QgsRasterViewPort * theRasterViewPort,
                                            const QgsMapToPixel* theQgsMapToPixel,
                                            int theBandNoInt );

    void drawPalettedMultiBandColor( QPainter * theQPainter,
                                     QgsRasterViewPort * theRasterViewPort,
                                     const QgsMapToPixel* theQgsMapToPixel,
                                     int theBandNoInt );

    void drawSingleBandGray( QPainter * theQPainter,
                             QgsRasterViewPort * theRasterViewPort,
                             const QgsMapToPixel* theQgsMapToPixel,
                             int theBandNoInt );

    void drawSingleBandPseudoColor( QPainter * theQPainter,
                                    QgsRasterViewPort * theRasterViewPort,
                                    const QgsMapToPixel* theQgsMapToPixel,
                                    int theBandNoInt );

    void closeDataProvider();

    QString  generateBandName( int );

    bool hasBand( const QString &  theBandName );

    QString projectionWkt();

    //void* readData( GDALRasterBandH gdalBand, QgsRasterViewPort *viewPort );
    void* readData( int bandNo, QgsRasterViewPort *viewPort );

    bool readFile( const QString & fileName );

    //inline double readValue( void *data, GDALDataType type, int index );
    inline double readValue( void *data, int type, int index );

    bool update();

    QString validateBandName( const QString & theBandName );

    //
    // Private member vars
    //
    const QString QSTRING_NOT_SET;
    const QString TRSTRING_NOT_SET;

    int mBandCount;

    QString mBlueBandName;

    ColorShadingAlgorithm mColorShadingAlgorithm;

    QgsContrastEnhancement::ContrastEnhancementAlgorithm mContrastEnhancementAlgorithm;

    ContrastEnhancementList mContrastEnhancementList;

    double mStandardDeviations;

    QgsRasterDataProvider* mDataProvider;

    DrawingStyle mDrawingStyle;

    bool mEditable;

    QString mError;

    QString mErrorCaption;

    //GDALDatasetH mGdalBaseDataset;

    //GDALDatasetH mGdalDataset;

    double mGeoTransform[6];

    QString mGrayBandName;

    bool mGrayMinimumMaximumEstimated;

    QString mGreenBandName;

    bool mHasPyramids;

    int mWidth;

    int mHeight;

    bool mInvertColor;

    QDateTime mLastModified;

    QgsRasterViewPort mLastViewPort;

    //QLibrary* mLib;

    bool mModified;

    double mNoDataValue;

    QString mProviderKey;

    RasterPyramidList mPyramidList;

    QgsRasterShader* mRasterShader;

    RasterStatsList mRasterStatsList;

    QgsRasterTransparency mRasterTransparency;

    LayerType mRasterType;

    QString mRedBandName;

    bool mRGBMinimumMaximumEstimated;

    QString mTransparencyBandName;

    bool mUserDefinedGrayMinimumMaximum;

    bool mUserDefinedRGBMinimumMaximum;

    bool mValidNoDataValue;

    /* TODO: put everything to URI */
    QStringList mLayers;
    QStringList mStyles;
    QString mFormat;
    QString mCrs;
};

/*#include <QColor>

typedef void* GDALRasterBandH;
class QgsMapToPixel;
struct QgsRasterViewPort;
class QImage;
class QPainter;*/

class CORE_EXPORT QgsRasterImageBuffer
{
  public:
    QgsRasterImageBuffer( QgsRasterDataProvider *dataProvider, int bandNo, QPainter* p,
                          QgsRasterViewPort* viewPort, const QgsMapToPixel* mapToPixel, double* mGeoTransform );
    ~QgsRasterImageBuffer();
    void reset( int maxPixelsInVirtualMemory = 5000000 );
    bool nextScanLine( QRgb** imageScanLine, void** rasterScanLine );

    void setWritingEnabled( bool enabled ) { mWritingEnabled = enabled; }

  private:
    QgsRasterImageBuffer(); //forbidden
    bool createNextPartImage();

    void drawPixelRectangle();

    QgsRasterDataProvider* mDataProvider;
    int mBandNo;
    QPainter* mPainter;
    QgsRasterViewPort* mViewPort;
    const QgsMapToPixel* mMapToPixel;
    double* mGeoTransform;

    bool mValid;
    bool mWritingEnabled;
    bool mDrawPixelRect;
    int mCurrentRow;
    int mNumPartImages; //number of part images
    int mNumRasterRowsPerPart; //number of (raster source) rows per part
    int mCurrentPartRasterMin; //minimum (raster source) row of current image
    int mCurrentPartRasterMax; //maximum (raster source) row of current image
    int mCurrentPartImageRow; //current image row
    int mNumCurrentImageRows; //number of image rows for the current part

    int mCurrentPart;

    //current memory image and gdal scan data
    QImage* mCurrentImage;
    void* mCurrentGDALData;
};

#endif