qgsrasterblock.h

Go to the documentation of this file.

/***************************************************************************
    qgsrasterblock.h - Class representing a block of raster data
     --------------------------------------
    Date                 : Oct 9, 2012
    Copyright            : (C) 2012 by Radim Blazek
    email                : radim dot blazek at gmail dot com
 ***************************************************************************/

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

#ifndef QGSRASTERBLOCK_H
#define QGSRASTERBLOCK_H

#include <limits>
#include <QImage>
#include "qgis.h"
#include "qgserror.h"
#include "qgslogger.h"
#include "qgsrasterrange.h"
#include "qgsrectangle.h"

class CORE_EXPORT QgsRasterBlock
{
  public:
    QgsRasterBlock();

    QgsRasterBlock( QGis::DataType theDataType, int theWidth, int theHeight );

    QgsRasterBlock( QGis::DataType theDataType, int theWidth, int theHeight, double theNoDataValue );

    virtual ~QgsRasterBlock();

    bool reset( QGis::DataType theDataType, int theWidth, int theHeight );

    bool reset( QGis::DataType theDataType, int theWidth, int theHeight, double theNoDataValue );

    // TODO: consider if use isValid() at all, isEmpty() should be sufficient
    // and works also if block is valid but empty - difference between valid and empty?
    bool isValid() const { return mValid; }

    void setValid( bool valid ) { mValid = valid; }

    bool isEmpty() const;

    // Return data type size in bytes
    static int typeSize( int dataType )
    {
      // Modified and extended copy from GDAL
      switch ( dataType )
      {
        case QGis::Byte:
          return 1;

        case QGis::UInt16:
        case QGis::Int16:
          return 2;

        case QGis::UInt32:
        case QGis::Int32:
        case QGis::Float32:
        case QGis::CInt16:
          return 4;

        case QGis::Float64:
        case QGis::CInt32:
        case QGis::CFloat32:
          return 8;

        case QGis::CFloat64:
          return 16;

        case QGis::ARGB32:
        case QGis::ARGB32_Premultiplied:
          return 4;

        default:
          return 0;
      }
    }

    // Data type in bytes
    int dataTypeSize() const
    {
      return typeSize( mDataType );
    }

    static bool typeIsNumeric( QGis::DataType type );

    static bool typeIsColor( QGis::DataType type );

    QGis::DataType dataType() const { return mDataType; }

    static QGis::DataType typeWithNoDataValue( QGis::DataType dataType, double *noDataValue );

    bool hasNoDataValue() const { return mHasNoDataValue; }

    bool hasNoData() const;

    double noDataValue() const { return mNoDataValue; }

    static QByteArray valueBytes( QGis::DataType theDataType, double theValue );

    double value( int row, int column ) const;

    double value( qgssize index ) const;

    QRgb color( int row, int column ) const;

    QRgb color( qgssize index ) const;

    bool isNoData( int row, int column );

    bool isNoData( qgssize index );

    bool setValue( int row, int column, double value );

    bool setValue( qgssize index, double value );

    bool setColor( int row, int column, QRgb color );

    bool setColor( qgssize index, QRgb color );

    bool setIsNoData( int row, int column );

    bool setIsNoData( qgssize index );

    bool setIsNoData();

    bool setIsNoDataExcept( QRect theExceptRect );

    void setIsData( int row, int column );

    void setIsData( qgssize index );

    char * bits( int row, int column );

    char * bits( qgssize index );

    char * bits();

    static QString printValue( double value );

    static QString printValue( float value );

    bool convert( QGis::DataType destDataType );

    QImage image() const;

    bool setImage( const QImage * image );

    inline static double readValue( void *data, QGis::DataType type, qgssize index );

    inline static void writeValue( void *data, QGis::DataType type, qgssize index, double value );

    void applyNoDataValues( const QgsRasterRangeList & rangeList );

    void applyScaleOffset( double scale, double offset );

    QgsError error() const { return mError; }

    void setError( const QgsError & theError ) { mError = theError;}

    QString toString() const;

    static QRect subRect( const QgsRectangle &theExtent, int theWidth, int theHeight, const QgsRectangle &theSubExtent );

    int width() const { return mWidth; }

    int height() const { return mHeight; }

  private:
    static QImage::Format imageFormat( QGis::DataType theDataType );
    static QGis::DataType dataType( QImage::Format theFormat );

    static bool isNoDataValue( double value, double noDataValue );

    bool isNoDataValue( double value ) const;

    bool createNoDataBitmap();

    static void * convert( void *srcData, QGis::DataType srcDataType, QGis::DataType destDataType, qgssize size );

    // Valid
    bool mValid;

    // Data type
    QGis::DataType mDataType;

    // Data type size in bytes, to make bits() fast
    int mTypeSize;

    // Width
    int mWidth;

    // Height
    int mHeight;

    // Has no data value
    bool mHasNoDataValue;

    // No data value
    double mNoDataValue;

    static const QRgb mNoDataColor;

    // Data block for numerical data types, not used with image data types
    // QByteArray does not seem to be intended for large data blocks, does it?
    void * mData;

    // Image for image data types, not used with numerical data types
    QImage *mImage;

    // Bitmap of no data. One bit for each pixel. Bit is 1 if a pixels is no data.
    // Each row is represented by whole number of bytes (last bits may be unused)
    // to make processing rows easy.
    char *mNoDataBitmap;

    // number of bytes in mNoDataBitmap row
    int mNoDataBitmapWidth;

    // total size in bytes of mNoDataBitmap
    qgssize mNoDataBitmapSize;

    // Error
    QgsError mError;
};

inline double QgsRasterBlock::readValue( void *data, QGis::DataType type, qgssize index )
{
  if ( !data )
  {
    return std::numeric_limits<double>::quiet_NaN();
  }

  switch ( type )
  {
    case QGis::Byte:
      return static_cast< double >(( static_cast< quint8 * >( data ) )[index] );
      break;
    case QGis::UInt16:
      return static_cast< double >(( static_cast< quint16 * >( data ) )[index] );
      break;
    case QGis::Int16:
      return static_cast< double >(( static_cast< qint16 * >( data ) )[index] );
      break;
    case QGis::UInt32:
      return static_cast< double >(( static_cast< quint32 * >( data ) )[index] );
      break;
    case QGis::Int32:
      return static_cast< double >(( static_cast< qint32 * >( data ) )[index] );
      break;
    case QGis::Float32:
      return static_cast< double >(( static_cast< float * >( data ) )[index] );
      break;
    case QGis::Float64:
      return static_cast< double >(( static_cast< double * >( data ) )[index] );
      break;
    default:
      QgsDebugMsg( QString( "Data type %1 is not supported" ).arg( type ) );
      break;
  }

  return std::numeric_limits<double>::quiet_NaN();
}

inline void QgsRasterBlock::writeValue( void *data, QGis::DataType type, qgssize index, double value )
{
  if ( !data ) return;

  switch ( type )
  {
    case QGis::Byte:
      ( static_cast< quint8 * >( data ) )[index] = static_cast< quint8 >( value );
      break;
    case QGis::UInt16:
      ( static_cast< quint16 * >( data ) )[index] =  static_cast< quint16 >( value );
      break;
    case QGis::Int16:
      ( static_cast< qint16 * >( data ) )[index] =  static_cast< qint16 >( value );
      break;
    case QGis::UInt32:
      ( static_cast< quint32 * >( data ) )[index] =  static_cast< quint32 >( value );
      break;
    case QGis::Int32:
      ( static_cast< qint32 * >( data ) )[index] =  static_cast< qint32 >( value );
      break;
    case QGis::Float32:
      ( static_cast< float * >( data ) )[index] = static_cast< float >( value );
      break;
    case QGis::Float64:
      ( static_cast< double * >( data ) )[index] = value;
      break;
    default:
      QgsDebugMsg( QString( "Data type %1 is not supported" ).arg( type ) );
      break;
  }
}

inline double QgsRasterBlock::value( qgssize index ) const
{
  if ( !mData )
  {
    QgsDebugMsg( "Data block not allocated" );
    return std::numeric_limits<double>::quiet_NaN();
  }
  return readValue( mData, mDataType, index );
}

inline bool QgsRasterBlock::isNoDataValue( double value ) const
{
  return qIsNaN( value ) || qgsDoubleNear( value, mNoDataValue );
}

#endif