QGIS » QGIS Application

  int memuse = width * height * 4 / 1000000;  // pixmap + image

#include "qgsrasterimagebuffer.h"

    //fetch image in several parts if it is too memory consuming

    //also some WMS servers have a pixel limit, so it's better to make several requests

    int totalPixelWidth = fabs(( myRasterViewPort->clippedXMax -  myRasterViewPort->clippedXMin )

                               / theQgsMapToPixel.mapUnitsPerPixel() * mGeoTransform[1] ) + 1;

    int totalPixelHeight = fabs(( myRasterViewPort->clippedYMax -  myRasterViewPort->clippedYMin )

                               / theQgsMapToPixel.mapUnitsPerPixel() * mGeoTransform[5] ) + 1;

    int numParts = totalPixelWidth * totalPixelHeight / 2000000 + 1.0;

    int numRowsPerPart = totalPixelHeight / numParts + 1.0;

    int currentPixelOffsetY = 0; //top y-coordinate of current raster part

    //the width of a WMS image part

    int pixelWidth = (myRasterExtent.xMaximum() - myRasterExtent.xMinimum()) / theQgsMapToPixel.mapUnitsPerPixel();

    for(int i = 0; i < numParts; ++i)

      //fetch a small overlap of 2 pixels between two adjacent tiles to avoid white stripes

      QgsRectangle rasterPartRect(myRasterExtent.xMinimum(), myRasterExtent.yMaximum() - (currentPixelOffsetY + numRowsPerPart + 2) * theQgsMapToPixel.mapUnitsPerPixel(), \

                                  myRasterExtent.xMaximum(), myRasterExtent.yMaximum() - currentPixelOffsetY * theQgsMapToPixel.mapUnitsPerPixel());

      int pixelHeight = rasterPartRect.height() / theQgsMapToPixel.mapUnitsPerPixel();

      QImage* image = mDataProvider->draw(rasterPartRect, pixelWidth, pixelHeight);

      if ( !image )

      {

        // An error occurred.

        mErrorCaption = mDataProvider->lastErrorTitle();

        mError        = mDataProvider->lastError();

        delete myRasterViewPort;

        return FALSE;

      }

      QgsDebugMsg( "Done mDataProvider->draw." );

      QgsDebugMsg( "image stats: " );

      QgsDebugMsg( QString( "depth=%1" ).arg( image->depth() ) );

      QgsDebugMsg( QString( "bytes=%1" ).arg( image->numBytes() ) );

      QgsDebugMsg( QString( "width=%1" ).arg( image->width() ) );

      QgsDebugMsg( QString( "height=%1" ).arg( image->height() ) );

      QgsDebugMsg( "Want to theQPainter->drawImage with" );

      QgsDebugMsg( QString( "origin x: %1" ).arg( myRasterViewPort->topLeftPoint.x() ) );

      QgsDebugMsg( QString( "(int)origin x: %1" ).arg( static_cast<int>( myRasterViewPort->topLeftPoint.x() ) ) );

      QgsDebugMsg( QString( "origin y: %1" ).arg( myRasterViewPort->topLeftPoint.y() ) );

      QgsDebugMsg( QString( "(int)origin y: %1" ).arg( static_cast<int>( myRasterViewPort->topLeftPoint.y() ) ) );

      //Set the transparency for the whole layer

      //QImage::setAlphaChannel does not work quite as expected so set each pixel individually

      //Currently this is only done for WMS images, which should be small enough not to impact performance

      if ( mTransparencyLevel != 255 ) //improve performance if layer transparency not altered

        QImage* transparentImageCopy = new QImage( *image ); //copy image if there is user transparency

        image = transparentImageCopy;

        int myWidth = image->width();

        int myHeight = image->height();

        QRgb myRgb;

        int newTransparency;

        for ( int myHeightRunner = 0; myHeightRunner < myHeight; myHeightRunner++ )

          QRgb* myLineBuffer = ( QRgb* ) transparentImageCopy->scanLine( myHeightRunner );

          for ( int myWidthRunner = 0; myWidthRunner < myWidth; myWidthRunner++ )

          {

            myRgb = image->pixel( myWidthRunner, myHeightRunner );

            //combine transparency from WMS and layer transparency

            newTransparency = ( double ) mTransparencyLevel / 255.0 * ( double )( qAlpha( myRgb ) );

            myLineBuffer[ myWidthRunner ] = qRgba( qRed( myRgb ), qGreen( myRgb ), qBlue( myRgb ), newTransparency );

          }

      theQPainter->drawImage(myRasterViewPort->topLeftPoint.x(), myRasterViewPort->topLeftPoint.y() + currentPixelOffsetY, *image);

      currentPixelOffsetY += numRowsPerPart;

          if ( mTransparencyLevel != 255 )

      {

        delete image;

      }

      emit statusChanged( tr( "%1 retrieved using %2" ).arg( name() ).arg( mProviderKey ) );

  if ( mProviderKey.isEmpty() && hasBand( "Palette" ) && theBandNumber > 0 ) //don't tr() this its a gdal word!

  //we assume that it only needs to be calculated if the length of the histogram

    //TODO: Remove the customColorRampType check and following if() in v2.0, added for compatibility with older ( bugged ) project files

  QgsRasterImageBuffer imageBuffer( myGdalBand, theQPainter, theRasterViewPort, theQgsMapToPixel, &mGeoTransform[0] );

  imageBuffer.reset();

  QRgb* imageScanLine = 0;

  void* rasterScanLine = 0;

  QRgb myDefaultColor = qRgba( 255, 255, 255, 0 );

  double myPixelValue = 0.0;

  int myRedValue = 0;

  int myGreenValue = 0;

  int myBlueValue = 0;

  int myAlphaValue = 0;

  while( imageBuffer.nextScanLine( &imageScanLine, &rasterScanLine ) )

  {

    for( int i = 0; i < theRasterViewPort->drawableAreaXDim; ++i )

    {

        myRedValue = 0; myGreenValue = 0; myBlueValue = 0;

        myPixelValue = readValue( rasterScanLine, ( GDALDataType )myDataType, i);

        if ( mValidNoDataValue && ( fabs( myPixelValue - mNoDataValue ) <= TINY_VALUE || myPixelValue != myPixelValue ) )

        {

            imageScanLine[ i ] = myDefaultColor;

            continue;

        }

        myAlphaValue = mRasterTransparency.alphaValue( myPixelValue, mTransparencyLevel );

        if ( 0 == myAlphaValue )

        {

            imageScanLine[ i ] = myDefaultColor;

            continue;

        }

        if ( !mRasterShader->shade( myPixelValue, &myRedValue, &myGreenValue, &myBlueValue ) )

        {

            imageScanLine[ i ] = myDefaultColor;

            continue;

        }

        if ( mInvertColor )

        {

            //Invert flag, flip blue and read

            imageScanLine[ i ] = qRgba( myBlueValue, myGreenValue, myRedValue, myAlphaValue );

        }

        else

        {

            //Normal

            imageScanLine[ i ] = qRgba( myRedValue, myGreenValue, myBlueValue, myAlphaValue );

        }

    }

  }

#if 0

#endif //0

  else if ( hasBand( "Palette" ) ) //don't tr() this its a gdal word!

/***************************************************************************

    qgsrasterimagebuffer.cpp

    ------------------------

    begin                : December 2009

    copyright            : (C) 2009 by Marco Hugentobler

    email                : marco at hugis 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.                                   *

 *                                                                         *

 ***************************************************************************/

#include "qgsrasterimagebuffer.h"

#include "qgsmaptopixel.h"

#include "qgsrasterviewport.h"

#include <QImage>

#include <QPainter>

#include <gdal.h>

#include "cpl_conv.h"

#ifndef Q_OS_MACX

#include <cmath>

#else

#include <math.h>

#endif

QgsRasterImageBuffer::QgsRasterImageBuffer(GDALRasterBandH rasterBand, QPainter* p, QgsRasterViewPort* viewPort, const QgsMapToPixel* mapToPixel, double* geoTransform): \

mRasterBand(rasterBand), mPainter(p), mViewPort(viewPort), mMapToPixel(mapToPixel), mValid(false), mCurrentImage(0), mCurrentGDALData(0), mGeoTransform(geoTransform)

{

}

QgsRasterImageBuffer::~QgsRasterImageBuffer()

{

    delete mCurrentImage;

    CPLFree(mCurrentGDALData);

}

void QgsRasterImageBuffer::reset()

{

    if( mRasterBand && mPainter && mViewPort && mMapToPixel )

    {

        mValid = true;

    }

    else

    {

        mValid = false;

        return;

    }

    //decide on the partition of the image

    int pixels = mViewPort->drawableAreaXDim * mViewPort->drawableAreaYDim;

    int mNumPartImages = std::max(pixels / 50000000.0, 1.0);

    mNumRasterRowsPerPart = (double)mViewPort->clippedHeight / (double)mNumPartImages + 0.5;

    mCurrentPartRasterMin = -1;

    mCurrentPartRasterMax = -1;

    mCurrentPartImageRow = 0;

    mNumCurrentImageRows = 0;

    createNextPartImage();

}

bool QgsRasterImageBuffer::nextScanLine(QRgb** imageScanLine, void** rasterScanLine)

{

    if(!mValid)

    {

        return false;

    }

    if( !mCurrentGDALData || ! mCurrentImage )

    {

        return false;

    }

    if(mCurrentPartImageRow >= (mNumCurrentImageRows))

    {

        if(!createNextPartImage())

        {

            return false;

        }

    }

    *imageScanLine = ( QRgb* )(mCurrentImage->scanLine(mCurrentPartImageRow));

    GDALDataType type = GDALGetRasterDataType( mRasterBand );

    int size = GDALGetDataTypeSize( type ) / 8;

    *rasterScanLine = mCurrentGDALData + mCurrentPartImageRow * mViewPort->drawableAreaXDim * size;

    ++mCurrentPartImageRow;

    ++mCurrentRow;

    return true;

}

bool QgsRasterImageBuffer::createNextPartImage()

{

    //draw the last image if mCurrentImage if it exists

    if(mCurrentImage)

    {

        double xLeft = mViewPort->topLeftPoint.x();

        double yTop = mViewPort->topLeftPoint.y() + fabs(mGeoTransform[5]) * mCurrentPartRasterMin / mMapToPixel->mapUnitsPerPixel();

        mPainter->drawImage(QPointF(xLeft, yTop), *mCurrentImage);

    }

    delete mCurrentImage; mCurrentImage = 0;

    CPLFree(mCurrentGDALData); mCurrentGDALData = 0;

    if(mCurrentPartRasterMax >= mViewPort->clippedHeight)

    {

        return false; //already at the end...

    }

    mCurrentPartRasterMin = mCurrentPartRasterMax + 1;

    mCurrentPartRasterMax = mCurrentPartRasterMin + mNumRasterRowsPerPart;

    if(mCurrentPartRasterMax > mViewPort->clippedHeight)

    {

        mCurrentPartRasterMax = mViewPort->clippedHeight;

    }

    mCurrentRow = mCurrentPartRasterMin;

    mCurrentPartImageRow = 0;

    //read GDAL image data

    GDALDataType type = GDALGetRasterDataType( mRasterBand );

    int size = GDALGetDataTypeSize( type ) / 8;

    int xSize = mViewPort->drawableAreaXDim;

    //make the raster tiles overlap at least 2 pixels to avoid white stripes

    int overlapRows = 0;

    overlapRows = mMapToPixel->mapUnitsPerPixel() / fabs(mGeoTransform[5]) + 2;

    if(mCurrentPartRasterMax + overlapRows >= mViewPort->clippedHeight)

    {

      overlapRows = 0;

    }

    int rasterYSize = mCurrentPartRasterMax - mCurrentPartRasterMin + overlapRows;

    int ySize = fabs(( (rasterYSize) / mMapToPixel->mapUnitsPerPixel() * mGeoTransform[5] ) ) + 0.5;

    if(ySize == 0)

    {

      return false;

    }

    mNumCurrentImageRows = ySize;

    mCurrentGDALData = VSIMalloc(size * xSize * ySize);

    CPLErr myErr = GDALRasterIO( mRasterBand, GF_Read, mViewPort->rectXOffset, \

                       mViewPort->rectYOffset + mCurrentRow, mViewPort->clippedWidth, rasterYSize, \

                       mCurrentGDALData, xSize, ySize, type, 0, 0);

    if ( myErr != CPLE_None )

    {

        CPLFree(mCurrentGDALData);

        mCurrentGDALData = 0;

        return false;

    }

    //create the QImage

    mCurrentImage = new QImage( xSize, ySize, QImage::Format_ARGB32 );

    mCurrentImage->fill(qRgba(255, 255, 255, 0));

    return true;

}

/***************************************************************************

    qgsrasterimagebuffer.h

    ---------------------

    begin                : December 2009

    copyright            : (C) 2009 by Marco Hugentobler

    email                : marco at hugis 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.                                   *

 *                                                                         *

 ***************************************************************************/

#ifndef QGSRASTERIMAGEBUFFER_H

#define QGSRASTERIMAGEBUFFER_H

#include <QColor>

typedef void* GDALRasterBandH;

class QgsMapToPixel;

struct QgsRasterViewPort;

class QImage;

class QPainter;

/**A class encapsulates reading from a raster band and drawing the pixels to a painter.

   The class allows sequential reading of the scan lines and setting the image scan line pixels. It automatically decides

   on how much of the band / image should stay in virtual memory at a time*/

class QgsRasterImageBuffer

{

    public:

        QgsRasterImageBuffer(GDALRasterBandH rasterBand, QPainter* p, \

                             QgsRasterViewPort* viewPort, const QgsMapToPixel* mapToPixel, double* mGeoTransform);

        ~QgsRasterImageBuffer();

        void reset();

        /**Returns a pointer to the next scan line (or 0 if end)*/

        bool nextScanLine(QRgb** imageScanLine, void** rasterScanLine);

    private:

        QgsRasterImageBuffer(); //forbidden

        /**Creates next part image. Returns false if at end*/

        bool createNextPartImage();

        GDALRasterBandH mRasterBand; //raster band

        QPainter* mPainter;

        QgsRasterViewPort* mViewPort;

        const QgsMapToPixel* mMapToPixel;

        double* mGeoTransform;

        bool mValid;

        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

        //current memory image and gdal scan data

        QImage* mCurrentImage;

        void* mCurrentGDALData;

};

#endif // QGSRASTERIMAGEBUFFER_H

  raster/qgsrasterimagebuffer.cpp