// Default implementation for values
QMap<int, QVariant> QgsRasterDataProvider::identify( const QgsPoint & thePoint, IdentifyFormat theFormat, const QgsRectangle &theExtent, int theWidth, int theHeight )
{
QgsDebugMsg( "Entered" );
QMap<int, QVariant> results;
if ( theFormat != IdentifyFormatValue || !( capabilities() & IdentifyValue ) )
{
QgsDebugMsg( "Format not supported" );
return results;
}
if ( !extent().contains( thePoint ) )
{
// Outside the raster
for ( int bandNo = 1; bandNo <= bandCount(); bandNo++ )
{
results.insert( bandNo, noDataValue( bandNo ) );
}
return results;
}
QgsRectangle myExtent = theExtent;
if ( myExtent.isEmpty() ) myExtent = extent();
if ( theWidth == 0 )
{
theWidth = capabilities() & Size ? xSize() : 1000;
}
if ( theHeight == 0 )
{
theHeight = capabilities() & Size ? ySize() : 1000;
}
// Calculate the row / column where the point falls
double xres = ( myExtent.width() ) / theWidth;
double yres = ( myExtent.height() ) / theHeight;
int col = ( int ) floor(( thePoint.x() - myExtent.xMinimum() ) / xres );
int row = ( int ) floor(( myExtent.yMaximum() - thePoint.y() ) / yres );
double xMin = myExtent.xMinimum() + col * xres;
double xMax = xMin + xres;
double yMax = myExtent.yMaximum() - row * yres;
double yMin = yMax - yres;
QgsRectangle pixelExtent( xMin, yMin, xMax, yMax );
for ( int i = 1; i <= bandCount(); i++ )
{
QgsRasterBlock * myBlock = block( i, pixelExtent, 1, 1 );
double value = noDataValue( i );
if ( myBlock ) value = myBlock->value( 0 );
results.insert( i, value );
}
return results;
}
void QgsZonalStatistics::statisticsFromMiddlePointTest( const QgsGeometry &poly, int pixelOffsetX,
int pixelOffsetY, int nCellsX, int nCellsY, double cellSizeX, double cellSizeY, const QgsRectangle &rasterBBox, FeatureStats &stats )
{
double cellCenterX, cellCenterY;
cellCenterY = rasterBBox.yMaximum() - pixelOffsetY * cellSizeY - cellSizeY / 2;
stats.reset();
GEOSGeometry *polyGeos = poly.exportToGeos();
if ( !polyGeos )
{
return;
}
GEOSContextHandle_t geosctxt = QgsGeometry::getGEOSHandler();
const GEOSPreparedGeometry *polyGeosPrepared = GEOSPrepare_r( geosctxt, polyGeos );
if ( !polyGeosPrepared )
{
GEOSGeom_destroy_r( geosctxt, polyGeos );
return;
}
GEOSCoordSequence *cellCenterCoords = nullptr;
GEOSGeometry *currentCellCenter = nullptr;
QgsRectangle featureBBox = poly.boundingBox().intersect( &rasterBBox );
QgsRectangle intersectBBox = rasterBBox.intersect( &featureBBox );
QgsRasterBlock *block = mRasterProvider->block( mRasterBand, intersectBBox, nCellsX, nCellsY );
for ( int i = 0; i < nCellsY; ++i )
{
cellCenterX = rasterBBox.xMinimum() + pixelOffsetX * cellSizeX + cellSizeX / 2;
for ( int j = 0; j < nCellsX; ++j )
{
if ( validPixel( block->value( i, j ) ) )
{
GEOSGeom_destroy_r( geosctxt, currentCellCenter );
cellCenterCoords = GEOSCoordSeq_create_r( geosctxt, 1, 2 );
GEOSCoordSeq_setX_r( geosctxt, cellCenterCoords, 0, cellCenterX );
GEOSCoordSeq_setY_r( geosctxt, cellCenterCoords, 0, cellCenterY );
currentCellCenter = GEOSGeom_createPoint_r( geosctxt, cellCenterCoords );
if ( GEOSPreparedContains_r( geosctxt, polyGeosPrepared, currentCellCenter ) )
{
stats.addValue( block->value( i, j ) );
}
}
cellCenterX += cellSizeX;
}
cellCenterY -= cellSizeY;
}
GEOSGeom_destroy_r( geosctxt, currentCellCenter );
GEOSPreparedGeom_destroy_r( geosctxt, polyGeosPrepared );
GEOSGeom_destroy_r( geosctxt, polyGeos );
delete block;
}
void QgsZonalStatistics::statisticsFromPreciseIntersection( const QgsGeometry &poly, int pixelOffsetX,
int pixelOffsetY, int nCellsX, int nCellsY, double cellSizeX, double cellSizeY, const QgsRectangle &rasterBBox, FeatureStats &stats )
{
stats.reset();
double currentY = rasterBBox.yMaximum() - pixelOffsetY * cellSizeY - cellSizeY / 2;
QgsGeometry pixelRectGeometry;
double hCellSizeX = cellSizeX / 2.0;
double hCellSizeY = cellSizeY / 2.0;
double pixelArea = cellSizeX * cellSizeY;
double weight = 0;
QgsRectangle featureBBox = poly.boundingBox().intersect( &rasterBBox );
QgsRectangle intersectBBox = rasterBBox.intersect( &featureBBox );
QgsRasterBlock *block = mRasterProvider->block( mRasterBand, intersectBBox, nCellsX, nCellsY );
for ( int i = 0; i < nCellsY; ++i )
{
double currentX = rasterBBox.xMinimum() + cellSizeX / 2.0 + pixelOffsetX * cellSizeX;
for ( int j = 0; j < nCellsX; ++j )
{
if ( !validPixel( block->value( i, j ) ) )
{
continue;
}
pixelRectGeometry = QgsGeometry::fromRect( QgsRectangle( currentX - hCellSizeX, currentY - hCellSizeY, currentX + hCellSizeX, currentY + hCellSizeY ) );
if ( !pixelRectGeometry.isNull() )
{
//intersection
QgsGeometry intersectGeometry = pixelRectGeometry.intersection( poly );
if ( !intersectGeometry.isNull() )
{
double intersectionArea = intersectGeometry.area();
if ( intersectionArea >= 0.0 )
{
weight = intersectionArea / pixelArea;
stats.addValue( block->value( i, j ), weight );
}
}
pixelRectGeometry = QgsGeometry();
}
currentX += cellSizeX;
}
currentY -= cellSizeY;
}
delete block;
}
static QByteArray _readDtmData( QgsRasterDataProvider *provider, const QgsRectangle &extent, int res )
{
QElapsedTimer t;
t.start();
// TODO: use feedback object? (but GDAL currently does not support cancelation anyway)
QgsRasterBlock *block = provider->block( 1, extent, res, res );
QByteArray data;
if ( block )
{
block->convert( Qgis::Float32 ); // currently we expect just floats
data = block->data();
data.detach(); // this should make a deep copy
delete block;
}
return data;
}
bool QgsRasterCalcNode::calculate( QMap<QString, QgsRasterMatrix*>& rasterData, QgsRasterMatrix& result ) const
{
//deprecated method
//convert QgsRasterMatrix to QgsRasterBlock and call replacement method
QMap<QString, QgsRasterBlock* > rasterBlockData;
QMap<QString, QgsRasterMatrix*>::const_iterator it = rasterData.constBegin();
for ( ; it != rasterData.constEnd(); ++it )
{
QgsRasterBlock* block = new QgsRasterBlock( QGis::Float32, it.value()->nColumns(), it.value()->nRows(), it.value()->nodataValue() );
for ( int row = 0; row < it.value()->nRows(); ++row )
{
for ( int col = 0; col < it.value()->nColumns(); ++col )
{
block->setValue( row, col, it.value()->data()[ row * it.value()->nColumns() + col ] );
}
}
rasterBlockData.insert( it.key(), block );
}
return calculate( rasterBlockData, result );
}
QgsRasterBlock * QgsRasterNuller::block( int bandNo, QgsRectangle const & extent, int width, int height )
{
QgsDebugMsg( "Entered" );
QgsRasterBlock *outputBlock = new QgsRasterBlock();
if ( !mInput )
{
return outputBlock;
}
//void * rasterData = mInput->block( bandNo, extent, width, height );
QgsRasterBlock *inputBlock = mInput->block( bandNo, extent, width, height );
// Input may be without no data value
//double noDataValue = mInput->noDataValue( bandNo );
double noDataValue = mOutputNoData;
for ( int i = 0; i < height; i++ )
{
for ( int j = 0; j < width; j++ )
{
//int index = i * width + j;
//double value = readValue( rasterData, dataType, index );
double value = inputBlock->value( i, j );
foreach ( NoData noData, mNoData )
{
if (( value >= noData.min && value <= noData.max ) ||
doubleNear( value, noData.min ) ||
doubleNear( value, noData.max ) )
{
inputBlock->setValue( i, j, noDataValue );
}
}
}
}
return inputBlock;
}
float QgsDemHeightMapGenerator::heightAt( double x, double y )
{
// TODO: this is quite a primitive implementation: better to use heightmaps currently in use
int res = 1024;
QgsRectangle rect = mDtm->extent();
if ( mDtmCoarseData.isEmpty() )
{
QgsRasterBlock *block = mDtm->dataProvider()->block( 1, rect, res, res );
block->convert( Qgis::Float32 );
mDtmCoarseData = block->data();
mDtmCoarseData.detach(); // make a deep copy
delete block;
}
int cellX = ( int )( ( x - rect.xMinimum() ) / rect.width() * res + .5f );
int cellY = ( int )( ( rect.yMaximum() - y ) / rect.height() * res + .5f );
cellX = qBound( 0, cellX, res - 1 );
cellY = qBound( 0, cellY, res - 1 );
const float *data = ( const float * ) mDtmCoarseData.constData();
return data[cellX + cellY * res];
}
QByteArray QgsDemHeightMapGenerator::renderSynchronously( int x, int y, int z )
{
// extend the rect by half-pixel on each side? to get the values in "corners"
QgsRectangle extent = mTilingScheme.tileToExtent( x, y, z );
float mapUnitsPerPixel = extent.width() / mResolution;
extent.grow( mapUnitsPerPixel / 2 );
// but make sure not to go beyond the full extent (returns invalid values)
QgsRectangle fullExtent = mTilingScheme.tileToExtent( 0, 0, 0 );
extent = extent.intersect( &fullExtent );
QgsRasterBlock *block = mDtm->dataProvider()->block( 1, extent, mResolution, mResolution );
QByteArray data;
if ( block )
{
block->convert( Qgis::Float32 ); // currently we expect just floats
data = block->data();
data.detach(); // this should make a deep copy
delete block;
}
return data;
}
QgsRasterBlock* QgsSingleBandColorDataRenderer::block( int bandNo, QgsRectangle const & extent, int width, int height, QgsRasterBlockFeedback* feedback )
{
Q_UNUSED( bandNo );
QgsRasterBlock *outputBlock = new QgsRasterBlock();
if ( !mInput )
{
return outputBlock;
}
QgsRasterBlock *inputBlock = mInput->block( mBand, extent, width, height, feedback );
if ( !inputBlock || inputBlock->isEmpty() )
{
QgsDebugMsg( "No raster data!" );
delete inputBlock;
return outputBlock;
}
bool hasTransparency = usesTransparency();
if ( !hasTransparency )
{
// Nothing to do, just retype if necessary
inputBlock->convert( Qgis::ARGB32_Premultiplied );
delete outputBlock;
return inputBlock;
}
if ( !outputBlock->reset( Qgis::ARGB32_Premultiplied, width, height ) )
{
delete inputBlock;
return outputBlock;
}
// make sure input is also premultiplied!
inputBlock->convert( Qgis::ARGB32_Premultiplied );
QRgb* inputBits = ( QRgb* )inputBlock->bits();
QRgb* outputBits = ( QRgb* )outputBlock->bits();
for ( qgssize i = 0; i < ( qgssize )width*height; i++ )
{
QRgb c = inputBits[i];
outputBits[i] = qRgba( mOpacity * qRed( c ), mOpacity * qGreen( c ), mOpacity * qBlue( c ), mOpacity * qAlpha( c ) );
}
delete inputBlock;
return outputBlock;
}
QgsRasterBlock* QgsSingleBandColorDataRenderer::block( int bandNo, QgsRectangle const & extent, int width, int height )
{
Q_UNUSED( bandNo );
QgsRasterBlock *outputBlock = new QgsRasterBlock();
if ( !mInput )
{
return outputBlock;
}
QgsRasterBlock *inputBlock = mInput->block( mBand, extent, width, height );
if ( !inputBlock || inputBlock->isEmpty() )
{
QgsDebugMsg( "No raster data!" );
delete inputBlock;
return outputBlock;
}
bool hasTransparency = usesTransparency();
if ( !hasTransparency )
{
// Nothing to do, just retype if necessary
inputBlock->convert( QgsRasterBlock::ARGB32_Premultiplied );
delete outputBlock;
return inputBlock;
}
if ( !outputBlock->reset( QgsRasterBlock::ARGB32_Premultiplied, width, height ) )
{
delete inputBlock;
return outputBlock;
}
for ( size_t i = 0; i < ( size_t )width*height; i++ )
{
QRgb pixelColor;
double alpha = 255.0;
QRgb c = inputBlock->color( i );
alpha = qAlpha( c );
pixelColor = qRgba( mOpacity * qRed( c ), mOpacity * qGreen( c ), mOpacity * qBlue( c ), mOpacity * alpha );
outputBlock->setColor( i, pixelColor );
}
delete inputBlock;
return outputBlock;
}
bool QgsGrassRasterImport::import()
{
QgsDebugMsg( "entered" );
if ( !mPipe )
{
setError( "Pipe is null." );
return false;
}
QgsRasterDataProvider * provider = mPipe->provider();
if ( !provider )
{
setError( "Pipe has no provider." );
return false;
}
if ( !provider->isValid() )
{
setError( "Provider is not valid." );
return false;
}
int redBand = 0;
int greenBand = 0;
int blueBand = 0;
for ( int band = 1; band <= provider->bandCount(); band++ )
{
QgsDebugMsg( QString( "band = %1" ).arg( band ) );
int colorInterpretation = provider->colorInterpretation( band );
if ( colorInterpretation == QgsRaster::RedBand )
{
redBand = band;
}
else if ( colorInterpretation == QgsRaster::GreenBand )
{
greenBand = band;
}
else if ( colorInterpretation == QgsRaster::BlueBand )
{
blueBand = band;
}
QGis::DataType qgis_out_type = QGis::UnknownDataType;
RASTER_MAP_TYPE data_type = -1;
switch ( provider->dataType( band ) )
{
case QGis::Byte:
case QGis::UInt16:
case QGis::Int16:
case QGis::UInt32:
case QGis::Int32:
qgis_out_type = QGis::Int32;
break;
case QGis::Float32:
qgis_out_type = QGis::Float32;
break;
case QGis::Float64:
qgis_out_type = QGis::Float64;
break;
case QGis::ARGB32:
case QGis::ARGB32_Premultiplied:
qgis_out_type = QGis::Int32; // split to multiple bands?
break;
case QGis::CInt16:
case QGis::CInt32:
case QGis::CFloat32:
case QGis::CFloat64:
case QGis::UnknownDataType:
setError( tr( "Data type %1 not supported" ).arg( provider->dataType( band ) ) );
return false;
}
QgsDebugMsg( QString( "data_type = %1" ).arg( data_type ) );
QString module = QgsGrass::qgisGrassModulePath() + "/qgis.r.in";
QStringList arguments;
QString name = mGrassObject.name();
if ( provider->bandCount() > 1 )
{
// raster.<band> to keep in sync with r.in.gdal
name += QString( ".%1" ).arg( band );
}
arguments.append( "output=" + name ); // get list of all output names
QTemporaryFile gisrcFile;
QProcess* process = 0;
try
{
process = QgsGrass::startModule( mGrassObject.gisdbase(), mGrassObject.location(), mGrassObject.mapset(), module, arguments, gisrcFile );
}
catch ( QgsGrass::Exception &e )
{
setError( e.what() );
return false;
}
QDataStream outStream( process );
outStream << mExtent << ( qint32 )mXSize << ( qint32 )mYSize;
outStream << ( qint32 )qgis_out_type;
// calculate reasonable block size (5MB)
int maximumTileHeight = 5000000 / mXSize;
maximumTileHeight = std::max( 1, maximumTileHeight );
// smaller if reprojecting so that it can be canceled quickly
if ( mPipe->projector() )
{
maximumTileHeight = std::max( 1, 100000 / mXSize );
}
QgsRasterIterator iter( mPipe->last() );
iter.setMaximumTileWidth( mXSize );
iter.setMaximumTileHeight( maximumTileHeight );
iter.startRasterRead( band, mXSize, mYSize, mExtent );
int iterLeft = 0;
int iterTop = 0;
int iterCols = 0;
int iterRows = 0;
QgsRasterBlock* block = 0;
process->setReadChannel( QProcess::StandardOutput );
while ( iter.readNextRasterPart( band, iterCols, iterRows, &block, iterLeft, iterTop ) )
{
for ( int row = 0; row < iterRows; row++ )
{
if ( !block->convert( qgis_out_type ) )
{
setError( tr( "Cannot convert block (%1) to data type %2" ).arg( block->toString() ).arg( qgis_out_type ) );
delete block;
return false;
}
// prepare null values
double noDataValue;
if ( block->hasNoDataValue() )
{
noDataValue = block->noDataValue();
}
else
{
switch ( qgis_out_type )
{
case QGis::Int32:
noDataValue = -2147483648.0;
break;
case QGis::Float32:
noDataValue = std::numeric_limits<float>::max() * -1.0;
break;
case QGis::Float64:
noDataValue = std::numeric_limits<double>::max() * -1.0;
break;
default: // should not happen
noDataValue = std::numeric_limits<double>::max() * -1.0;
}
for ( qgssize i = 0; i < ( qgssize )block->width()*block->height(); i++ )
{
if ( block->isNoData( i ) )
{
block->setValue( i, noDataValue );
}
}
}
char * data = block->bits( row, 0 );
int size = iterCols * block->dataTypeSize();
QByteArray byteArray = QByteArray::fromRawData( data, size ); // does not copy data and does not take ownership
if ( isCanceled() )
{
outStream << true; // cancel module
break;
}
outStream << false; // not canceled
outStream << noDataValue;
outStream << byteArray;
// Without waitForBytesWritten() it does not finish ok on Windows (process timeout)
process->waitForBytesWritten( -1 );
#ifndef Q_OS_WIN
// wait until the row is written to allow quick cancel (don't send data to buffer)
process->waitForReadyRead();
bool result;
outStream >> result;
#endif
}
delete block;
if ( isCanceled() )
{
outStream << true; // cancel module
break;
}
}
// TODO: send something back from module and read it here to close map correctly in module
process->closeWriteChannel();
// TODO: best timeout?
process->waitForFinished( 30000 );
QString stdoutString = process->readAllStandardOutput().data();
QString stderrString = process->readAllStandardError().data();
QString processResult = QString( "exitStatus=%1, exitCode=%2, error=%3, errorString=%4 stdout=%5, stderr=%6" )
.arg( process->exitStatus() ).arg( process->exitCode() )
.arg( process->error() ).arg( process->errorString() )
.arg( stdoutString.replace( "\n", ", " ) ).arg( stderrString.replace( "\n", ", " ) );
QgsDebugMsg( "processResult: " + processResult );
if ( process->exitStatus() != QProcess::NormalExit )
{
setError( process->errorString() );
delete process;
return false;
}
if ( process->exitCode() != 0 )
{
setError( stderrString );
delete process;
return false;
}
delete process;
}
QgsDebugMsg( QString( "redBand = %1 greenBand = %2 blueBand = %3" ).arg( redBand ).arg( greenBand ).arg( blueBand ) );
if ( redBand > 0 && greenBand > 0 && blueBand > 0 )
{
// TODO: check if the group exists
// I_find_group()
QString name = mGrassObject.name();
G_TRY
{
QgsGrass::setMapset( mGrassObject.gisdbase(), mGrassObject.location(), mGrassObject.mapset() );
struct Ref ref;
I_get_group_ref( name.toUtf8().data(), &ref );
QString redName = name + QString( ".%1" ).arg( redBand );
QString greenName = name + QString( ".%1" ).arg( greenBand );
QString blueName = name + QString( ".%1" ).arg( blueBand );
I_add_file_to_group_ref( redName.toUtf8().data(), mGrassObject.mapset().toUtf8().data(), &ref );
I_add_file_to_group_ref( greenName.toUtf8().data(), mGrassObject.mapset().toUtf8().data(), &ref );
I_add_file_to_group_ref( blueName.toUtf8().data(), mGrassObject.mapset().toUtf8().data(), &ref );
I_put_group_ref( name.toUtf8().data(), &ref );
}
G_CATCH( QgsGrass::Exception &e )
{
QgsDebugMsg( QString( "Cannot create group: %1" ).arg( e.what() ) );
}
QgsRasterFileWriter::WriterError QgsRasterFileWriter::writeImageRaster( QgsRasterIterator* iter, int nCols, int nRows, const QgsRectangle& outputExtent,
const QgsCoordinateReferenceSystem& crs, QProgressDialog* progressDialog )
{
QgsDebugMsg( "Entered" );
if ( !iter )
{
return SourceProviderError;
}
const QgsRasterInterface* iface = iter->input();
QGis::DataType inputDataType = iface->dataType( 1 );
if ( !iface || ( inputDataType != QGis::ARGB32 &&
inputDataType != QGis::ARGB32_Premultiplied ) )
{
return SourceProviderError;
}
iter->setMaximumTileWidth( mMaxTileWidth );
iter->setMaximumTileHeight( mMaxTileHeight );
void* redData = qgsMalloc( mMaxTileWidth * mMaxTileHeight );
void* greenData = qgsMalloc( mMaxTileWidth * mMaxTileHeight );
void* blueData = qgsMalloc( mMaxTileWidth * mMaxTileHeight );
void* alphaData = qgsMalloc( mMaxTileWidth * mMaxTileHeight );
QgsRectangle mapRect;
int iterLeft = 0, iterTop = 0, iterCols = 0, iterRows = 0;
int fileIndex = 0;
//create destProvider for whole dataset here
QgsRasterDataProvider* destProvider = 0;
double pixelSize;
double geoTransform[6];
globalOutputParameters( outputExtent, nCols, nRows, geoTransform, pixelSize );
destProvider = initOutput( nCols, nRows, crs, geoTransform, 4, QGis::Byte );
iter->startRasterRead( 1, nCols, nRows, outputExtent );
int nParts = 0;
if ( progressDialog )
{
int nPartsX = nCols / iter->maximumTileWidth() + 1;
int nPartsY = nRows / iter->maximumTileHeight() + 1;
nParts = nPartsX * nPartsY;
progressDialog->setMaximum( nParts );
progressDialog->show();
progressDialog->setLabelText( QObject::tr( "Reading raster part %1 of %2" ).arg( fileIndex + 1 ).arg( nParts ) );
}
QgsRasterBlock *inputBlock = 0;
while ( iter->readNextRasterPart( 1, iterCols, iterRows, &inputBlock, iterLeft, iterTop ) )
{
if ( !inputBlock )
{
continue;
}
if ( progressDialog && fileIndex < ( nParts - 1 ) )
{
progressDialog->setValue( fileIndex + 1 );
progressDialog->setLabelText( QObject::tr( "Reading raster part %1 of %2" ).arg( fileIndex + 2 ).arg( nParts ) );
QCoreApplication::processEvents( QEventLoop::AllEvents, 1000 );
if ( progressDialog->wasCanceled() )
{
delete inputBlock;
break;
}
}
//fill into red/green/blue/alpha channels
qgssize nPixels = ( qgssize )iterCols * iterRows;
// TODO: should be char not int? we are then copying 1 byte
int red = 0;
int green = 0;
int blue = 0;
int alpha = 255;
for ( qgssize i = 0; i < nPixels; ++i )
{
QRgb c = inputBlock->color( i );
alpha = qAlpha( c );
red = qRed( c ); green = qGreen( c ); blue = qBlue( c );
if ( inputDataType == QGis::ARGB32_Premultiplied )
{
double a = alpha / 255.;
QgsDebugMsgLevel( QString( "red = %1 green = %2 blue = %3 alpha = %4 p = %5 a = %6" ).arg( red ).arg( green ).arg( blue ).arg( alpha ).arg(( int )c, 0, 16 ).arg( a ), 5 );
red /= a;
green /= a;
blue /= a;
}
memcpy(( char* )redData + i, &red, 1 );
memcpy(( char* )greenData + i, &green, 1 );
memcpy(( char* )blueData + i, &blue, 1 );
memcpy(( char* )alphaData + i, &alpha, 1 );
}
delete inputBlock;
//create output file
if ( mTiledMode )
{
//delete destProvider;
QgsRasterDataProvider* partDestProvider = createPartProvider( outputExtent,
nCols, iterCols, iterRows,
iterLeft, iterTop, mOutputUrl, fileIndex,
4, QGis::Byte, crs );
if ( partDestProvider )
{
//write data to output file
partDestProvider->write( redData, 1, iterCols, iterRows, 0, 0 );
partDestProvider->write( greenData, 2, iterCols, iterRows, 0, 0 );
partDestProvider->write( blueData, 3, iterCols, iterRows, 0, 0 );
partDestProvider->write( alphaData, 4, iterCols, iterRows, 0, 0 );
addToVRT( partFileName( fileIndex ), 1, iterCols, iterRows, iterLeft, iterTop );
addToVRT( partFileName( fileIndex ), 2, iterCols, iterRows, iterLeft, iterTop );
addToVRT( partFileName( fileIndex ), 3, iterCols, iterRows, iterLeft, iterTop );
addToVRT( partFileName( fileIndex ), 4, iterCols, iterRows, iterLeft, iterTop );
delete partDestProvider;
}
}
else if ( destProvider )
{
destProvider->write( redData, 1, iterCols, iterRows, iterLeft, iterTop );
destProvider->write( greenData, 2, iterCols, iterRows, iterLeft, iterTop );
destProvider->write( blueData, 3, iterCols, iterRows, iterLeft, iterTop );
destProvider->write( alphaData, 4, iterCols, iterRows, iterLeft, iterTop );
}
++fileIndex;
}
if ( destProvider )
delete destProvider;
qgsFree( redData ); qgsFree( greenData ); qgsFree( blueData ); qgsFree( alphaData );
if ( progressDialog )
{
progressDialog->setValue( progressDialog->maximum() );
}
if ( mTiledMode )
{
QString vrtFilePath( mOutputUrl + "/" + vrtFileName() );
writeVRT( vrtFilePath );
if ( mBuildPyramidsFlag == QgsRaster::PyramidsFlagYes )
{
buildPyramids( vrtFilePath );
}
}
else
{
if ( mBuildPyramidsFlag == QgsRaster::PyramidsFlagYes )
{
buildPyramids( mOutputUrl );
}
}
return NoError;
}
QgsRasterBlock* QgsSingleBandGrayRenderer::block( int bandNo, QgsRectangle const & extent, int width, int height )
{
Q_UNUSED( bandNo );
QgsDebugMsg( QString( "width = %1 height = %2" ).arg( width ).arg( height ) );
QgsRasterBlock *outputBlock = new QgsRasterBlock();
if ( !mInput )
{
return outputBlock;
}
QgsRasterBlock *inputBlock = mInput->block( mGrayBand, extent, width, height );
if ( !inputBlock || inputBlock->isEmpty() )
{
QgsDebugMsg( "No raster data!" );
delete inputBlock;
return outputBlock;
}
QgsRasterBlock *alphaBlock = 0;
if ( mAlphaBand > 0 && mGrayBand != mAlphaBand )
{
alphaBlock = mInput->block( mAlphaBand, extent, width, height );
if ( !alphaBlock || alphaBlock->isEmpty() )
{
// TODO: better to render without alpha
delete inputBlock;
delete alphaBlock;
return outputBlock;
}
}
else if ( mAlphaBand > 0 )
{
alphaBlock = inputBlock;
}
if ( !outputBlock->reset( QGis::ARGB32_Premultiplied, width, height ) )
{
delete inputBlock;
delete alphaBlock;
return outputBlock;
}
QRgb myDefaultColor = NODATA_COLOR;
for ( qgssize i = 0; i < ( qgssize )width*height; i++ )
{
if ( inputBlock->isNoData( i ) )
{
outputBlock->setColor( i, myDefaultColor );
continue;
}
double grayVal = inputBlock->value( i );
double currentAlpha = mOpacity;
if ( mRasterTransparency )
{
currentAlpha = mRasterTransparency->alphaValue( grayVal, mOpacity * 255 ) / 255.0;
}
if ( mAlphaBand > 0 )
{
currentAlpha *= alphaBlock->value( i ) / 255.0;
}
if ( mContrastEnhancement )
{
if ( !mContrastEnhancement->isValueInDisplayableRange( grayVal ) )
{
outputBlock->setColor( i, myDefaultColor );
continue;
}
grayVal = mContrastEnhancement->enhanceContrast( grayVal );
}
if ( mGradient == WhiteToBlack )
{
grayVal = 255 - grayVal;
}
if ( qgsDoubleNear( currentAlpha, 1.0 ) )
{
outputBlock->setColor( i, qRgba( grayVal, grayVal, grayVal, 255 ) );
}
else
{
outputBlock->setColor( i, qRgba( currentAlpha * grayVal, currentAlpha * grayVal, currentAlpha * grayVal, currentAlpha * 255 ) );
}
}
delete inputBlock;
if ( mAlphaBand > 0 && mGrayBand != mAlphaBand )
{
delete alphaBlock;
}
return outputBlock;
}
QgsRasterBlock* QgsSingleBandPseudoColorRenderer::block( int bandNo, QgsRectangle const & extent, int width, int height, QgsRasterBlockFeedback* feedback )
{
Q_UNUSED( bandNo );
QgsRasterBlock *outputBlock = new QgsRasterBlock();
if ( !mInput || !mShader )
{
return outputBlock;
}
QgsRasterBlock *inputBlock = mInput->block( mBand, extent, width, height, feedback );
if ( !inputBlock || inputBlock->isEmpty() )
{
QgsDebugMsg( "No raster data!" );
delete inputBlock;
return outputBlock;
}
//rendering is faster without considering user-defined transparency
bool hasTransparency = usesTransparency();
QgsRasterBlock *alphaBlock = nullptr;
if ( mAlphaBand > 0 && mAlphaBand != mBand )
{
alphaBlock = mInput->block( mAlphaBand, extent, width, height, feedback );
if ( !alphaBlock || alphaBlock->isEmpty() )
{
delete inputBlock;
delete alphaBlock;
return outputBlock;
}
}
else if ( mAlphaBand == mBand )
{
alphaBlock = inputBlock;
}
if ( !outputBlock->reset( Qgis::ARGB32_Premultiplied, width, height ) )
{
delete inputBlock;
delete alphaBlock;
return outputBlock;
}
QRgb myDefaultColor = NODATA_COLOR;
for ( qgssize i = 0; i < ( qgssize )width*height; i++ )
{
if ( inputBlock->isNoData( i ) )
{
outputBlock->setColor( i, myDefaultColor );
continue;
}
double val = inputBlock->value( i );
int red, green, blue, alpha;
if ( !mShader->shade( val, &red, &green, &blue, &alpha ) )
{
outputBlock->setColor( i, myDefaultColor );
continue;
}
if ( alpha < 255 )
{
// Working with premultiplied colors, so multiply values by alpha
red *= ( alpha / 255.0 );
blue *= ( alpha / 255.0 );
green *= ( alpha / 255.0 );
}
if ( !hasTransparency )
{
outputBlock->setColor( i, qRgba( red, green, blue, alpha ) );
}
else
{
//opacity
double currentOpacity = mOpacity;
if ( mRasterTransparency )
{
currentOpacity = mRasterTransparency->alphaValue( val, mOpacity * 255 ) / 255.0;
}
if ( mAlphaBand > 0 )
{
currentOpacity *= alphaBlock->value( i ) / 255.0;
}
outputBlock->setColor( i, qRgba( currentOpacity * red, currentOpacity * green, currentOpacity * blue, currentOpacity * alpha ) );
}
}
delete inputBlock;
if ( mAlphaBand > 0 && mBand != mAlphaBand )
{
delete alphaBlock;
}
return outputBlock;
}
QgsRasterBlock *QgsHillshadeRenderer::block( int bandNo, const QgsRectangle &extent, int width, int height, QgsRasterBlockFeedback* feedback )
{
Q_UNUSED( bandNo );
QgsRasterBlock *outputBlock = new QgsRasterBlock();
if ( !mInput )
{
QgsDebugMsg( "No input raster!" );
return outputBlock;
}
QgsRasterBlock *inputBlock = mInput->block( mBand, extent, width, height, feedback );
if ( !inputBlock || inputBlock->isEmpty() )
{
QgsDebugMsg( "No raster data!" );
delete inputBlock;
return outputBlock;
}
QgsRasterBlock *alphaBlock = nullptr;
if ( mAlphaBand > 0 && mBand != mAlphaBand )
{
alphaBlock = mInput->block( mAlphaBand, extent, width, height, feedback );
if ( !alphaBlock || alphaBlock->isEmpty() )
{
// TODO: better to render without alpha
delete inputBlock;
delete alphaBlock;
return outputBlock;
}
}
else if ( mAlphaBand > 0 )
{
alphaBlock = inputBlock;
}
if ( !outputBlock->reset( Qgis::ARGB32_Premultiplied, width, height ) )
{
delete inputBlock;
delete alphaBlock;
return outputBlock;
}
double cellXSize = extent.width() / double( width );
double cellYSize = extent.height() / double( height );
double zenithRad = qMax( 0.0, 90 - mLightAngle ) * M_PI / 180.0;
double azimuthRad = -1 * mLightAzimuth * M_PI / 180.0;
double cosZenithRad = cos( zenithRad );
double sinZenithRad = sin( zenithRad );
// Multi direction hillshade: http://pubs.usgs.gov/of/1992/of92-422/of92-422.pdf
double angle0Rad = ( -1 * mLightAzimuth - 45 - 45 * 0.5 ) * M_PI / 180.0;
double angle1Rad = ( -1 * mLightAzimuth - 45 * 0.5 ) * M_PI / 180.0;
double angle2Rad = ( -1 * mLightAzimuth + 45 * 0.5 ) * M_PI / 180.0;
double angle3Rad = ( -1 * mLightAzimuth + 45 + 45 * 0.5 ) * M_PI / 180.0;
QRgb myDefaultColor = NODATA_COLOR;
for ( qgssize i = 0; i < ( qgssize )height; i++ )
{
for ( qgssize j = 0; j < ( qgssize )width; j++ )
{
if ( inputBlock->isNoData( i, j ) )
{
outputBlock->setColor( i, j, myDefaultColor );
continue;
}
qgssize iUp, iDown, jLeft, jRight;
if ( i == 0 )
{
iUp = i;
iDown = i + 1;
}
else if ( i < ( qgssize )height - 1 )
{
iUp = i - 1;
iDown = i + 1;
}
else
{
iUp = i - 1;
iDown = i;
}
if ( j == 0 )
{
jLeft = j;
jRight = j + 1;
}
else if ( j < ( qgssize )width - 1 )
{
jLeft = j - 1;
jRight = j + 1;
}
else
{
jLeft = j - 1;
jRight = j;
}
double x11;
double x21;
double x31;
double x12;
double x22; // Working cell
double x32;
double x13;
double x23;
double x33;
// This is center cell. It is not nodata. Use this in place of nodata neighbors
x22 = inputBlock->value( i, j );
x11 = inputBlock->isNoData( iUp, jLeft ) ? x22 : inputBlock->value( iUp, jLeft );
x21 = inputBlock->isNoData( i, jLeft ) ? x22 : inputBlock->value( i, jLeft );
x31 = inputBlock->isNoData( iDown, jLeft ) ? x22 : inputBlock->value( iDown, jLeft );
x12 = inputBlock->isNoData( iUp, j ) ? x22 : inputBlock->value( iUp, j );
// x22
x32 = inputBlock->isNoData( iDown, j ) ? x22 : inputBlock->value( iDown, j );
x13 = inputBlock->isNoData( iUp, jRight ) ? x22 : inputBlock->value( iUp, jRight );
x23 = inputBlock->isNoData( i, jRight ) ? x22 : inputBlock->value( i, jRight );
x33 = inputBlock->isNoData( iDown, jRight ) ? x22 : inputBlock->value( iDown, jRight );
double derX = calcFirstDerX( x11, x21, x31, x12, x22, x32, x13, x23, x33, cellXSize );
double derY = calcFirstDerY( x11, x21, x31, x12, x22, x32, x13, x23, x33, cellYSize );
double slopeRad = atan( mZFactor * sqrt( derX * derX + derY * derY ) );
double aspectRad = atan2( derX, -derY );
double grayValue;
if ( !mMultiDirectional )
{
// Standard single direction hillshade
grayValue = qBound( 0.0, 255.0 * ( cosZenithRad * cos( slopeRad )
+ sinZenithRad * sin( slopeRad )
* cos( azimuthRad - aspectRad ) ) , 255.0 );
}
else
{
// Weighted multi direction as in http://pubs.usgs.gov/of/1992/of92-422/of92-422.pdf
double weight0 = sin( aspectRad - angle0Rad );
double weight1 = sin( aspectRad - angle1Rad );
double weight2 = sin( aspectRad - angle2Rad );
double weight3 = sin( aspectRad - angle3Rad );
weight0 = weight0 * weight0;
weight1 = weight1 * weight1;
weight2 = weight2 * weight2;
weight3 = weight3 * weight3;
double cosSlope = cosZenithRad * cos( slopeRad );
double sinSlope = sinZenithRad * sin( slopeRad );
double color0 = cosSlope + sinSlope * cos( angle0Rad - aspectRad ) ;
double color1 = cosSlope + sinSlope * cos( angle1Rad - aspectRad ) ;
double color2 = cosSlope + sinSlope * cos( angle2Rad - aspectRad ) ;
double color3 = cosSlope + sinSlope * cos( angle3Rad - aspectRad ) ;
grayValue = qBound( 0.0, 255 * ( weight0 * color0 + weight1 * color1 + weight2 * color2 + weight3 * color3 ) * 0.5, 255.0 );
}
double currentAlpha = mOpacity;
if ( mRasterTransparency )
{
currentAlpha = mRasterTransparency->alphaValue( x22, mOpacity * 255 ) / 255.0;
}
if ( mAlphaBand > 0 )
{
currentAlpha *= alphaBlock->value( i ) / 255.0;
}
if ( qgsDoubleNear( currentAlpha, 1.0 ) )
{
outputBlock->setColor( i, j, qRgba( grayValue, grayValue, grayValue, 255 ) );
}
else
{
outputBlock->setColor( i, j, qRgba( currentAlpha * grayValue, currentAlpha * grayValue, currentAlpha * grayValue, currentAlpha * 255 ) );
}
}
}
delete inputBlock;
if ( mAlphaBand > 0 && mBand != mAlphaBand )
{
delete alphaBlock;
}
return outputBlock;
}
QgsRasterHistogram QgsRasterInterface::histogram( int theBandNo,
int theBinCount,
double theMinimum, double theMaximum,
const QgsRectangle & theExtent,
int theSampleSize,
bool theIncludeOutOfRange )
{
QgsDebugMsg( QString( "theBandNo = %1 theBinCount = %2 theMinimum = %3 theMaximum = %4 theSampleSize = %5" ).arg( theBandNo ).arg( theBinCount ).arg( theMinimum ).arg( theMaximum ).arg( theSampleSize ) );
QgsRasterHistogram myHistogram;
initHistogram( myHistogram, theBandNo, theBinCount, theMinimum, theMaximum, theExtent, theSampleSize, theIncludeOutOfRange );
// Find cached
foreach ( QgsRasterHistogram histogram, mHistograms )
{
if ( histogram == myHistogram )
{
QgsDebugMsg( "Using cached histogram." );
return histogram;
}
}
int myBinCount = myHistogram.binCount;
int myWidth = myHistogram.width;
int myHeight = myHistogram.height;
QgsRectangle myExtent = myHistogram.extent;
myHistogram.histogramVector.resize( myBinCount );
int myXBlockSize = xBlockSize();
int myYBlockSize = yBlockSize();
if ( myXBlockSize == 0 ) // should not happen, but happens
{
myXBlockSize = 500;
}
if ( myYBlockSize == 0 ) // should not happen, but happens
{
myYBlockSize = 500;
}
int myNXBlocks = ( myWidth + myXBlockSize - 1 ) / myXBlockSize;
int myNYBlocks = ( myHeight + myYBlockSize - 1 ) / myYBlockSize;
double myXRes = myExtent.width() / myWidth;
double myYRes = myExtent.height() / myHeight;
double myMinimum = myHistogram.minimum;
double myMaximum = myHistogram.maximum;
// To avoid rounding errors
// TODO: check this
double myerval = ( myMaximum - myMinimum ) / myHistogram.binCount;
myMinimum -= 0.1 * myerval;
myMaximum += 0.1 * myerval;
QgsDebugMsg( QString( "binCount = %1 myMinimum = %2 myMaximum = %3" ).arg( myHistogram.binCount ).arg( myMinimum ).arg( myMaximum ) );
double myBinSize = ( myMaximum - myMinimum ) / myBinCount;
// TODO: progress signals
for ( int myYBlock = 0; myYBlock < myNYBlocks; myYBlock++ )
{
for ( int myXBlock = 0; myXBlock < myNXBlocks; myXBlock++ )
{
int myBlockWidth = qMin( myXBlockSize, myWidth - myXBlock * myXBlockSize );
int myBlockHeight = qMin( myYBlockSize, myHeight - myYBlock * myYBlockSize );
double xmin = myExtent.xMinimum() + myXBlock * myXBlockSize * myXRes;
double xmax = xmin + myBlockWidth * myXRes;
double ymin = myExtent.yMaximum() - myYBlock * myYBlockSize * myYRes;
double ymax = ymin - myBlockHeight * myYRes;
QgsRectangle myPartExtent( xmin, ymin, xmax, ymax );
QgsRasterBlock* blk = block( theBandNo, myPartExtent, myBlockWidth, myBlockHeight );
// Collect the histogram counts.
for ( qgssize i = 0; i < (( qgssize ) myBlockHeight ) * myBlockWidth; i++ )
{
if ( blk->isNoData( i ) )
{
continue; // NULL
}
double myValue = blk->value( i );
int myBinIndex = static_cast <int>( qFloor(( myValue - myMinimum ) / myBinSize ) ) ;
if (( myBinIndex < 0 || myBinIndex > ( myBinCount - 1 ) ) && !theIncludeOutOfRange )
{
continue;
}
if ( myBinIndex < 0 ) myBinIndex = 0;
if ( myBinIndex > ( myBinCount - 1 ) ) myBinIndex = myBinCount - 1;
myHistogram.histogramVector[myBinIndex] += 1;
myHistogram.nonNullCount++;
}
delete blk;
}
}
myHistogram.valid = true;
mHistograms.append( myHistogram );
#ifdef QGISDEBUG
QString hist;
for ( int i = 0; i < qMin( myHistogram.histogramVector.size(), 500 ); i++ )
{
hist += QString::number( myHistogram.histogramVector.value( i ) ) + " ";
}
QgsDebugMsg( "Histogram (max first 500 bins): " + hist );
#endif
return myHistogram;
}
int QgsGrassGisLib::readRasterRow( int fd, void * buf, int row, RASTER_MAP_TYPE data_type, bool noDataAsZero )
{
if ( row < 0 || row >= mRows )
{
QgsDebugMsg( QString( "row %1 out of range 0 - %2" ).arg( row ).arg( mRows ) );
return 0;
}
// TODO: use cached block with more rows
Raster raster = mRasters.value( fd );
//if ( !raster.provider ) return -1;
if ( !raster.input ) return -1;
// Create extent for current row
QgsRectangle blockRect = mExtent;
double yRes = mExtent.height() / mRows;
double yMax = mExtent.yMaximum() - yRes * row;
//QgsDebugMsg( QString( "height = %1 mRows = %2" ).arg( mExtent.height() ).arg( mRows ) );
//QgsDebugMsg( QString( "row = %1 yRes = %2 yRes * row = %3" ).arg( row ).arg( yRes ).arg( yRes * row ) );
//QgsDebugMsg( QString( "mExtent.yMaximum() = %1 yMax = %2" ).arg( mExtent.yMaximum() ).arg( yMax ) );
blockRect.setYMaximum( yMax );
blockRect.setYMinimum( yMax - yRes );
QgsRasterBlock *block = raster.input->block( raster.band, blockRect, mColumns, 1 );
if ( !block ) return -1;
QGis::DataType requestedType = qgisRasterType( data_type );
//QgsDebugMsg( QString("data_type = %1").arg(data_type) );
//QgsDebugMsg( QString("requestedType = %1").arg(requestedType) );
//QgsDebugMsg( QString("requestedType size = %1").arg( QgsRasterBlock::typeSize( requestedType ) ) );
//QgsDebugMsg( QString("block->dataType = %1").arg( block->dataType() ) );
block->convert( requestedType );
memcpy( buf, block->bits( 0 ), QgsRasterBlock::typeSize( requestedType ) * mColumns );
for ( int i = 0; i < mColumns; i++ )
{
QgsDebugMsgLevel( QString( "row = %1 i = %2 val = %3 isNoData = %4" ).arg( row ).arg( i ).arg( block->value( i ) ).arg( block->isNoData( i ) ), 5 );
//(( CELL * ) buf )[i] = i;
if ( block->isNoData( 0, i ) )
{
if ( noDataAsZero )
{
switch ( data_type )
{
case CELL_TYPE:
G_zero(( char * ) &(( CELL * ) buf )[i], G_raster_size( data_type ) );
break;
case FCELL_TYPE:
G_zero(( char * ) &(( FCELL * ) buf )[i], G_raster_size( data_type ) );
break;
case DCELL_TYPE:
G_zero(( char * ) &(( DCELL * ) buf )[i], G_raster_size( data_type ) );
break;
default:
break;
}
}
else
{
switch ( data_type )
{
case CELL_TYPE:
G_set_c_null_value( &(( CELL * ) buf )[i], 1 );
break;
case FCELL_TYPE:
G_set_f_null_value( &(( FCELL * ) buf )[i], 1 );
break;
case DCELL_TYPE:
G_set_d_null_value( &(( DCELL * ) buf )[i], 1 );
break;
default:
break;
}
}
}
//else
//{
//memcpy( &( buf[i] ), block->bits( 0, i ), 4 );
//buf[i] = (int) block->value( 0, i);
//QgsDebugMsg( QString("buf[i] = %1").arg(buf[i]));
//}
}
delete block;
return 1;
}
QgsRasterBlock * QgsPalettedRasterRenderer::block( int bandNo, QgsRectangle const & extent, int width, int height )
{
QgsRasterBlock *outputBlock = new QgsRasterBlock();
if ( !mInput )
{
return outputBlock;
}
QgsRasterBlock *inputBlock = mInput->block( bandNo, extent, width, height );
if ( !inputBlock || inputBlock->isEmpty() )
{
QgsDebugMsg( "No raster data!" );
delete inputBlock;
return outputBlock;
}
double currentOpacity = mOpacity;
//rendering is faster without considering user-defined transparency
bool hasTransparency = usesTransparency();
QgsRasterBlock *alphaBlock = 0;
if ( mAlphaBand > 0 && mAlphaBand != mBand )
{
alphaBlock = mInput->block( mAlphaBand, extent, width, height );
if ( !alphaBlock || alphaBlock->isEmpty() )
{
delete inputBlock;
delete alphaBlock;
return outputBlock;
}
}
else if ( mAlphaBand == mBand )
{
alphaBlock = inputBlock;
}
if ( !outputBlock->reset( QGis::ARGB32_Premultiplied, width, height ) )
{
delete inputBlock;
delete alphaBlock;
return outputBlock;
}
QRgb myDefaultColor = NODATA_COLOR;
//use direct data access instead of QgsRasterBlock::setValue
//because of performance
unsigned int* outputData = ( unsigned int* )( outputBlock->bits() );
qgssize rasterSize = ( qgssize )width * height;
for ( qgssize i = 0; i < rasterSize; ++i )
{
if ( inputBlock->isNoData( i ) )
{
outputData[i] = myDefaultColor;
continue;
}
int val = ( int ) inputBlock->value( i );
if ( !hasTransparency )
{
outputData[i] = mColors[val];
}
else
{
currentOpacity = mOpacity;
if ( mRasterTransparency )
{
currentOpacity = mRasterTransparency->alphaValue( val, mOpacity * 255 ) / 255.0;
}
if ( mAlphaBand > 0 )
{
currentOpacity *= alphaBlock->value( i ) / 255.0;
}
QColor currentColor = QColor( mColors[val] );
outputData[i] = qRgba( currentOpacity * currentColor.red(), currentOpacity * currentColor.green(), currentOpacity * currentColor.blue(), currentOpacity * 255 );
}
}
delete inputBlock;
if ( mAlphaBand > 0 && mBand != mAlphaBand )
{
delete alphaBlock;
}
return outputBlock;
}
QgsRasterBlock* QgsRasterResampleFilter::block2( int bandNo, QgsRectangle const & extent, int width, int height, QgsRasterBlockFeedback *feedback )
{
Q_UNUSED( bandNo );
QgsDebugMsg( QString( "width = %1 height = %2 extent = %3" ).arg( width ).arg( height ).arg( extent.toString() ) );
QgsRasterBlock *outputBlock = new QgsRasterBlock();
if ( !mInput ) return outputBlock;
double oversampling = 1.0; // approximate global oversampling factor
if ( mZoomedInResampler || mZoomedOutResampler )
{
QgsRasterDataProvider *provider = dynamic_cast<QgsRasterDataProvider*>( mInput->srcInput() );
if ( provider && ( provider->capabilities() & QgsRasterDataProvider::Size ) )
{
double xRes = extent.width() / width;
double providerXRes = provider->extent().width() / provider->xSize();
double pixelRatio = xRes / providerXRes;
oversampling = ( pixelRatio > mMaxOversampling ) ? mMaxOversampling : pixelRatio;
QgsDebugMsg( QString( "xRes = %1 providerXRes = %2 pixelRatio = %3 oversampling = %4" ).arg( xRes ).arg( providerXRes ).arg( pixelRatio ).arg( oversampling ) );
}
else
{
// We don't know exact data source resolution (WMS) so we expect that
// server data have higher resolution (which is not always true) and use
// mMaxOversampling
oversampling = mMaxOversampling;
}
}
QgsDebugMsg( QString( "oversampling %1" ).arg( oversampling ) );
int bandNumber = 1;
// Do no oversampling if no resampler for zoomed in / zoomed out (nearest neighbour)
// We do mZoomedInResampler if oversampling == 1 (otherwise for example reprojected
// zoom in rasters are never resampled because projector limits resolution.
if ((( oversampling < 1.0 || qgsDoubleNear( oversampling, 1.0 ) ) && !mZoomedInResampler ) || ( oversampling > 1.0 && !mZoomedOutResampler ) )
{
QgsDebugMsg( "No oversampling." );
delete outputBlock;
return mInput->block2( bandNumber, extent, width, height, feedback );
}
//effective oversampling factors are different to global one because of rounding
double oversamplingX = (( double )width * oversampling ) / width;
double oversamplingY = (( double )height * oversampling ) / height;
// TODO: we must also increase the extent to get correct result on borders of parts
int resWidth = width * oversamplingX;
int resHeight = height * oversamplingY;
QgsRasterBlock *inputBlock = mInput->block2( bandNumber, extent, resWidth, resHeight, feedback );
if ( !inputBlock || inputBlock->isEmpty() )
{
QgsDebugMsg( "No raster data!" );
delete inputBlock;
return outputBlock;
}
if ( !outputBlock->reset( QGis::ARGB32_Premultiplied, width, height ) )
{
delete inputBlock;
return outputBlock;
}
//resample image
QImage img = inputBlock->image();
QImage dstImg = QImage( width, height, QImage::Format_ARGB32_Premultiplied );
if ( mZoomedInResampler && ( oversamplingX < 1.0 || qgsDoubleNear( oversampling, 1.0 ) ) )
{
QgsDebugMsg( "zoomed in resampling" );
mZoomedInResampler->resample( img, dstImg );
}
else if ( mZoomedOutResampler && oversamplingX > 1.0 )
{
QgsDebugMsg( "zoomed out resampling" );
mZoomedOutResampler->resample( img, dstImg );
}
else
{
// Should not happen
QgsDebugMsg( "Unexpected resampling" );
dstImg = img.scaled( width, height );
}
outputBlock->setImage( &dstImg );
delete inputBlock;
return outputBlock; // No resampling
}
QgsRasterBlock *QgsMultiBandColorRenderer::block( int bandNo, QgsRectangle const &extent, int width, int height, QgsRasterBlockFeedback *feedback )
{
Q_UNUSED( bandNo );
std::unique_ptr< QgsRasterBlock > outputBlock( new QgsRasterBlock() );
if ( !mInput )
{
return outputBlock.release();
}
//In some (common) cases, we can simplify the drawing loop considerably and save render time
bool fastDraw = ( !usesTransparency()
&& mRedBand > 0 && mGreenBand > 0 && mBlueBand > 0
&& mAlphaBand < 1 );
QSet<int> bands;
if ( mRedBand > 0 )
{
bands << mRedBand;
}
if ( mGreenBand > 0 )
{
bands << mGreenBand;
}
if ( mBlueBand > 0 )
{
bands << mBlueBand;
}
if ( bands.empty() )
{
// no need to draw anything if no band is set
// TODO:: we should probably return default color block
return outputBlock.release();
}
if ( mAlphaBand > 0 )
{
bands << mAlphaBand;
}
QMap<int, QgsRasterBlock *> bandBlocks;
QgsRasterBlock *defaultPointer = nullptr;
QSet<int>::const_iterator bandIt = bands.constBegin();
for ( ; bandIt != bands.constEnd(); ++bandIt )
{
bandBlocks.insert( *bandIt, defaultPointer );
}
QgsRasterBlock *redBlock = nullptr;
QgsRasterBlock *greenBlock = nullptr;
QgsRasterBlock *blueBlock = nullptr;
QgsRasterBlock *alphaBlock = nullptr;
bandIt = bands.constBegin();
for ( ; bandIt != bands.constEnd(); ++bandIt )
{
bandBlocks[*bandIt] = mInput->block( *bandIt, extent, width, height, feedback );
if ( !bandBlocks[*bandIt] )
{
// We should free the alloced mem from block().
QgsDebugMsg( QStringLiteral( "No input band" ) );
--bandIt;
for ( ; bandIt != bands.constBegin(); --bandIt )
{
delete bandBlocks[*bandIt];
}
return outputBlock.release();
}
}
if ( mRedBand > 0 )
{
redBlock = bandBlocks[mRedBand];
}
if ( mGreenBand > 0 )
{
greenBlock = bandBlocks[mGreenBand];
}
if ( mBlueBand > 0 )
{
blueBlock = bandBlocks[mBlueBand];
}
if ( mAlphaBand > 0 )
{
alphaBlock = bandBlocks[mAlphaBand];
}
if ( !outputBlock->reset( Qgis::ARGB32_Premultiplied, width, height ) )
{
for ( int i = 0; i < bandBlocks.size(); i++ )
{
delete bandBlocks.value( i );
}
return outputBlock.release();
}
QRgb *outputBlockColorData = outputBlock->colorData();
// faster data access to data for the common case that input data are coming from RGB image with 8-bit bands
bool hasByteRgb = ( redBlock && greenBlock && blueBlock && redBlock->dataType() == Qgis::Byte && greenBlock->dataType() == Qgis::Byte && blueBlock->dataType() == Qgis::Byte );
const quint8 *redData = nullptr, *greenData = nullptr, *blueData = nullptr;
if ( hasByteRgb )
{
redData = redBlock->byteData();
greenData = greenBlock->byteData();
blueData = blueBlock->byteData();
}
QRgb myDefaultColor = NODATA_COLOR;
if ( fastDraw )
{
// By default RGB raster layers have contrast enhancement assigned and normally that requires us to take the slow
// route that applies the enhancement. However if the algorithm type is "no enhancement" and all input bands are byte-sized,
// no transform would be applied to the input values and we can take the fast route.
bool hasEnhancement;
if ( hasByteRgb )
{
hasEnhancement =
( mRedContrastEnhancement && mRedContrastEnhancement->contrastEnhancementAlgorithm() != QgsContrastEnhancement::NoEnhancement ) ||
( mGreenContrastEnhancement && mGreenContrastEnhancement->contrastEnhancementAlgorithm() != QgsContrastEnhancement::NoEnhancement ) ||
( mBlueContrastEnhancement && mBlueContrastEnhancement->contrastEnhancementAlgorithm() != QgsContrastEnhancement::NoEnhancement );
}
else
{
hasEnhancement = mRedContrastEnhancement || mGreenContrastEnhancement || mBlueContrastEnhancement;
}
if ( hasEnhancement )
fastDraw = false;
}
qgssize count = ( qgssize )width * height;
for ( qgssize i = 0; i < count; i++ )
{
if ( fastDraw ) //fast rendering if no transparency, stretching, color inversion, etc.
{
if ( redBlock->isNoData( i ) ||
greenBlock->isNoData( i ) ||
blueBlock->isNoData( i ) )
{
outputBlock->setColor( i, myDefaultColor );
}
else
{
if ( hasByteRgb )
{
outputBlockColorData[i] = qRgb( redData[i], greenData[i], blueData[i] );
}
else
{
int redVal = static_cast<int>( redBlock->value( i ) );
int greenVal = static_cast<int>( greenBlock->value( i ) );
int blueVal = static_cast<int>( blueBlock->value( i ) );
outputBlockColorData[i] = qRgb( redVal, greenVal, blueVal );
}
}
continue;
}
bool isNoData = false;
double redVal = 0;
double greenVal = 0;
double blueVal = 0;
if ( mRedBand > 0 )
{
redVal = redBlock->value( i );
if ( redBlock->isNoData( i ) ) isNoData = true;
}
if ( !isNoData && mGreenBand > 0 )
{
greenVal = greenBlock->value( i );
if ( greenBlock->isNoData( i ) ) isNoData = true;
}
if ( !isNoData && mBlueBand > 0 )
{
blueVal = blueBlock->value( i );
if ( blueBlock->isNoData( i ) ) isNoData = true;
}
if ( isNoData )
{
outputBlock->setColor( i, myDefaultColor );
continue;
}
//apply default color if red, green or blue not in displayable range
if ( ( mRedContrastEnhancement && !mRedContrastEnhancement->isValueInDisplayableRange( redVal ) )
|| ( mGreenContrastEnhancement && !mGreenContrastEnhancement->isValueInDisplayableRange( redVal ) )
|| ( mBlueContrastEnhancement && !mBlueContrastEnhancement->isValueInDisplayableRange( redVal ) ) )
{
outputBlock->setColor( i, myDefaultColor );
continue;
}
//stretch color values
if ( mRedContrastEnhancement )
{
redVal = mRedContrastEnhancement->enhanceContrast( redVal );
}
if ( mGreenContrastEnhancement )
{
greenVal = mGreenContrastEnhancement->enhanceContrast( greenVal );
}
if ( mBlueContrastEnhancement )
{
blueVal = mBlueContrastEnhancement->enhanceContrast( blueVal );
}
//opacity
double currentOpacity = mOpacity;
if ( mRasterTransparency )
{
currentOpacity = mRasterTransparency->alphaValue( redVal, greenVal, blueVal, mOpacity * 255 ) / 255.0;
}
if ( mAlphaBand > 0 )
{
currentOpacity *= alphaBlock->value( i ) / 255.0;
}
if ( qgsDoubleNear( currentOpacity, 1.0 ) )
{
outputBlock->setColor( i, qRgba( redVal, greenVal, blueVal, 255 ) );
}
else
{
outputBlock->setColor( i, qRgba( currentOpacity * redVal, currentOpacity * greenVal, currentOpacity * blueVal, currentOpacity * 255 ) );
}
}
//delete input blocks
QMap<int, QgsRasterBlock *>::const_iterator bandDelIt = bandBlocks.constBegin();
for ( ; bandDelIt != bandBlocks.constEnd(); ++bandDelIt )
{
delete bandDelIt.value();
}
return outputBlock.release();
}
QgsRasterBlock * QgsRasterResampleFilter::block( int bandNo, QgsRectangle const & extent, int width, int height )
{
Q_UNUSED( bandNo );
QgsDebugMsg( "Entered" );
QgsRasterBlock *outputBlock = new QgsRasterBlock();
if ( !mInput ) return outputBlock;
double oversampling = 1.0; // approximate global oversampling factor
if ( mZoomedInResampler || mZoomedOutResampler )
{
QgsRasterDataProvider *provider = dynamic_cast<QgsRasterDataProvider*>( mInput->srcInput() );
// Do not oversample if data source does not have fixed resolution (WMS)
if ( provider && ( provider->capabilities() & QgsRasterDataProvider::ExactResolution ) )
{
double xRes = extent.width() / width;
double providerXRes = provider->extent().width() / provider->xSize();
double pixelRatio = xRes / providerXRes;
oversampling = ( pixelRatio > mMaxOversampling ) ? mMaxOversampling : pixelRatio;
QgsDebugMsg( QString( "xRes = %1 providerXRes = %2 pixelRatio = %3 oversampling = %4" ).arg( xRes ).arg( providerXRes ).arg( pixelRatio ).arg( oversampling ) );
}
}
//set oversampling back to 1.0 if no resampler for zoomed in / zoomed out (nearest neighbour)
if (( oversampling < 1.0 && !mZoomedInResampler ) || ( oversampling > 1.0 && !mZoomedOutResampler ) )
{
oversampling = 1.0;
}
QgsDebugMsg( QString( "oversampling %1" ).arg( oversampling ) );
//effective oversampling factors are different to global one because of rounding
double oversamplingX = (( double )width * oversampling ) / width;
double oversamplingY = (( double )height * oversampling ) / height;
// TODO: we must also increase the extent to get correct result on borders of parts
int resWidth = width * oversamplingX;
int resHeight = height * oversamplingY;
// At moment we know that we read rendered image
int bandNumber = 1;
//void *rasterData = mInput->block( bandNumber, extent, resWidth, resHeight );
QgsRasterBlock *inputBlock = mInput->block( bandNumber, extent, resWidth, resHeight );
if ( !inputBlock || inputBlock->isEmpty() )
{
QgsDebugMsg( "No raster data!" );
delete inputBlock;
return outputBlock;
}
if ( doubleNear( oversamplingX, 1.0 ) || doubleNear( oversamplingY, 1.0 ) )
{
QgsDebugMsg( "No oversampling." );
delete outputBlock;
return inputBlock;
}
if ( !outputBlock->reset( QgsRasterBlock::ARGB32_Premultiplied, width, height ) )
{
delete inputBlock;
return outputBlock;
}
//resample image
QImage img = inputBlock->image();
QImage dstImg = QImage( width, height, QImage::Format_ARGB32_Premultiplied );
if ( mZoomedInResampler && oversamplingX < 1.0 )
{
QgsDebugMsg( "zoomed in resampling" );
mZoomedInResampler->resample( img, dstImg );
}
else if ( mZoomedOutResampler && oversamplingX > 1.0 )
{
QgsDebugMsg( "zoomed out resampling" );
mZoomedOutResampler->resample( img, dstImg );
}
else
{
// Should not happen
QgsDebugMsg( "Unexpected resampling" );
dstImg = img.scaled( width, height );
}
outputBlock->setImage( &dstImg );
delete inputBlock;
return outputBlock; // No resampling
}
// Default implementation for values
QgsRasterIdentifyResult QgsRasterDataProvider::identify( const QgsPointXY &point, QgsRaster::IdentifyFormat format, const QgsRectangle &boundingBox, int width, int height, int /*dpi*/ )
{
QgsDebugMsgLevel( "Entered", 4 );
QMap<int, QVariant> results;
if ( format != QgsRaster::IdentifyFormatValue || !( capabilities() & IdentifyValue ) )
{
QgsDebugMsg( "Format not supported" );
return QgsRasterIdentifyResult( ERR( tr( "Format not supported" ) ) );
}
if ( !extent().contains( point ) )
{
// Outside the raster
for ( int bandNo = 1; bandNo <= bandCount(); bandNo++ )
{
results.insert( bandNo, QVariant() );
}
return QgsRasterIdentifyResult( QgsRaster::IdentifyFormatValue, results );
}
QgsRectangle finalExtent = boundingBox;
if ( finalExtent.isEmpty() )
finalExtent = extent();
if ( width == 0 )
{
width = capabilities() & Size ? xSize() : 1000;
}
if ( height == 0 )
{
height = capabilities() & Size ? ySize() : 1000;
}
// Calculate the row / column where the point falls
double xres = ( finalExtent.width() ) / width;
double yres = ( finalExtent.height() ) / height;
int col = static_cast< int >( std::floor( ( point.x() - finalExtent.xMinimum() ) / xres ) );
int row = static_cast< int >( std::floor( ( finalExtent.yMaximum() - point.y() ) / yres ) );
double xMin = finalExtent.xMinimum() + col * xres;
double xMax = xMin + xres;
double yMax = finalExtent.yMaximum() - row * yres;
double yMin = yMax - yres;
QgsRectangle pixelExtent( xMin, yMin, xMax, yMax );
for ( int i = 1; i <= bandCount(); i++ )
{
QgsRasterBlock *myBlock = block( i, pixelExtent, 1, 1 );
if ( myBlock )
{
double value = myBlock->value( 0 );
results.insert( i, value );
delete myBlock;
}
else
{
results.insert( i, QVariant() );
}
}
return QgsRasterIdentifyResult( QgsRaster::IdentifyFormatValue, results );
}
int QgsRasterCalculator::processCalculation( QProgressDialog* p )
{
//prepare search string / tree
QString errorString;
QgsRasterCalcNode* calcNode = QgsRasterCalcNode::parseRasterCalcString( mFormulaString, errorString );
if ( !calcNode )
{
//error
return static_cast<int>( ParserError );
}
QMap< QString, QgsRasterBlock* > inputBlocks;
QVector<QgsRasterCalculatorEntry>::const_iterator it = mRasterEntries.constBegin();
for ( ; it != mRasterEntries.constEnd(); ++it )
{
if ( !it->raster ) // no raster layer in entry
{
delete calcNode;
qDeleteAll( inputBlocks );
return static_cast< int >( InputLayerError );
}
QgsRasterBlock* block = nullptr;
// if crs transform needed
if ( it->raster->crs() != mOutputCrs )
{
QgsRasterProjector proj;
proj.setCRS( it->raster->crs(), mOutputCrs );
proj.setInput( it->raster->dataProvider() );
proj.setPrecision( QgsRasterProjector::Exact );
block = proj.block( it->bandNumber, mOutputRectangle, mNumOutputColumns, mNumOutputRows );
}
else
{
block = it->raster->dataProvider()->block( it->bandNumber, mOutputRectangle, mNumOutputColumns, mNumOutputRows );
}
if ( block->isEmpty() )
{
delete block;
delete calcNode;
qDeleteAll( inputBlocks );
return static_cast<int>( MemoryError );
}
inputBlocks.insert( it->ref, block );
}
//open output dataset for writing
GDALDriverH outputDriver = openOutputDriver();
if ( !outputDriver )
{
return static_cast< int >( CreateOutputError );
}
GDALDatasetH outputDataset = openOutputFile( outputDriver );
GDALSetProjection( outputDataset, mOutputCrs.toWkt().toLocal8Bit().data() );
GDALRasterBandH outputRasterBand = GDALGetRasterBand( outputDataset, 1 );
float outputNodataValue = -FLT_MAX;
GDALSetRasterNoDataValue( outputRasterBand, outputNodataValue );
if ( p )
{
p->setMaximum( mNumOutputRows );
}
QgsRasterMatrix resultMatrix;
resultMatrix.setNodataValue( outputNodataValue );
//read / write line by line
for ( int i = 0; i < mNumOutputRows; ++i )
{
if ( p )
{
p->setValue( i );
}
if ( p && p->wasCanceled() )
{
break;
}
if ( calcNode->calculate( inputBlocks, resultMatrix, i ) )
{
bool resultIsNumber = resultMatrix.isNumber();
float* calcData = new float[mNumOutputColumns];
for ( int j = 0; j < mNumOutputColumns; ++j )
{
calcData[j] = ( float )( resultIsNumber ? resultMatrix.number() : resultMatrix.data()[j] );
}
//write scanline to the dataset
if ( GDALRasterIO( outputRasterBand, GF_Write, 0, i, mNumOutputColumns, 1, calcData, mNumOutputColumns, 1, GDT_Float32, 0, 0 ) != CE_None )
{
qWarning( "RasterIO error!" );
}
delete[] calcData;
}
}
if ( p )
{
p->setValue( mNumOutputRows );
}
//close datasets and release memory
delete calcNode;
qDeleteAll( inputBlocks );
inputBlocks.clear();
if ( p && p->wasCanceled() )
{
//delete the dataset without closing (because it is faster)
GDALDeleteDataset( outputDriver, TO8F( mOutputFile ) );
return static_cast< int >( Cancelled );
}
GDALClose( outputDataset );
return static_cast< int >( Success );
}
void QgsRasterDrawer::draw( QPainter* p, QgsRasterViewPort* viewPort, const QgsMapToPixel* theQgsMapToPixel )
{
QgsDebugMsg( "Entered" );
if ( !p || !mIterator || !viewPort || !theQgsMapToPixel )
{
return;
}
// last pipe filter has only 1 band
int bandNumber = 1;
mIterator->startRasterRead( bandNumber, viewPort->mWidth, viewPort->mHeight, viewPort->mDrawnExtent );
//number of cols/rows in output pixels
int nCols = 0;
int nRows = 0;
//shift to top left point for the raster part
int topLeftCol = 0;
int topLeftRow = 0;
// We know that the output data type of last pipe filter is QImage data
QgsRasterBlock *block;
// readNextRasterPart calcs and resets nCols, nRows, topLeftCol, topLeftRow
while ( mIterator->readNextRasterPart( bandNumber, nCols, nRows,
&block, topLeftCol, topLeftRow ) )
{
if ( !block )
{
QgsDebugMsg( "Cannot get block" );
continue;
}
QImage img = block->image();
// Because of bug in Acrobat Reader we must use "white" transparent color instead
// of "black" for PDF. See #9101.
QPrinter *printer = dynamic_cast<QPrinter *>( p->device() );
if ( printer && printer->outputFormat() == QPrinter::PdfFormat )
{
QgsDebugMsg( "PdfFormat" );
img = img.convertToFormat( QImage::Format_ARGB32 );
QRgb transparentBlack = qRgba( 0, 0, 0, 0 );
QRgb transparentWhite = qRgba( 255, 255, 255, 0 );
for ( int x = 0; x < img.width(); x++ )
{
for ( int y = 0; y < img.height(); y++ )
{
if ( img.pixel( x, y ) == transparentBlack )
{
img.setPixel( x, y, transparentWhite );
}
}
}
}
drawImage( p, viewPort, img, topLeftCol, topLeftRow );
delete block;
}
}
QgsRasterBlock * QgsHueSaturationFilter::block( int bandNo, QgsRectangle const & extent, int width, int height, QgsRasterBlockFeedback* feedback )
{
Q_UNUSED( bandNo );
QgsDebugMsgLevel( QString( "width = %1 height = %2 extent = %3" ).arg( width ).arg( height ).arg( extent.toString() ), 4 );
QgsRasterBlock *outputBlock = new QgsRasterBlock();
if ( !mInput )
{
return outputBlock;
}
// At this moment we know that we read rendered image
int bandNumber = 1;
QgsRasterBlock *inputBlock = mInput->block( bandNumber, extent, width, height, feedback );
if ( !inputBlock || inputBlock->isEmpty() )
{
QgsDebugMsg( "No raster data!" );
delete inputBlock;
return outputBlock;
}
if ( mSaturation == 0 && mGrayscaleMode == GrayscaleOff && !mColorizeOn )
{
QgsDebugMsgLevel( "No hue/saturation change.", 4 );
delete outputBlock;
return inputBlock;
}
if ( !outputBlock->reset( Qgis::ARGB32_Premultiplied, width, height ) )
{
delete inputBlock;
return outputBlock;
}
// adjust image
QRgb myNoDataColor = qRgba( 0, 0, 0, 0 );
QRgb myRgb;
QColor myColor;
int h, s, l;
int r, g, b, alpha;
double alphaFactor = 1.0;
for ( qgssize i = 0; i < ( qgssize )width*height; i++ )
{
if ( inputBlock->color( i ) == myNoDataColor )
{
outputBlock->setColor( i, myNoDataColor );
continue;
}
myRgb = inputBlock->color( i );
myColor = QColor( myRgb );
// Alpha must be taken from QRgb, since conversion from QRgb->QColor loses alpha
alpha = qAlpha( myRgb );
if ( alpha == 0 )
{
// totally transparent, no changes required
outputBlock->setColor( i, myRgb );
continue;
}
// Get rgb for color
myColor.getRgb( &r, &g, &b );
if ( alpha != 255 )
{
// Semi-transparent pixel. We need to adjust the colors since we are using Qgis::ARGB32_Premultiplied
// and color values have been premultiplied by alpha
alphaFactor = alpha / 255.;
r /= alphaFactor;
g /= alphaFactor;
b /= alphaFactor;
myColor = QColor::fromRgb( r, g, b );
}
myColor.getHsl( &h, &s, &l );
// Changing saturation?
if (( mGrayscaleMode != GrayscaleOff ) || ( mSaturationScale != 1 ) )
{
processSaturation( r, g, b, h, s, l );
}
// Colorizing?
if ( mColorizeOn )
{
processColorization( r, g, b, h, s, l );
}
// Convert back to rgb
if ( alpha != 255 )
{
// Transparent pixel, need to premultiply color components
r *= alphaFactor;
g *= alphaFactor;
b *= alphaFactor;
}
outputBlock->setColor( i, qRgba( r, g, b, alpha ) );
}
delete inputBlock;
return outputBlock;
}
QgsRasterBlock * QgsRasterNuller::block( int bandNo, QgsRectangle const & extent, int width, int height )
{
QgsDebugMsg( "Entered" );
if ( !mInput )
{
return new QgsRasterBlock();
}
QgsRasterBlock *inputBlock = mInput->block( bandNo, extent, width, height );
if ( !inputBlock )
{
return new QgsRasterBlock();
}
// We don't support nuller for color types
if ( QgsRasterBlock::typeIsColor( inputBlock->dataType() ) )
{
return inputBlock;
}
QgsRasterBlock *outputBlock = 0;
if ( mHasOutputNoData.value( bandNo - 1 ) || inputBlock->hasNoDataValue() )
{
double noDataValue;
if ( mHasOutputNoData.value( bandNo - 1 ) )
{
noDataValue = mOutputNoData.value( bandNo - 1 );
}
else
{
noDataValue = inputBlock->noDataValue();
}
outputBlock = new QgsRasterBlock( inputBlock->dataType(), width, height, noDataValue );
}
else
{
outputBlock = new QgsRasterBlock( inputBlock->dataType(), width, height );
}
for ( int i = 0; i < height; i++ )
{
for ( int j = 0; j < width; j++ )
{
double value = inputBlock->value( i, j );
bool isNoData = inputBlock->isNoData( i, j );
if ( QgsRasterRange::contains( value, mNoData.value( bandNo - 1 ) ) )
{
isNoData = true;
}
outputBlock->setValue( i, j, inputBlock->value( i, j ) );
if ( isNoData )
{
outputBlock->setIsNoData( i, j );
}
else
{
outputBlock->setValue( i, j, value );
}
}
}
delete inputBlock;
return outputBlock;
}
bool QgsRasterChecker::runTest( QString theVerifiedKey, QString theVerifiedUri,
QString theExpectedKey, QString theExpectedUri )
{
bool ok = true;
mReport += "\n\n";
//QgsRasterDataProvider* verifiedProvider = QgsRasterLayer::loadProvider( theVerifiedKey, theVerifiedUri );
QgsRasterDataProvider* verifiedProvider = ( QgsRasterDataProvider* ) QgsProviderRegistry::instance()->provider( theVerifiedKey, theVerifiedUri );
if ( !verifiedProvider || !verifiedProvider->isValid() )
{
error( QString( "Cannot load provider %1 with URI: %2" ).arg( theVerifiedKey ).arg( theVerifiedUri ), mReport );
ok = false;
}
//QgsRasterDataProvider* expectedProvider = QgsRasterLayer::loadProvider( theExpectedKey, theExpectedUri );
QgsRasterDataProvider* expectedProvider = ( QgsRasterDataProvider* ) QgsProviderRegistry::instance()->provider( theExpectedKey, theExpectedUri );
if ( !expectedProvider || !expectedProvider->isValid() )
{
error( QString( "Cannot load provider %1 with URI: %2" ).arg( theExpectedKey ).arg( theExpectedUri ), mReport );
ok = false;
}
if ( !ok ) return false;
mReport += QString( "Verified URI: %1<br>" ).arg( theVerifiedUri.replace( "&", "&" ) );
mReport += QString( "Expected URI: %1<br>" ).arg( theExpectedUri.replace( "&", "&" ) );
mReport += "<br>";
mReport += QString( "<table style='%1'>\n" ).arg( mTabStyle );
mReport += compareHead();
compare( "Band count", verifiedProvider->bandCount(), expectedProvider->bandCount(), mReport, ok );
compare( "Width", verifiedProvider->xSize(), expectedProvider->xSize(), mReport, ok );
compare( "Height", verifiedProvider->ySize(), expectedProvider->ySize(), mReport, ok );
compareRow( "Extent", verifiedProvider->extent().toString(), expectedProvider->extent().toString(), mReport, verifiedProvider->extent() == expectedProvider->extent() );
if ( verifiedProvider->extent() != expectedProvider->extent() ) ok = false;
mReport += "</table>\n";
if ( !ok ) return false;
bool allOk = true;
for ( int band = 1; band <= expectedProvider->bandCount(); band++ )
{
bool bandOk = true;
mReport += QString( "<h3>Band %1</h3>\n" ).arg( band );
mReport += QString( "<table style='%1'>\n" ).arg( mTabStyle );
mReport += compareHead();
// Data types may differ (?)
bool typesOk = true;
compare( "Source data type", verifiedProvider->srcDataType( band ), expectedProvider->srcDataType( band ), mReport, typesOk );
compare( "Data type", verifiedProvider->dataType( band ), expectedProvider->dataType( band ), mReport, typesOk ) ;
// TODO: not yet sure if noDataValue() should exist at all
//compare( "No data (NULL) value", verifiedProvider->noDataValue( band ), expectedProvider->noDataValue( band ), mReport, typesOk );
bool statsOk = true;
QgsRasterBandStats verifiedStats = verifiedProvider->bandStatistics( band );
QgsRasterBandStats expectedStats = expectedProvider->bandStatistics( band );
// Min/max may 'slightly' differ, for big numbers however, the difference may
// be quite big, for example for Float32 with max -3.332e+38, the difference is 1.47338e+24
double tol = tolerance( expectedStats.minimumValue );
compare( "Minimum value", verifiedStats.minimumValue, expectedStats.minimumValue, mReport, statsOk, tol );
tol = tolerance( expectedStats.maximumValue );
compare( "Maximum value", verifiedStats.maximumValue, expectedStats.maximumValue, mReport, statsOk, tol );
// TODO: enable once fixed (WCS excludes nulls but GDAL does not)
//compare( "Cells count", verifiedStats.elementCount, expectedStats.elementCount, mReport, statsOk );
tol = tolerance( expectedStats.mean );
compare( "Mean", verifiedStats.mean, expectedStats.mean, mReport, statsOk, tol );
// stdDev usually differ significantly
tol = tolerance( expectedStats.stdDev, 1 );
compare( "Standard deviation", verifiedStats.stdDev, expectedStats.stdDev, mReport, statsOk, tol );
mReport += "</table>";
mReport += "<br>";
if ( !bandOk )
{
allOk = false;
continue;
}
if ( !statsOk || !typesOk )
{
allOk = false;
// create values table anyway so that values are available
}
mReport += "<table><tr>";
mReport += "<td>Data comparison</td>";
mReport += QString( "<td style='%1 %2 border: 1px solid'>correct value</td>" ).arg( mCellStyle ).arg( mOkStyle );
mReport += "<td></td>";
mReport += QString( "<td style='%1 %2 border: 1px solid'>wrong value<br>expected value</td></tr>" ).arg( mCellStyle ).arg( mErrStyle );
mReport += "</tr></table>";
mReport += "<br>";
int width = expectedProvider->xSize();
int height = expectedProvider->ySize();
QgsRasterBlock *expectedBlock = expectedProvider->block( band, expectedProvider->extent(), width, height );
QgsRasterBlock *verifiedBlock = verifiedProvider->block( band, expectedProvider->extent(), width, height );
if ( !expectedBlock || !expectedBlock->isValid() ||
!verifiedBlock || !verifiedBlock->isValid() )
{
allOk = false;
mReport += "cannot read raster block";
continue;
}
// compare data values
QString htmlTable = QString( "<table style='%1'>" ).arg( mTabStyle );
for ( int row = 0; row < height; row ++ )
{
htmlTable += "<tr>";
for ( int col = 0; col < width; col ++ )
{
bool cellOk = true;
double verifiedVal = verifiedBlock->value( row, col );
double expectedVal = expectedBlock->value( row, col );
QString valStr;
if ( compare( verifiedVal, expectedVal, 0 ) )
{
valStr = QString( "%1" ).arg( verifiedVal );
}
else
{
cellOk = false;
allOk = false;
valStr = QString( "%1<br>%2" ).arg( verifiedVal ).arg( expectedVal );
}
htmlTable += QString( "<td style='%1 %2'>%3</td>" ).arg( mCellStyle ).arg( cellOk ? mOkStyle : mErrStyle ).arg( valStr );
}
htmlTable += "</tr>";
}
htmlTable += "</table>";
mReport += htmlTable;
delete expectedBlock;
delete verifiedBlock;
}
delete verifiedProvider;
delete expectedProvider;
return allOk;
}
QgsRasterBandStats QgsRasterInterface::bandStatistics( int theBandNo,
int theStats,
const QgsRectangle & theExtent,
int theSampleSize )
{
QgsDebugMsg( QString( "theBandNo = %1 theStats = %2 theSampleSize = %3" ).arg( theBandNo ).arg( theStats ).arg( theSampleSize ) );
// TODO: null values set on raster layer!!!
QgsRasterBandStats myRasterBandStats;
initStatistics( myRasterBandStats, theBandNo, theStats, theExtent, theSampleSize );
foreach ( QgsRasterBandStats stats, mStatistics )
{
if ( stats.contains( myRasterBandStats ) )
{
QgsDebugMsg( "Using cached statistics." );
return stats;
}
}
QgsRectangle myExtent = myRasterBandStats.extent;
int myWidth = myRasterBandStats.width;
int myHeight = myRasterBandStats.height;
//int myDataType = dataType( theBandNo );
int myXBlockSize = xBlockSize();
int myYBlockSize = yBlockSize();
if ( myXBlockSize == 0 ) // should not happen, but happens
{
myXBlockSize = 500;
}
if ( myYBlockSize == 0 ) // should not happen, but happens
{
myYBlockSize = 500;
}
int myNXBlocks = ( myWidth + myXBlockSize - 1 ) / myXBlockSize;
int myNYBlocks = ( myHeight + myYBlockSize - 1 ) / myYBlockSize;
double myXRes = myExtent.width() / myWidth;
double myYRes = myExtent.height() / myHeight;
// TODO: progress signals
// used by single pass stdev
double myMean = 0;
double mySumOfSquares = 0;
bool myFirstIterationFlag = true;
for ( int myYBlock = 0; myYBlock < myNYBlocks; myYBlock++ )
{
for ( int myXBlock = 0; myXBlock < myNXBlocks; myXBlock++ )
{
QgsDebugMsg( QString( "myYBlock = %1 myXBlock = %2" ).arg( myYBlock ).arg( myXBlock ) );
int myBlockWidth = qMin( myXBlockSize, myWidth - myXBlock * myXBlockSize );
int myBlockHeight = qMin( myYBlockSize, myHeight - myYBlock * myYBlockSize );
double xmin = myExtent.xMinimum() + myXBlock * myXBlockSize * myXRes;
double xmax = xmin + myBlockWidth * myXRes;
double ymin = myExtent.yMaximum() - myYBlock * myYBlockSize * myYRes;
double ymax = ymin - myBlockHeight * myYRes;
QgsRectangle myPartExtent( xmin, ymin, xmax, ymax );
QgsRasterBlock* blk = block( theBandNo, myPartExtent, myBlockWidth, myBlockHeight );
// Collect the histogram counts.
for ( qgssize i = 0; i < (( qgssize ) myBlockHeight ) * myBlockWidth; i++ )
{
if ( blk->isNoData( i ) ) continue; // NULL
double myValue = blk->value( i );
myRasterBandStats.sum += myValue;
myRasterBandStats.elementCount++;
if ( myFirstIterationFlag )
{
myFirstIterationFlag = false;
myRasterBandStats.minimumValue = myValue;
myRasterBandStats.maximumValue = myValue;
}
else
{
if ( myValue < myRasterBandStats.minimumValue )
{
myRasterBandStats.minimumValue = myValue;
}
if ( myValue > myRasterBandStats.maximumValue )
{
myRasterBandStats.maximumValue = myValue;
}
}
// Single pass stdev
double myDelta = myValue - myMean;
myMean += myDelta / myRasterBandStats.elementCount;
mySumOfSquares += myDelta * ( myValue - myMean );
}
delete blk;
}
}
myRasterBandStats.range = myRasterBandStats.maximumValue - myRasterBandStats.minimumValue;
myRasterBandStats.mean = myRasterBandStats.sum / myRasterBandStats.elementCount;
myRasterBandStats.sumOfSquares = mySumOfSquares; // OK with single pass?
// stdDev may differ from GDAL stats, because GDAL is using naive single pass
// algorithm which is more error prone (because of rounding errors)
// Divide result by sample size - 1 and get square root to get stdev
myRasterBandStats.stdDev = sqrt( mySumOfSquares / ( myRasterBandStats.elementCount - 1 ) );
QgsDebugMsg( "************ STATS **************" );
QgsDebugMsg( QString( "MIN %1" ).arg( myRasterBandStats.minimumValue ) );
QgsDebugMsg( QString( "MAX %1" ).arg( myRasterBandStats.maximumValue ) );
QgsDebugMsg( QString( "RANGE %1" ).arg( myRasterBandStats.range ) );
QgsDebugMsg( QString( "MEAN %1" ).arg( myRasterBandStats.mean ) );
QgsDebugMsg( QString( "STDDEV %1" ).arg( myRasterBandStats.stdDev ) );
myRasterBandStats.statsGathered = QgsRasterBandStats::All;
mStatistics.append( myRasterBandStats );
return myRasterBandStats;
}
QgsRasterBlock *QgsRasterDataProvider::block( int bandNo, QgsRectangle const &boundingBox, int width, int height, QgsRasterBlockFeedback *feedback )
{
QgsDebugMsgLevel( QString( "bandNo = %1 width = %2 height = %3" ).arg( bandNo ).arg( width ).arg( height ), 4 );
QgsDebugMsgLevel( QString( "boundingBox = %1" ).arg( boundingBox.toString() ), 4 );
QgsRasterBlock *block = new QgsRasterBlock( dataType( bandNo ), width, height );
if ( sourceHasNoDataValue( bandNo ) && useSourceNoDataValue( bandNo ) )
{
block->setNoDataValue( sourceNoDataValue( bandNo ) );
}
if ( block->isEmpty() )
{
QgsDebugMsg( "Couldn't create raster block" );
return block;
}
// Read necessary extent only
QgsRectangle tmpExtent = extent().intersect( &boundingBox );
if ( tmpExtent.isEmpty() )
{
QgsDebugMsg( "Extent outside provider extent" );
block->setIsNoData();
return block;
}
double xRes = boundingBox.width() / width;
double yRes = boundingBox.height() / height;
double tmpXRes, tmpYRes;
double providerXRes = 0;
double providerYRes = 0;
if ( capabilities() & Size )
{
providerXRes = extent().width() / xSize();
providerYRes = extent().height() / ySize();
tmpXRes = std::max( providerXRes, xRes );
tmpYRes = std::max( providerYRes, yRes );
if ( qgsDoubleNear( tmpXRes, xRes ) ) tmpXRes = xRes;
if ( qgsDoubleNear( tmpYRes, yRes ) ) tmpYRes = yRes;
}
else
{
tmpXRes = xRes;
tmpYRes = yRes;
}
if ( tmpExtent != boundingBox ||
tmpXRes > xRes || tmpYRes > yRes )
{
// Read smaller extent or lower resolution
if ( !extent().contains( boundingBox ) )
{
QRect subRect = QgsRasterBlock::subRect( boundingBox, width, height, extent() );
block->setIsNoDataExcept( subRect );
}
// Calculate row/col limits (before tmpExtent is aligned)
int fromRow = std::round( ( boundingBox.yMaximum() - tmpExtent.yMaximum() ) / yRes );
int toRow = std::round( ( boundingBox.yMaximum() - tmpExtent.yMinimum() ) / yRes ) - 1;
int fromCol = std::round( ( tmpExtent.xMinimum() - boundingBox.xMinimum() ) / xRes );
int toCol = std::round( ( tmpExtent.xMaximum() - boundingBox.xMinimum() ) / xRes ) - 1;
QgsDebugMsgLevel( QString( "fromRow = %1 toRow = %2 fromCol = %3 toCol = %4" ).arg( fromRow ).arg( toRow ).arg( fromCol ).arg( toCol ), 4 );
if ( fromRow < 0 || fromRow >= height || toRow < 0 || toRow >= height ||
fromCol < 0 || fromCol >= width || toCol < 0 || toCol >= width )
{
// Should not happen
QgsDebugMsg( "Row or column limits out of range" );
return block;
}
// If lower source resolution is used, the extent must beS aligned to original
// resolution to avoid possible shift due to resampling
if ( tmpXRes > xRes )
{
int col = std::floor( ( tmpExtent.xMinimum() - extent().xMinimum() ) / providerXRes );
tmpExtent.setXMinimum( extent().xMinimum() + col * providerXRes );
col = std::ceil( ( tmpExtent.xMaximum() - extent().xMinimum() ) / providerXRes );
tmpExtent.setXMaximum( extent().xMinimum() + col * providerXRes );
}
if ( tmpYRes > yRes )
{
int row = std::floor( ( extent().yMaximum() - tmpExtent.yMaximum() ) / providerYRes );
tmpExtent.setYMaximum( extent().yMaximum() - row * providerYRes );
row = std::ceil( ( extent().yMaximum() - tmpExtent.yMinimum() ) / providerYRes );
tmpExtent.setYMinimum( extent().yMaximum() - row * providerYRes );
}
int tmpWidth = std::round( tmpExtent.width() / tmpXRes );
int tmpHeight = std::round( tmpExtent.height() / tmpYRes );
tmpXRes = tmpExtent.width() / tmpWidth;
tmpYRes = tmpExtent.height() / tmpHeight;
QgsDebugMsgLevel( QString( "Reading smaller block tmpWidth = %1 height = %2" ).arg( tmpWidth ).arg( tmpHeight ), 4 );
QgsDebugMsgLevel( QString( "tmpExtent = %1" ).arg( tmpExtent.toString() ), 4 );
QgsRasterBlock *tmpBlock = new QgsRasterBlock( dataType( bandNo ), tmpWidth, tmpHeight );
if ( sourceHasNoDataValue( bandNo ) && useSourceNoDataValue( bandNo ) )
{
tmpBlock->setNoDataValue( sourceNoDataValue( bandNo ) );
}
readBlock( bandNo, tmpExtent, tmpWidth, tmpHeight, tmpBlock->bits(), feedback );
int pixelSize = dataTypeSize( bandNo );
double xMin = boundingBox.xMinimum();
double yMax = boundingBox.yMaximum();
double tmpXMin = tmpExtent.xMinimum();
double tmpYMax = tmpExtent.yMaximum();
for ( int row = fromRow; row <= toRow; row++ )
{
double y = yMax - ( row + 0.5 ) * yRes;
int tmpRow = std::floor( ( tmpYMax - y ) / tmpYRes );
for ( int col = fromCol; col <= toCol; col++ )
{
double x = xMin + ( col + 0.5 ) * xRes;
int tmpCol = std::floor( ( x - tmpXMin ) / tmpXRes );
if ( tmpRow < 0 || tmpRow >= tmpHeight || tmpCol < 0 || tmpCol >= tmpWidth )
{
QgsDebugMsg( "Source row or column limits out of range" );
block->setIsNoData(); // so that the problem becomes obvious and fixed
delete tmpBlock;
return block;
}
qgssize tmpIndex = static_cast< qgssize >( tmpRow ) * static_cast< qgssize >( tmpWidth ) + tmpCol;
qgssize index = row * static_cast< qgssize >( width ) + col;
char *tmpBits = tmpBlock->bits( tmpIndex );
char *bits = block->bits( index );
if ( !tmpBits )
{
QgsDebugMsg( QString( "Cannot get input block data tmpRow = %1 tmpCol = %2 tmpIndex = %3." ).arg( tmpRow ).arg( tmpCol ).arg( tmpIndex ) );
continue;
}
if ( !bits )
{
QgsDebugMsg( "Cannot set output block data." );
continue;
}
memcpy( bits, tmpBits, pixelSize );
}
}
delete tmpBlock;
}
else
{
readBlock( bandNo, boundingBox, width, height, block->bits(), feedback );
}
// apply scale and offset
block->applyScaleOffset( bandScale( bandNo ), bandOffset( bandNo ) );
// apply user no data values
block->applyNoDataValues( userNoDataValues( bandNo ) );
return block;
}
QgsRasterBlock * QgsRasterProjector::block( int bandNo, QgsRectangle const & extent, int width, int height )
{
QgsDebugMsg( QString( "extent:\n%1" ).arg( extent.toString() ) );
QgsDebugMsg( QString( "width = %1 height = %2" ).arg( width ).arg( height ) );
if ( !mInput )
{
QgsDebugMsg( "Input not set" );
return new QgsRasterBlock();
}
if ( ! mSrcCRS.isValid() || ! mDestCRS.isValid() || mSrcCRS == mDestCRS )
{
QgsDebugMsg( "No projection necessary" );
return mInput->block( bandNo, extent, width, height );
}
mDestExtent = extent;
mDestRows = height;
mDestCols = width;
calc();
QgsDebugMsg( QString( "srcExtent:\n%1" ).arg( srcExtent().toString() ) );
QgsDebugMsg( QString( "srcCols = %1 srcRows = %2" ).arg( srcCols() ).arg( srcRows() ) );
// If we zoom out too much, projector srcRows / srcCols maybe 0, which can cause problems in providers
if ( srcRows() <= 0 || srcCols() <= 0 )
{
QgsDebugMsg( "Zero srcRows or srcCols" );
return new QgsRasterBlock();
}
QgsRasterBlock *inputBlock = mInput->block( bandNo, srcExtent(), srcCols(), srcRows() );
if ( !inputBlock || inputBlock->isEmpty() )
{
QgsDebugMsg( "No raster data!" );
delete inputBlock;
return new QgsRasterBlock();
}
qgssize pixelSize = QgsRasterBlock::typeSize( mInput->dataType( bandNo ) );
QgsRasterBlock *outputBlock;
if ( inputBlock->hasNoDataValue() )
{
outputBlock = new QgsRasterBlock( inputBlock->dataType(), width, height, inputBlock->noDataValue() );
}
else
{
outputBlock = new QgsRasterBlock( inputBlock->dataType(), width, height );
}
if ( !outputBlock->isValid() )
{
QgsDebugMsg( "Cannot create block" );
delete inputBlock;
return outputBlock;
}
// set output to no data, it should be fast
outputBlock->setIsNoData();
// No data: because isNoData()/setIsNoData() is slow with respect to simple memcpy,
// we use if only if necessary:
// 1) no data value exists (numerical) -> memcpy, not necessary isNoData()/setIsNoData()
// 2) no data value does not exist but it may contain no data (numerical no data bitmap)
// -> must use isNoData()/setIsNoData()
// 3) no data are not used (no no data value, no no data bitmap) -> simple memcpy
// 4) image - simple memcpy
// To copy no data values stored in bitmaps we have to use isNoData()/setIsNoData(),
// we cannot fill output block with no data because we use memcpy for data, not setValue().
bool doNoData = !QgsRasterBlock::typeIsNumeric( inputBlock->dataType() ) && inputBlock->hasNoData() && !inputBlock->hasNoDataValue();
const QgsCoordinateTransform* inverseCt = nullptr;
if ( !mApproximate )
{
inverseCt = QgsCoordinateTransformCache::instance()->transform( mDestCRS.authid(), mSrcCRS.authid(), mDestDatumTransform, mSrcDatumTransform );
}
outputBlock->setIsNoData();
int srcRow, srcCol;
for ( int i = 0; i < height; ++i )
{
for ( int j = 0; j < width; ++j )
{
bool inside = srcRowCol( i, j, &srcRow, &srcCol, inverseCt );
if ( !inside ) continue; // we have everything set to no data
qgssize srcIndex = ( qgssize )srcRow * mSrcCols + srcCol;
QgsDebugMsgLevel( QString( "row = %1 col = %2 srcRow = %3 srcCol = %4" ).arg( i ).arg( j ).arg( srcRow ).arg( srcCol ), 5 );
// isNoData() may be slow so we check doNoData first
if ( doNoData && inputBlock->isNoData( srcRow, srcCol ) )
{
outputBlock->setIsNoData( i, j );
continue;
}
qgssize destIndex = ( qgssize )i * width + j;
char *srcBits = inputBlock->bits( srcIndex );
char *destBits = outputBlock->bits( destIndex );
if ( !srcBits )
{
QgsDebugMsg( QString( "Cannot get input block data: row = %1 col = %2" ).arg( i ).arg( j ) );
continue;
}
if ( !destBits )
{
QgsDebugMsg( QString( "Cannot set output block data: srcRow = %1 srcCol = %2" ).arg( srcRow ).arg( srcCol ) );
continue;
}
memcpy( destBits, srcBits, pixelSize );
outputBlock->setIsData( i, j );
}
}
delete inputBlock;
return outputBlock;
}