GDALRasterBand *GDALOverviewBand::GetOverview(int iOvr)
{
if( iOvr < 0 || iOvr >= GetOverviewCount() )
return NULL;
GDALOverviewDataset* poOvrDS = (GDALOverviewDataset*)poDS;
GDALDataset* poMainDS = poOvrDS->poMainDS;
return poMainDS->GetRasterBand(nBand)->GetOverview(iOvr + poOvrDS->nOvrLevel + 1);
}
CPLErr PostGISRasterRasterBand::ComputeRasterMinMax( int bApproxOK, double* adfMinMax )
{
if( nRasterXSize < 1024 && nRasterYSize < 1024 )
return VRTSourcedRasterBand::ComputeRasterMinMax(bApproxOK, adfMinMax);
int nOverviewCount = GetOverviewCount();
for(int i = 0; i < nOverviewCount; i++)
{
if( GetOverview(i)->GetXSize() < 1024 && GetOverview(i)->GetYSize() < 1024 )
return GetOverview(i)->ComputeRasterMinMax(bApproxOK, adfMinMax);
}
return CE_Failure;
}
CPLErr VRTRawRasterBand::IRasterIO( GDALRWFlag eRWFlag,
int nXOff, int nYOff,
int nXSize, int nYSize,
void * pData, int nBufXSize, int nBufYSize,
GDALDataType eBufType,
GSpacing nPixelSpace,
GSpacing nLineSpace,
GDALRasterIOExtraArg* psExtraArg )
{
if( m_poRawRaster == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"No raw raster band configured on VRTRawRasterBand." );
return CE_Failure;
}
if( eRWFlag == GF_Write && eAccess == GA_ReadOnly )
{
CPLError( CE_Failure, CPLE_NoWriteAccess,
"Attempt to write to read only dataset in"
"VRTRawRasterBand::IRasterIO()." );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Do we have overviews that would be appropriate to satisfy */
/* this request? */
/* -------------------------------------------------------------------- */
if( (nBufXSize < nXSize || nBufYSize < nYSize)
&& GetOverviewCount() > 0 )
{
if( OverviewRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nPixelSpace,
nLineSpace, psExtraArg ) == CE_None )
return CE_None;
}
m_poRawRaster->SetAccess(eAccess);
return m_poRawRaster->RasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nPixelSpace,
nLineSpace, psExtraArg );
}
SDERasterBand::SDERasterBand( SDEDataset *poDS,
int nBand,
int nOverview,
const SE_RASBANDINFO* band )
{
// Carry some of the data we were given at construction.
// If we were passed -1 for an overview at construction, reset it
// to 0 to ensure we get the zero'th level from SDE.
// The SE_RASBANDINFO* we were given is actually owned by the
// dataset. We want it around for convenience.
this->poDS = poDS;
this->nBand = nBand;
this->nOverview = nOverview;
this->poBand = band;
// Initialize our SDE opaque object pointers to NULL.
// The nOverviews private data member will be updated when
// GetOverviewCount is called and subsequently returned immediately in
// later calls if it has been set to anything other than 0.
this->hConstraint = NULL;
this->hQuery = NULL;
this->poColorTable = NULL;
if (this->nOverview == -1 || this->nOverview == 0)
this->nOverviews = GetOverviewCount();
else
this->nOverviews = 0;
if (nOverview == -1) {
this->papoOverviews = (GDALRasterBand**) CPLMalloc( nOverviews * sizeof(GDALRasterBand*) );
}
else {
this->papoOverviews = NULL;
}
this->eDataType = GetRasterDataType();
// nSDERasterType is set by GetRasterDataType
this->dfDepth = MorphESRIRasterDepth(nSDERasterType);
InitializeBand(this->nOverview);
}
/**********************************************************
* \brief Fetch overview raster band object
**********************************************************/
GDALRasterBand * PostGISRasterRasterBand::GetOverview(int i)
{
if (i < 0 || i >= GetOverviewCount())
return NULL;
PostGISRasterDataset* poRDS = (PostGISRasterDataset *)poDS;
PostGISRasterDataset* poOverviewDS = poRDS->GetOverviewDS(i);
if( poOverviewDS->nBands == 0 )
{
if (!poOverviewDS->SetRasterProperties(NULL) ||
poOverviewDS->GetRasterCount() != poRDS->GetRasterCount())
{
CPLDebug("PostGIS_Raster",
"Request for overview %d of band %d failed", i, nBand);
return NULL;
}
}
return poOverviewDS->GetRasterBand(nBand);
}
CPLErr VRTSourcedRasterBand::IRasterIO( GDALRWFlag eRWFlag,
int nXOff, int nYOff, int nXSize, int nYSize,
void * pData, int nBufXSize, int nBufYSize,
GDALDataType eBufType,
int nPixelSpace, int nLineSpace )
{
int iSource;
CPLErr eErr = CE_None;
if( eRWFlag == GF_Write )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Writing through VRTSourcedRasterBand is not supported." );
return CE_Failure;
}
/* When using GDALProxyPoolDataset for sources, the recusion will not be */
/* detected at VRT opening but when doing RasterIO. As the proxy pool will */
/* return the already opened dataset, we can just test a member variable. */
if ( bAlreadyInIRasterIO )
{
CPLError( CE_Failure, CPLE_AppDefined,
"VRTSourcedRasterBand::IRasterIO() called recursively on the same band. "
"It looks like the VRT is referencing itself." );
return CE_Failure;
}
/* ==================================================================== */
/* Do we have overviews that would be appropriate to satisfy */
/* this request? */
/* ==================================================================== */
if( (nBufXSize < nXSize || nBufYSize < nYSize)
&& GetOverviewCount() > 0 )
{
if( OverviewRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nPixelSpace, nLineSpace ) == CE_None )
return CE_None;
}
/* -------------------------------------------------------------------- */
/* Initialize the buffer to some background value. Use the */
/* nodata value if available. */
/* -------------------------------------------------------------------- */
if ( nPixelSpace == GDALGetDataTypeSize(eBufType)/8 &&
(!bNoDataValueSet || (!CPLIsNan(dfNoDataValue) && dfNoDataValue == 0)) )
{
if (nLineSpace == nBufXSize * nPixelSpace)
{
memset( pData, 0, nBufYSize * nLineSpace );
}
else
{
int iLine;
for( iLine = 0; iLine < nBufYSize; iLine++ )
{
memset( ((GByte*)pData) + iLine * nLineSpace, 0, nBufXSize * nPixelSpace );
}
}
}
else if ( !bEqualAreas || bNoDataValueSet )
{
double dfWriteValue = 0.0;
int iLine;
if( bNoDataValueSet )
dfWriteValue = dfNoDataValue;
for( iLine = 0; iLine < nBufYSize; iLine++ )
{
GDALCopyWords( &dfWriteValue, GDT_Float64, 0,
((GByte *)pData) + nLineSpace * iLine,
eBufType, nPixelSpace, nBufXSize );
}
}
/* -------------------------------------------------------------------- */
/* Do we have overviews that would be appropriate to satisfy */
/* this request? */
/* -------------------------------------------------------------------- */
if( (nBufXSize < nXSize || nBufYSize < nYSize)
&& GetOverviewCount() > 0 )
{
if( OverviewRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nPixelSpace, nLineSpace ) == CE_None )
return CE_None;
}
bAlreadyInIRasterIO = TRUE;
/* -------------------------------------------------------------------- */
/* Overlay each source in turn over top this. */
/* -------------------------------------------------------------------- */
for( iSource = 0; eErr == CE_None && iSource < nSources; iSource++ )
{
eErr =
papoSources[iSource]->RasterIO( nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nPixelSpace, nLineSpace);
}
bAlreadyInIRasterIO = FALSE;
return eErr;
}
CPLErr RawRasterBand::IRasterIO( GDALRWFlag eRWFlag,
int nXOff, int nYOff, int nXSize, int nYSize,
void * pData, int nBufXSize, int nBufYSize,
GDALDataType eBufType,
int nPixelSpace, int nLineSpace )
{
int nBandDataSize = GDALGetDataTypeSize(eDataType) / 8;
int nBufDataSize = GDALGetDataTypeSize( eBufType ) / 8;
int nBytesToRW = nPixelOffset * nXSize;
if( !CanUseDirectIO(nXOff, nYOff, nXSize, nYSize, eBufType ) )
{
return GDALRasterBand::IRasterIO( eRWFlag, nXOff, nYOff,
nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType,
nPixelSpace, nLineSpace );
}
CPLDebug("RAW", "Using direct IO implementation");
/* ==================================================================== */
/* Read data. */
/* ==================================================================== */
if ( eRWFlag == GF_Read )
{
/* -------------------------------------------------------------------- */
/* Do we have overviews that would be appropriate to satisfy */
/* this request? */
/* -------------------------------------------------------------------- */
if( (nBufXSize < nXSize || nBufYSize < nYSize)
&& GetOverviewCount() > 0 )
{
if( OverviewRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nPixelSpace, nLineSpace ) == CE_None )
return CE_None;
}
/* ==================================================================== */
/* 1. Simplest case when we should get contiguous block */
/* of uninterleaved pixels. */
/* ==================================================================== */
if ( nXSize == GetXSize()
&& nXSize == nBufXSize
&& nYSize == nBufYSize
&& eBufType == eDataType
&& nPixelOffset == nBandDataSize
&& nPixelSpace == nBufDataSize
&& nLineSpace == nPixelSpace * nXSize )
{
vsi_l_offset nOffset = nImgOffset
+ (vsi_l_offset)nYOff * nLineOffset + nXOff;
if ( AccessBlock( nOffset,
nXSize * nYSize * nBandDataSize, pData ) != CE_None )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read %d bytes at " CPL_FRMT_GUIB ".",
nXSize * nYSize * nBandDataSize, nOffset);
}
}
/* ==================================================================== */
/* 2. Case when we need deinterleave and/or subsample data. */
/* ==================================================================== */
else
{
GByte *pabyData;
double dfSrcXInc, dfSrcYInc;
int iLine;
dfSrcXInc = (double)nXSize / nBufXSize;
dfSrcYInc = (double)nYSize / nBufYSize;
pabyData = (GByte *) CPLMalloc( nBytesToRW );
for ( iLine = 0; iLine < nBufYSize; iLine++ )
{
vsi_l_offset nOffset = nImgOffset
+ ((vsi_l_offset)nYOff
+ (vsi_l_offset)(iLine * dfSrcYInc)) * nLineOffset
+ nXOff * nPixelOffset;
if ( AccessBlock( nOffset,
nBytesToRW, pabyData ) != CE_None )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read %d bytes at " CPL_FRMT_GUIB ".",
nBytesToRW, nOffset );
}
/* -------------------------------------------------------------------- */
/* Copy data from disk buffer to user block buffer and subsample, */
/* if needed. */
/* -------------------------------------------------------------------- */
if ( nXSize == nBufXSize && nYSize == nBufYSize )
{
GDALCopyWords( pabyData, eDataType, nPixelOffset,
(GByte *)pData + (vsi_l_offset)iLine * nLineSpace,
eBufType, nPixelSpace, nXSize );
}
else
{
int iPixel;
for ( iPixel = 0; iPixel < nBufXSize; iPixel++ )
{
GDALCopyWords( pabyData +
(vsi_l_offset)(iPixel * dfSrcXInc) * nPixelOffset,
eDataType, nPixelOffset,
(GByte *)pData + (vsi_l_offset)iLine * nLineSpace +
(vsi_l_offset)iPixel * nPixelSpace,
eBufType, nPixelSpace, 1 );
}
}
}
CPLFree( pabyData );
}
}
/* ==================================================================== */
/* Write data. */
/* ==================================================================== */
else
{
int nBytesActuallyWritten;
/* ==================================================================== */
/* 1. Simplest case when we should write contiguous block */
/* of uninterleaved pixels. */
/* ==================================================================== */
if ( nXSize == GetXSize()
&& nXSize == nBufXSize
&& nYSize == nBufYSize
&& eBufType == eDataType
&& nPixelOffset == nBandDataSize
&& nPixelSpace == nBufDataSize
&& nLineSpace == nPixelSpace * nXSize )
{
/* -------------------------------------------------------------------- */
/* Byte swap the data buffer, if required. */
/* -------------------------------------------------------------------- */
if( !bNativeOrder && eDataType != GDT_Byte )
{
if( GDALDataTypeIsComplex( eDataType ) )
{
int nWordSize;
nWordSize = GDALGetDataTypeSize(eDataType)/16;
GDALSwapWords( pData, nWordSize, nXSize, nPixelOffset );
GDALSwapWords( ((GByte *) pData) + nWordSize,
nWordSize, nXSize, nPixelOffset );
}
else
GDALSwapWords( pData, nBandDataSize, nXSize, nPixelOffset );
}
/* -------------------------------------------------------------------- */
/* Seek to the right block. */
/* -------------------------------------------------------------------- */
vsi_l_offset nOffset = nImgOffset + (vsi_l_offset)nYOff * nLineOffset + nXOff;
if( Seek( nOffset, SEEK_SET) == -1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to seek to " CPL_FRMT_GUIB " to write data.\n",
nOffset);
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Write the block. */
/* -------------------------------------------------------------------- */
nBytesToRW = nXSize * nYSize * nBandDataSize;
nBytesActuallyWritten = Write( pData, 1, nBytesToRW );
if( nBytesActuallyWritten < nBytesToRW )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to write %d bytes to file. %d bytes written",
nBytesToRW, nBytesActuallyWritten );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Byte swap (if necessary) back into machine order so the */
/* buffer is still usable for reading purposes. */
/* -------------------------------------------------------------------- */
if( !bNativeOrder && eDataType != GDT_Byte )
{
if( GDALDataTypeIsComplex( eDataType ) )
{
int nWordSize;
nWordSize = GDALGetDataTypeSize(eDataType)/16;
GDALSwapWords( pData, nWordSize, nXSize, nPixelOffset );
GDALSwapWords( ((GByte *) pData) + nWordSize,
nWordSize, nXSize, nPixelOffset );
}
else
GDALSwapWords( pData, nBandDataSize, nXSize, nPixelOffset );
}
}
/* ==================================================================== */
/* 2. Case when we need deinterleave and/or subsample data. */
/* ==================================================================== */
else
{
GByte *pabyData;
double dfSrcXInc, dfSrcYInc;
vsi_l_offset nBlockOff;
int iLine;
dfSrcXInc = (double)nXSize / nBufXSize;
dfSrcYInc = (double)nYSize / nBufYSize;
pabyData = (GByte *) CPLMalloc( nBytesToRW );
for ( iLine = 0; iLine < nBufYSize; iLine++ )
{
nBlockOff = nImgOffset
+ ((vsi_l_offset)nYOff + (vsi_l_offset)(iLine*dfSrcYInc))*nLineOffset
+ nXOff * nPixelOffset;
/* -------------------------------------------------------------------- */
/* If the data for this band is completely contiguous we don't */
/* have to worry about pre-reading from disk. */
/* -------------------------------------------------------------------- */
if( nPixelOffset > nBandDataSize )
AccessBlock( nBlockOff, nBytesToRW, pabyData );
/* -------------------------------------------------------------------- */
/* Copy data from user block buffer to disk buffer and subsample, */
/* if needed. */
/* -------------------------------------------------------------------- */
if ( nXSize == nBufXSize && nYSize == nBufYSize )
{
GDALCopyWords( (GByte *)pData + (vsi_l_offset)iLine * nLineSpace,
eBufType, nPixelSpace,
pabyData, eDataType, nPixelOffset, nXSize );
}
else
{
int iPixel;
for ( iPixel = 0; iPixel < nBufXSize; iPixel++ )
{
GDALCopyWords( (GByte *)pData+(vsi_l_offset)iLine*nLineSpace +
(vsi_l_offset)iPixel * nPixelSpace,
eBufType, nPixelSpace,
pabyData +
(vsi_l_offset)(iPixel * dfSrcXInc) * nPixelOffset,
eDataType, nPixelOffset, 1 );
}
}
/* -------------------------------------------------------------------- */
/* Byte swap the data buffer, if required. */
/* -------------------------------------------------------------------- */
if( !bNativeOrder && eDataType != GDT_Byte )
{
if( GDALDataTypeIsComplex( eDataType ) )
{
int nWordSize;
nWordSize = GDALGetDataTypeSize(eDataType)/16;
GDALSwapWords( pabyData, nWordSize, nXSize, nPixelOffset );
GDALSwapWords( ((GByte *) pabyData) + nWordSize,
nWordSize, nXSize, nPixelOffset );
}
else
GDALSwapWords( pabyData, nBandDataSize, nXSize,
nPixelOffset );
}
/* -------------------------------------------------------------------- */
/* Seek to the right line in block. */
/* -------------------------------------------------------------------- */
if( Seek( nBlockOff, SEEK_SET) == -1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to seek to " CPL_FRMT_GUIB " to read.\n",
nBlockOff );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Write the line of block. */
/* -------------------------------------------------------------------- */
nBytesActuallyWritten = Write( pabyData, 1, nBytesToRW );
if( nBytesActuallyWritten < nBytesToRW )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to write %d bytes to file. %d bytes written",
nBytesToRW, nBytesActuallyWritten );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Byte swap (if necessary) back into machine order so the */
/* buffer is still usable for reading purposes. */
/* -------------------------------------------------------------------- */
if( !bNativeOrder && eDataType != GDT_Byte )
{
if( GDALDataTypeIsComplex( eDataType ) )
{
int nWordSize;
nWordSize = GDALGetDataTypeSize(eDataType)/16;
GDALSwapWords( pabyData, nWordSize, nXSize, nPixelOffset );
GDALSwapWords( ((GByte *) pabyData) + nWordSize,
nWordSize, nXSize, nPixelOffset );
}
else
GDALSwapWords( pabyData, nBandDataSize, nXSize,
nPixelOffset );
}
}
bDirty = TRUE;
CPLFree( pabyData );
}
}
return CE_None;
}
CPLErr PostGISRasterRasterBand::IRasterIO(GDALRWFlag eRWFlag, int nXOff,
int nYOff, int nXSize, int nYSize, void * pData, int nBufXSize,
int nBufYSize, GDALDataType eBufType, int nPixelSpace,
int nLineSpace)
{
PostGISRasterDataset * poRDS = (PostGISRasterDataset *)poDS;
CPLDebug("PostGIS_Raster",
"PostGISRasterRasterBand::IRasterIO(): Table %s.%s (%s), Srid : %d",
pszSchema, pszTable, pszColumn, poRDS->nSrid);
if (eRWFlag == GF_Write) {
/*
ReportError(CE_Failure, CPLE_NotSupported,
"Writing through PostGIS Raster band not supported yet");
return CE_Failure;
*/
// Delegate in generic IRasterIO to force IWriteBlock call.
// TODO: This is not a solution for UPDATE scenario, but it works
// for CREATE scenario.
return GDALRasterBand::IRasterIO(eRWFlag, nXOff, nYOff, nXSize,
nYSize, pData, nBufXSize, nBufYSize, eBufType, nPixelSpace,
nLineSpace);
}
/*******************************************************************
* Do we have overviews that would be appropriate to satisfy this
* request?
******************************************************************/
if( (nBufXSize < nXSize || nBufYSize < nYSize) &&
GetOverviewCount() > 0 && eRWFlag == GF_Read)
{
if(OverviewRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize, eBufType, nPixelSpace,
nLineSpace) == CE_None)
return CE_None;
}
int bSameWindowAsOtherBand =
(nXOff == poRDS->nXOffPrev &&
nYOff == poRDS->nYOffPrev &&
nXSize == poRDS->nXSizePrev &&
nYSize == poRDS->nYSizePrev);
poRDS->nXOffPrev = nXOff;
poRDS->nYOffPrev = nYOff;
poRDS->nXSizePrev = nXSize;
poRDS->nYSizePrev = nYSize;
/* Logic to determine if bands are read in order 1, 2, ... N */
/* If so, then use multi-band caching, otherwise do just single band caching */
if( poRDS->bAssumeMultiBandReadPattern )
{
if( nBand != poRDS->nNextExpectedBand )
{
CPLDebug("PostGIS_Raster",
"Disabling multi-band caching since band access pattern does not match");
poRDS->bAssumeMultiBandReadPattern = false;
poRDS->nNextExpectedBand = 1;
}
else
{
poRDS->nNextExpectedBand ++;
if( poRDS->nNextExpectedBand > poRDS->GetRasterCount() )
poRDS->nNextExpectedBand = 1;
}
}
else
{
if( nBand == poRDS->nNextExpectedBand )
{
poRDS->nNextExpectedBand ++;
if( poRDS->nNextExpectedBand > poRDS->GetRasterCount() )
{
CPLDebug("PostGIS_Raster", "Re-enabling multi-band caching");
poRDS->bAssumeMultiBandReadPattern = true;
poRDS->nNextExpectedBand = 1;
}
}
}
#ifdef DEBUG_VERBOSE
CPLDebug("PostGIS_Raster",
"PostGISRasterRasterBand::IRasterIO: "
"nBand = %d, nXOff = %d, nYOff = %d, nXSize = %d, nYSize = %d, nBufXSize = %d, nBufYSize = %d",
nBand, nXOff, nYOff, nXSize, nYSize, nBufXSize, nBufYSize);
#endif
#ifdef notdef
/*******************************************************************
* Optimization: We just have one tile. So, we can read it with
* IReadBlock
*
* TODO: Review it. It's not working (see comment in
* PostGISRasterDataset::ConstructOneDatasetFromTiles)
******************************************************************/
if (poRDS->nTiles == 1) {
return GDALRasterBand::IRasterIO(eRWFlag, nXOff, nYOff, nXSize,
nYSize, pData, nBufXSize, nBufYSize, eBufType, nPixelSpace,
nLineSpace);
}
#endif
/*******************************************************************
* Several tiles: we first look in all our sources caches. Missing
* blocks are queried
******************************************************************/
double adfProjWin[8];
int nFeatureCount = 0;
CPLRectObj sAoi;
poRDS->PolygonFromCoords(nXOff, nYOff, nXOff + nXSize, nYOff + nYSize, adfProjWin);
// (p[6], p[7]) is the minimum (x, y), and (p[2], p[3]) the max
sAoi.minx = adfProjWin[6];
sAoi.maxx = adfProjWin[2];
if( adfProjWin[7] < adfProjWin[3] )
{
sAoi.miny = adfProjWin[7];
sAoi.maxy = adfProjWin[3];
}
else
{
sAoi.maxy = adfProjWin[7];
sAoi.miny = adfProjWin[3];
}
#ifdef DEBUG_VERBOSE
CPLDebug("PostGIS_Raster",
"PostGISRasterRasterBand::IRasterIO: "
"Intersection box: (%f, %f) - (%f, %f)", sAoi.minx,
sAoi.miny, sAoi.maxx, sAoi.maxy);
#endif
if (poRDS->hQuadTree == NULL)
{
ReportError(CE_Failure, CPLE_AppDefined,
"Could not read metadata index.");
return CE_Failure;
}
NullBuffer(pData, nBufXSize, nBufYSize, eBufType, nPixelSpace, nLineSpace);
if( poRDS->bBuildQuadTreeDynamically && !bSameWindowAsOtherBand )
{
if( !(poRDS->LoadSources(nXOff, nYOff, nXSize, nYSize, nBand)) )
return CE_Failure;
}
// Matching sources, to avoid a dumb for loop over the sources
PostGISRasterTileDataset ** papsMatchingTiles =
(PostGISRasterTileDataset **)
CPLQuadTreeSearch(poRDS->hQuadTree, &sAoi, &nFeatureCount);
// No blocks found. This is not an error (the raster may have holes)
if (nFeatureCount == 0) {
CPLFree(papsMatchingTiles);
return CE_None;
}
int i;
/**
* We need to store the max, min coords for the missing tiles in
* any place. This is as good as any other
**/
sAoi.minx = 0.0;
sAoi.miny = 0.0;
sAoi.maxx = 0.0;
sAoi.maxy = 0.0;
GIntBig nMemoryRequiredForTiles = 0;
CPLString osIDsToFetch;
int nTilesToFetch = 0;
int nBandDataTypeSize = GDALGetDataTypeSize(eDataType) / 8;
// Loop just over the intersecting sources
for(i = 0; i < nFeatureCount; i++) {
PostGISRasterTileDataset *poTile = papsMatchingTiles[i];
PostGISRasterTileRasterBand* poTileBand =
(PostGISRasterTileRasterBand *)poTile->GetRasterBand(nBand);
nMemoryRequiredForTiles += poTileBand->GetXSize() * poTileBand->GetYSize() *
nBandDataTypeSize;
// Missing tile: we'll need to query for it
if (!poTileBand->IsCached()) {
// If we have a PKID, add the tile PKID to the list
if (poTile->pszPKID != NULL)
{
if( osIDsToFetch.size() != 0 )
osIDsToFetch += ",";
osIDsToFetch += "'";
osIDsToFetch += poTile->pszPKID;
osIDsToFetch += "'";
}
double dfTileMinX, dfTileMinY, dfTileMaxX, dfTileMaxY;
poTile->GetExtent(&dfTileMinX, &dfTileMinY,
&dfTileMaxX, &dfTileMaxY);
/**
* We keep the general max and min values of all the missing
* tiles, to raise a query that intersect just that area.
*
* TODO: In case of just a few tiles and very separated,
* this strategy is clearly suboptimal. We'll get our
* missing tiles, but with a lot of other not needed tiles.
*
* A possible optimization will be to simply rely on the
* I/O method of the source (must be implemented), in case
* we have minus than a reasonable amount of tiles missing.
* Another criteria to decide would be how separated the
* tiles are. Two queries for just two adjacent tiles is
* also a dumb strategy.
**/
if( nTilesToFetch == 0 )
{
sAoi.minx = dfTileMinX;
sAoi.miny = dfTileMinY;
sAoi.maxx = dfTileMaxX;
sAoi.maxy = dfTileMaxY;
}
else
{
if (dfTileMinX < sAoi.minx)
sAoi.minx = dfTileMinX;
if (dfTileMinY < sAoi.miny)
sAoi.miny = dfTileMinY;
if (dfTileMaxX > sAoi.maxx)
sAoi.maxx = dfTileMaxX;
if (dfTileMaxY > sAoi.maxy)
sAoi.maxy = dfTileMaxY;
}
nTilesToFetch ++;
}
}
/* Determine caching strategy */
int bAllBandCaching = FALSE;
if (nTilesToFetch > 0)
{
GIntBig nCacheMax = (GIntBig) GDALGetCacheMax64();
if( nMemoryRequiredForTiles > nCacheMax )
{
CPLDebug("PostGIS_Raster",
"For best performance, the block cache should be able to store " CPL_FRMT_GIB
" bytes for the tiles of the requested window, "
"but it is only " CPL_FRMT_GIB " byte large",
nMemoryRequiredForTiles, nCacheMax );
nTilesToFetch = 0;
}
if( poRDS->GetRasterCount() > 1 && poRDS->bAssumeMultiBandReadPattern )
{
GIntBig nMemoryRequiredForTilesAllBands =
nMemoryRequiredForTiles * poRDS->GetRasterCount();
if( nMemoryRequiredForTilesAllBands <= nCacheMax )
{
bAllBandCaching = TRUE;
}
else
{
CPLDebug("PostGIS_Raster", "Caching only this band, but not all bands. "
"Cache should be " CPL_FRMT_GIB " byte large for that",
nMemoryRequiredForTilesAllBands);
}
}
}
// Raise a query for missing tiles and cache them
if (nTilesToFetch > 0) {
/**
* There are several options here, to raise the query.
* - Get all the tiles which PKID is in a list of missing
* PKIDs.
* - Get all the tiles that intersect a polygon constructed
* based on the (min - max) values calculated before.
* - Get all the tiles with upper left pixel included in the
* range (min - max) calculated before.
*
* The first option is the most efficient one when a PKID exists.
* After that, the second one is the most efficient one when a
* spatial index exists.
* The third one is the only one available when neither a PKID or spatial
* index exist.
**/
CPLString osCommand;
PGresult * poResult;
CPLString osRasterToFetch;
if (bAllBandCaching)
osRasterToFetch = pszColumn;
else
osRasterToFetch.Printf("ST_Band(%s, %d)", pszColumn, nBand);
int bHasWhere = FALSE;
if (osIDsToFetch.size() && (poRDS->bIsFastPK || !(poRDS->HasSpatialIndex())) ) {
osCommand.Printf("SELECT %s, "
"ST_Metadata(%s), %s FROM %s.%s",
osRasterToFetch.c_str(), pszColumn,
poRDS->GetPrimaryKeyRef(), pszSchema, pszTable);
if( nTilesToFetch < poRDS->nTiles || poRDS->bBuildQuadTreeDynamically )
{
bHasWhere = TRUE;
osCommand += " WHERE ";
osCommand += poRDS->pszPrimaryKeyName;
osCommand += " IN (";
osCommand += osIDsToFetch;
osCommand += ")";
}
}
else {
CPLLocaleC oCLocale; // Force C locale to avoid commas instead of decimal points (for QGIS e.g.)
bHasWhere = TRUE;
osCommand.Printf("SELECT %s, ST_Metadata(%s), %s FROM %s.%s WHERE ",
osRasterToFetch.c_str(), pszColumn,
(poRDS->GetPrimaryKeyRef()) ? poRDS->GetPrimaryKeyRef() : "'foo'",
pszSchema, pszTable);
if( poRDS->HasSpatialIndex() )
{
osCommand += CPLSPrintf("%s && "
"ST_GeomFromText('POLYGON((%.18f %.18f,%.18f %.18f,%.18f %.18f,%.18f %.18f,%.18f %.18f))')",
pszColumn,
adfProjWin[0], adfProjWin[1],
adfProjWin[2], adfProjWin[3],
adfProjWin[4], adfProjWin[5],
adfProjWin[6], adfProjWin[7],
adfProjWin[0], adfProjWin[1]);
}
else
{
#define EPS 1e-5
osCommand += CPLSPrintf("ST_UpperLeftX(%s)"
" BETWEEN %f AND %f AND ST_UpperLeftY(%s) BETWEEN "
"%f AND %f", pszColumn, sAoi.minx-EPS, sAoi.maxx+EPS,
pszColumn, sAoi.miny-EPS, sAoi.maxy+EPS);
}
}
if( poRDS->pszWhere != NULL )
{
if( bHasWhere )
osCommand += " AND (";
else
osCommand += " WHERE (";
osCommand += poRDS->pszWhere;
osCommand += ")";
}
poResult = PQexec(poRDS->poConn, osCommand.c_str());
#ifdef DEBUG_QUERY
CPLDebug("PostGIS_Raster",
"PostGISRasterRasterBand::IRasterIO(): Query = \"%s\" --> number of rows = %d",
osCommand.c_str(), poResult ? PQntuples(poResult) : 0 );
#endif
if (poResult == NULL ||
PQresultStatus(poResult) != PGRES_TUPLES_OK ||
PQntuples(poResult) < 0) {
if (poResult)
PQclear(poResult);
CPLError(CE_Failure, CPLE_AppDefined,
"PostGISRasterRasterBand::IRasterIO(): %s",
PQerrorMessage(poRDS->poConn));
// Free the object that holds pointers to matching tiles
CPLFree(papsMatchingTiles);
return CE_Failure;
}
/**
* No data. Return the buffer filled with nodata values
**/
else if (PQntuples(poResult) == 0) {
PQclear(poResult);
// Free the object that holds pointers to matching tiles
CPLFree(papsMatchingTiles);
return CE_None;
}
/**
* Ok, we loop over the results
**/
int nTuples = PQntuples(poResult);
for(i = 0; i < nTuples; i++)
{
const char* pszMetadata = PQgetvalue(poResult, i, 1);
const char* pszRaster = PQgetvalue(poResult, i, 0);
const char *pszPKID = (poRDS->GetPrimaryKeyRef() != NULL) ? PQgetvalue(poResult, i, 2) : NULL;
poRDS->CacheTile(pszMetadata, pszRaster, pszPKID, nBand, bAllBandCaching);
} // All tiles have been added to cache
PQclear(poResult);
} // End missing tiles
/* -------------------------------------------------------------------- */
/* Overlay each source in turn over top this. */
/* -------------------------------------------------------------------- */
CPLErr eErr = CE_None;
/* Sort tiles by ascending PKID, so that the draw order is determinist */
if( poRDS->GetPrimaryKeyRef() != NULL )
{
qsort(papsMatchingTiles, nFeatureCount, sizeof(PostGISRasterTileDataset*),
SortTilesByPKID);
}
for(i = 0; i < nFeatureCount && eErr == CE_None; i++)
{
PostGISRasterTileDataset *poTile = papsMatchingTiles[i];
PostGISRasterTileRasterBand* poTileBand =
(PostGISRasterTileRasterBand *)poTile->GetRasterBand(nBand);
eErr =
poTileBand->poSource->RasterIO( nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nPixelSpace, nLineSpace);
}
// Free the object that holds pointers to matching tiles
CPLFree(papsMatchingTiles);
return eErr;
}
CPLErr
VRTSourcedRasterBand::ComputeStatistics( int bApproxOK,
double *pdfMin, double *pdfMax,
double *pdfMean, double *pdfStdDev,
GDALProgressFunc pfnProgress,
void *pProgressData )
{
if( nSources != 1 )
return GDALRasterBand::ComputeStatistics( bApproxOK,
pdfMin, pdfMax,
pdfMean, pdfStdDev,
pfnProgress, pProgressData );
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
/* -------------------------------------------------------------------- */
/* If we have overview bands, use them for statistics. */
/* -------------------------------------------------------------------- */
if( bApproxOK && GetOverviewCount() > 0 && !HasArbitraryOverviews() )
{
GDALRasterBand *poBand;
poBand = GetRasterSampleOverview( GDALSTAT_APPROX_NUMSAMPLES );
if( poBand != this )
return poBand->ComputeStatistics( FALSE,
pdfMin, pdfMax,
pdfMean, pdfStdDev,
pfnProgress, pProgressData );
}
/* -------------------------------------------------------------------- */
/* Try with source bands. */
/* -------------------------------------------------------------------- */
if ( bAntiRecursionFlag )
{
CPLError( CE_Failure, CPLE_AppDefined,
"VRTSourcedRasterBand::ComputeStatistics() called recursively on the same band. "
"It looks like the VRT is referencing itself." );
return CE_Failure;
}
bAntiRecursionFlag = TRUE;
double dfMin = 0.0, dfMax = 0.0, dfMean = 0.0, dfStdDev = 0.0;
CPLErr eErr = papoSources[0]->ComputeStatistics(GetXSize(), GetYSize(), bApproxOK,
&dfMin, &dfMax,
&dfMean, &dfStdDev,
pfnProgress, pProgressData);
if (eErr != CE_None)
{
eErr = GDALRasterBand::ComputeStatistics(bApproxOK,
pdfMin, pdfMax,
pdfMean, pdfStdDev,
pfnProgress, pProgressData);
bAntiRecursionFlag = FALSE;
return eErr;
}
bAntiRecursionFlag = FALSE;
SetStatistics( dfMin, dfMax, dfMean, dfStdDev );
/* -------------------------------------------------------------------- */
/* Record results. */
/* -------------------------------------------------------------------- */
if( pdfMin != NULL )
*pdfMin = dfMin;
if( pdfMax != NULL )
*pdfMax = dfMax;
if( pdfMean != NULL )
*pdfMean = dfMean;
if( pdfStdDev != NULL )
*pdfStdDev = dfStdDev;
return CE_None;
}
CPLErr VRTSourcedRasterBand::ComputeRasterMinMax( int bApproxOK, double* adfMinMax )
{
double dfMin = 0.0;
double dfMax = 0.0;
/* -------------------------------------------------------------------- */
/* Does the driver already know the min/max? */
/* -------------------------------------------------------------------- */
if( bApproxOK )
{
int bSuccessMin, bSuccessMax;
dfMin = GetMinimum( &bSuccessMin );
dfMax = GetMaximum( &bSuccessMax );
if( bSuccessMin && bSuccessMax )
{
adfMinMax[0] = dfMin;
adfMinMax[1] = dfMax;
return CE_None;
}
}
/* -------------------------------------------------------------------- */
/* If we have overview bands, use them for min/max. */
/* -------------------------------------------------------------------- */
if ( bApproxOK && GetOverviewCount() > 0 && !HasArbitraryOverviews() )
{
GDALRasterBand *poBand;
poBand = GetRasterSampleOverview( GDALSTAT_APPROX_NUMSAMPLES );
if ( poBand != this )
return poBand->ComputeRasterMinMax( FALSE, adfMinMax );
}
/* -------------------------------------------------------------------- */
/* Try with source bands. */
/* -------------------------------------------------------------------- */
if ( bAntiRecursionFlag )
{
CPLError( CE_Failure, CPLE_AppDefined,
"VRTSourcedRasterBand::ComputeRasterMinMax() called recursively on the same band. "
"It looks like the VRT is referencing itself." );
return CE_Failure;
}
bAntiRecursionFlag = TRUE;
adfMinMax[0] = 0.0;
adfMinMax[1] = 0.0;
for( int iSource = 0; iSource < nSources; iSource++ )
{
double adfSourceMinMax[2];
CPLErr eErr = papoSources[iSource]->ComputeRasterMinMax(GetXSize(), GetYSize(), bApproxOK, adfSourceMinMax);
if (eErr != CE_None)
{
eErr = GDALRasterBand::ComputeRasterMinMax(bApproxOK, adfMinMax);
bAntiRecursionFlag = FALSE;
return eErr;
}
if (iSource == 0 || adfSourceMinMax[0] < adfMinMax[0])
adfMinMax[0] = adfSourceMinMax[0];
if (iSource == 0 || adfSourceMinMax[1] > adfMinMax[1])
adfMinMax[1] = adfSourceMinMax[1];
}
bAntiRecursionFlag = FALSE;
return CE_None;
}
CPLErr
GDALDefaultOverviews::BuildOverviews(
const char * pszBasename,
const char * pszResampling,
int nOverviews, int * panOverviewList,
int nBands, int * panBandList,
GDALProgressFunc pfnProgress, void * pProgressData)
{
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
if( nOverviews == 0 )
return CleanOverviews();
/* -------------------------------------------------------------------- */
/* If we don't already have an overview file, we need to decide */
/* what format to use. */
/* -------------------------------------------------------------------- */
if( poODS == NULL )
{
bOvrIsAux = CPLTestBool(CPLGetConfigOption( "USE_RRD", "NO" ));
if( bOvrIsAux )
{
osOvrFilename = CPLResetExtension(poDS->GetDescription(),"aux");
VSIStatBufL sStatBuf;
if( VSIStatExL( osOvrFilename, &sStatBuf,
VSI_STAT_EXISTS_FLAG ) == 0 )
osOvrFilename.Printf( "%s.aux", poDS->GetDescription() );
}
}
/* -------------------------------------------------------------------- */
/* If we already have the overviews open, but they are */
/* read-only, then try and reopen them read-write. */
/* -------------------------------------------------------------------- */
else if( poODS->GetAccess() == GA_ReadOnly )
{
GDALClose( poODS );
poODS = static_cast<GDALDataset *>(
GDALOpen( osOvrFilename, GA_Update ));
if( poODS == NULL )
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Our TIFF overview support currently only works safely if all */
/* bands are handled at the same time. */
/* -------------------------------------------------------------------- */
if( !bOvrIsAux && nBands != poDS->GetRasterCount() )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Generation of overviews in external TIFF currently only "
"supported when operating on all bands. "
"Operation failed." );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* If a basename is provided, use it to override the internal */
/* overview filename. */
/* -------------------------------------------------------------------- */
if( pszBasename == NULL && osOvrFilename.length() == 0 )
pszBasename = poDS->GetDescription();
if( pszBasename != NULL )
{
if( bOvrIsAux )
osOvrFilename.Printf( "%s.aux", pszBasename );
else
osOvrFilename.Printf( "%s.ovr", pszBasename );
}
/* -------------------------------------------------------------------- */
/* Establish which of the overview levels we already have, and */
/* which are new. We assume that band 1 of the file is */
/* representative. */
/* -------------------------------------------------------------------- */
GDALRasterBand *poBand = poDS->GetRasterBand( 1 );
int nNewOverviews = 0;
int *panNewOverviewList = static_cast<int *>(
CPLCalloc(sizeof(int), nOverviews) );
double dfAreaNewOverviews = 0;
double dfAreaRefreshedOverviews = 0;
for( int i = 0; i < nOverviews && poBand != NULL; i++ )
{
for( int j = 0; j < poBand->GetOverviewCount(); j++ )
{
GDALRasterBand * poOverview = poBand->GetOverview( j );
if( poOverview == NULL )
continue;
int nOvFactor =
GDALComputeOvFactor(poOverview->GetXSize(),
poBand->GetXSize(),
poOverview->GetYSize(),
poBand->GetYSize());
if( nOvFactor == panOverviewList[i]
|| nOvFactor == GDALOvLevelAdjust2( panOverviewList[i],
poBand->GetXSize(),
poBand->GetYSize() ) )
{
panOverviewList[i] *= -1;
}
}
const double dfArea = 1.0 / (panOverviewList[i] * panOverviewList[i]);
dfAreaRefreshedOverviews += dfArea;
if( panOverviewList[i] > 0 )
{
dfAreaNewOverviews += dfArea;
panNewOverviewList[nNewOverviews++] = panOverviewList[i];
}
}
/* -------------------------------------------------------------------- */
/* Build band list. */
/* -------------------------------------------------------------------- */
GDALRasterBand **pahBands = static_cast<GDALRasterBand **>(
CPLCalloc(sizeof(GDALRasterBand *), nBands) );
for( int i = 0; i < nBands; i++ )
pahBands[i] = poDS->GetRasterBand( panBandList[i] );
/* -------------------------------------------------------------------- */
/* Build new overviews - Imagine. Keep existing file open if */
/* we have it. But mark all overviews as in need of */
/* regeneration, since HFAAuxBuildOverviews() doesn't actually */
/* produce the imagery. */
/* -------------------------------------------------------------------- */
CPLErr eErr = CE_None;
void* pScaledProgress = GDALCreateScaledProgress(
0, dfAreaNewOverviews / dfAreaRefreshedOverviews,
pfnProgress, pProgressData );
if( bOvrIsAux )
{
if( nNewOverviews == 0 )
{
/* if we call HFAAuxBuildOverviews() with nNewOverviews == 0 */
/* because that there's no new, this will wipe existing */
/* overviews (#4831) */
// eErr = CE_None;
}
else
{
eErr = HFAAuxBuildOverviews( osOvrFilename, poDS, &poODS,
nBands, panBandList,
nNewOverviews, panNewOverviewList,
pszResampling,
GDALScaledProgress, pScaledProgress );
}
for( int j = 0; j < nOverviews; j++ )
{
if( panOverviewList[j] > 0 )
panOverviewList[j] *= -1;
}
}
/* -------------------------------------------------------------------- */
/* Build new overviews - TIFF. Close TIFF files while we */
/* operate on it. */
/* -------------------------------------------------------------------- */
else
{
if( poODS != NULL )
{
delete poODS;
poODS = NULL;
}
eErr = GTIFFBuildOverviews( osOvrFilename, nBands, pahBands,
nNewOverviews, panNewOverviewList,
pszResampling,
GDALScaledProgress, pScaledProgress );
// Probe for proxy overview filename.
if( eErr == CE_Failure )
{
const char *pszProxyOvrFilename =
poDS->GetMetadataItem("FILENAME","ProxyOverviewRequest");
if( pszProxyOvrFilename != NULL )
{
osOvrFilename = pszProxyOvrFilename;
eErr = GTIFFBuildOverviews( osOvrFilename, nBands, pahBands,
nNewOverviews, panNewOverviewList,
pszResampling,
GDALScaledProgress, pScaledProgress );
}
}
if( eErr == CE_None )
{
poODS = static_cast<GDALDataset *>(
GDALOpen( osOvrFilename, GA_Update ) );
if( poODS == NULL )
eErr = CE_Failure;
}
}
GDALDestroyScaledProgress( pScaledProgress );
/* -------------------------------------------------------------------- */
/* Refresh old overviews that were listed. */
/* -------------------------------------------------------------------- */
GDALRasterBand **papoOverviewBands = static_cast<GDALRasterBand **>(
CPLCalloc(sizeof(void*), nOverviews) );
for( int iBand = 0; iBand < nBands && eErr == CE_None; iBand++ )
{
poBand = poDS->GetRasterBand( panBandList[iBand] );
nNewOverviews = 0;
for( int i = 0; i < nOverviews && poBand != NULL; i++ )
{
for( int j = 0; j < poBand->GetOverviewCount(); j++ )
{
GDALRasterBand * poOverview = poBand->GetOverview( j );
if( poOverview == NULL )
continue;
int bHasNoData = FALSE;
double noDataValue = poBand->GetNoDataValue(&bHasNoData);
if( bHasNoData )
poOverview->SetNoDataValue(noDataValue);
const int nOvFactor =
GDALComputeOvFactor(poOverview->GetXSize(),
poBand->GetXSize(),
poOverview->GetYSize(),
poBand->GetYSize());
if( nOvFactor == - panOverviewList[i]
|| (panOverviewList[i] < 0 &&
nOvFactor == GDALOvLevelAdjust2( -panOverviewList[i],
poBand->GetXSize(),
poBand->GetYSize() )) )
{
papoOverviewBands[nNewOverviews++] = poOverview;
break;
}
}
}
if( nNewOverviews > 0 )
{
const double dfOffset = dfAreaNewOverviews / dfAreaRefreshedOverviews;
const double dfScale = 1.0 - dfOffset;
pScaledProgress = GDALCreateScaledProgress(
dfOffset + dfScale * iBand / nBands,
dfOffset + dfScale * (iBand+1) / nBands,
pfnProgress, pProgressData );
eErr = GDALRegenerateOverviews( (GDALRasterBandH) poBand,
nNewOverviews,
(GDALRasterBandH*)papoOverviewBands,
pszResampling,
GDALScaledProgress, pScaledProgress );
GDALDestroyScaledProgress( pScaledProgress );
}
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
CPLFree( papoOverviewBands );
CPLFree( panNewOverviewList );
CPLFree( pahBands );
/* -------------------------------------------------------------------- */
/* If we have a mask file, we need to build its overviews too. */
/* -------------------------------------------------------------------- */
if( HaveMaskFile() && poMaskDS )
{
// Some config option are not compatible with mask overviews
// so unset them, and define more sensible values.
const bool bJPEG =
EQUAL(CPLGetConfigOption("COMPRESS_OVERVIEW", ""), "JPEG");
const bool bPHOTOMETRIC_YCBCR =
EQUAL(CPLGetConfigOption("PHOTOMETRIC_OVERVIEW", ""), "YCBCR");
if( bJPEG )
CPLSetThreadLocalConfigOption("COMPRESS_OVERVIEW", "DEFLATE");
if( bPHOTOMETRIC_YCBCR )
CPLSetThreadLocalConfigOption("PHOTOMETRIC_OVERVIEW", "");
poMaskDS->BuildOverviews( pszResampling, nOverviews, panOverviewList,
0, NULL, pfnProgress, pProgressData );
// Restore config option.
if( bJPEG )
CPLSetThreadLocalConfigOption("COMPRESS_OVERVIEW", "JPEG");
if( bPHOTOMETRIC_YCBCR )
CPLSetThreadLocalConfigOption("PHOTOMETRIC_OVERVIEW", "YCBCR");
if( bOwnMaskDS )
{
// Reset the poMask member of main dataset bands, since it
// will become invalid after poMaskDS closing.
for( int iBand = 1; iBand <= poDS->GetRasterCount(); iBand ++ )
{
GDALRasterBand *poOtherBand = poDS->GetRasterBand(iBand);
if( poOtherBand != NULL )
poOtherBand->InvalidateMaskBand();
}
GDALClose( poMaskDS );
}
// force next request to reread mask file.
poMaskDS = NULL;
bOwnMaskDS = false;
bCheckedForMask = false;
}
/* -------------------------------------------------------------------- */
/* If we have an overview dataset, then mark all the overviews */
/* with the base dataset Used later for finding overviews */
/* masks. Uggg. */
/* -------------------------------------------------------------------- */
if( poODS )
{
const int nOverviewCount = GetOverviewCount(1);
for( int iOver = 0; iOver < nOverviewCount; iOver++ )
{
GDALRasterBand *poOtherBand = GetOverview( 1, iOver );
GDALDataset *poOverDS = poOtherBand != NULL ?
poOtherBand->GetDataset() : NULL;
if( poOverDS != NULL )
{
poOverDS->oOvManager.poBaseDS = poDS;
poOverDS->oOvManager.poDS = poOverDS;
}
}
}
return eErr;
}
void GDALDefaultOverviews::OverviewScan()
{
if( bCheckedForOverviews || poDS == NULL )
return;
bCheckedForOverviews = true;
CPLDebug( "GDAL", "GDALDefaultOverviews::OverviewScan()" );
/* -------------------------------------------------------------------- */
/* Open overview dataset if it exists. */
/* -------------------------------------------------------------------- */
if( pszInitName == NULL )
pszInitName = CPLStrdup(poDS->GetDescription());
if( !EQUAL(pszInitName,":::VIRTUAL:::") &&
GDALCanFileAcceptSidecarFile(pszInitName) )
{
if( bInitNameIsOVR )
osOvrFilename = pszInitName;
else
osOvrFilename.Printf( "%s.ovr", pszInitName );
std::vector<char> achOvrFilename;
achOvrFilename.resize(osOvrFilename.size() + 1);
memcpy(&(achOvrFilename[0]),
osOvrFilename.c_str(),
osOvrFilename.size() + 1);
bool bExists = CPL_TO_BOOL(
CPLCheckForFile( &achOvrFilename[0], papszInitSiblingFiles ) );
osOvrFilename = &achOvrFilename[0];
#if !defined(WIN32)
if( !bInitNameIsOVR && !bExists && !papszInitSiblingFiles )
{
osOvrFilename.Printf( "%s.OVR", pszInitName );
memcpy(&(achOvrFilename[0]),
osOvrFilename.c_str(),
osOvrFilename.size() + 1);
bExists = CPL_TO_BOOL(
CPLCheckForFile( &achOvrFilename[0], papszInitSiblingFiles ) );
osOvrFilename = &achOvrFilename[0];
if( !bExists )
osOvrFilename.Printf( "%s.ovr", pszInitName );
}
#endif
if( bExists )
{
poODS = static_cast<GDALDataset *>( GDALOpenEx(
osOvrFilename,
GDAL_OF_RASTER |
(poDS->GetAccess() == GA_Update ? GDAL_OF_UPDATE : 0),
NULL, NULL, papszInitSiblingFiles ) );
}
}
/* -------------------------------------------------------------------- */
/* We didn't find that, so try and find a corresponding aux */
/* file. Check that we are the dependent file of the aux */
/* file. */
/* */
/* We only use the .aux file for overviews if they already have */
/* overviews existing, or if USE_RRD is set true. */
/* -------------------------------------------------------------------- */
if( !poODS && !EQUAL(pszInitName,":::VIRTUAL:::") &&
GDALCanFileAcceptSidecarFile(pszInitName) )
{
bool bTryFindAssociatedAuxFile = true;
if( papszInitSiblingFiles )
{
CPLString osAuxFilename = CPLResetExtension( pszInitName, "aux");
int iSibling = CSLFindString( papszInitSiblingFiles,
CPLGetFilename(osAuxFilename) );
if( iSibling < 0 )
{
osAuxFilename = pszInitName;
osAuxFilename += ".aux";
iSibling = CSLFindString( papszInitSiblingFiles,
CPLGetFilename(osAuxFilename) );
if( iSibling < 0 )
bTryFindAssociatedAuxFile = false;
}
}
if( bTryFindAssociatedAuxFile )
{
poODS = GDALFindAssociatedAuxFile( pszInitName, poDS->GetAccess(),
poDS );
}
if( poODS )
{
const bool bUseRRD = CPLTestBool(CPLGetConfigOption("USE_RRD","NO"));
bOvrIsAux = true;
if( GetOverviewCount(1) == 0 && !bUseRRD )
{
bOvrIsAux = false;
GDALClose( poODS );
poODS = NULL;
}
else
{
osOvrFilename = poODS->GetDescription();
}
}
}
/* -------------------------------------------------------------------- */
/* If we still don't have an overview, check to see if we have */
/* overview metadata referencing a remote (i.e. proxy) or local */
/* subdataset overview dataset. */
/* -------------------------------------------------------------------- */
if( poODS == NULL )
{
const char *pszProxyOvrFilename =
poDS->GetMetadataItem( "OVERVIEW_FILE", "OVERVIEWS" );
if( pszProxyOvrFilename != NULL )
{
if( STARTS_WITH_CI(pszProxyOvrFilename, ":::BASE:::") )
{
const CPLString osPath = CPLGetPath(poDS->GetDescription());
osOvrFilename =
CPLFormFilename( osPath, pszProxyOvrFilename+10, NULL );
}
else
{
osOvrFilename = pszProxyOvrFilename;
}
CPLPushErrorHandler(CPLQuietErrorHandler);
poODS = static_cast<GDALDataset *>(GDALOpen(osOvrFilename, poDS->GetAccess()));
CPLPopErrorHandler();
}
}
/* -------------------------------------------------------------------- */
/* If we have an overview dataset, then mark all the overviews */
/* with the base dataset Used later for finding overviews */
/* masks. Uggg. */
/* -------------------------------------------------------------------- */
if( poODS )
{
const int nOverviewCount = GetOverviewCount(1);
for( int iOver = 0; iOver < nOverviewCount; iOver++ )
{
GDALRasterBand * const poBand = GetOverview( 1, iOver );
GDALDataset * const poOverDS = poBand != NULL ?
poBand->GetDataset() : NULL;
if( poOverDS != NULL )
{
poOverDS->oOvManager.poBaseDS = poDS;
poOverDS->oOvManager.poDS = poOverDS;
}
}
}
}
void GDALDefaultOverviews::OverviewScan()
{
if( bCheckedForOverviews || poDS == NULL )
return;
bCheckedForOverviews = true;
CPLDebug( "GDAL", "GDALDefaultOverviews::OverviewScan()" );
/* -------------------------------------------------------------------- */
/* Open overview dataset if it exists. */
/* -------------------------------------------------------------------- */
int bExists;
if( pszInitName == NULL )
pszInitName = CPLStrdup(poDS->GetDescription());
if( !EQUAL(pszInitName,":::VIRTUAL:::") )
{
if( bInitNameIsOVR )
osOvrFilename = pszInitName;
else
osOvrFilename.Printf( "%s.ovr", pszInitName );
bExists = CPLCheckForFile( (char *) osOvrFilename.c_str(),
papszInitSiblingFiles );
#if !defined(WIN32)
if( !bInitNameIsOVR && !bExists && !papszInitSiblingFiles )
{
osOvrFilename.Printf( "%s.OVR", pszInitName );
bExists = CPLCheckForFile( (char *) osOvrFilename.c_str(),
papszInitSiblingFiles );
if( !bExists )
osOvrFilename.Printf( "%s.ovr", pszInitName );
}
#endif
if( bExists )
{
GDALOpenInfo oOpenInfo(osOvrFilename, poDS->GetAccess(),
papszInitSiblingFiles);
poODS = (GDALDataset*) GDALOpenInternal( oOpenInfo, NULL );
}
}
/* -------------------------------------------------------------------- */
/* We didn't find that, so try and find a corresponding aux */
/* file. Check that we are the dependent file of the aux */
/* file. */
/* */
/* We only use the .aux file for overviews if they already have */
/* overviews existing, or if USE_RRD is set true. */
/* -------------------------------------------------------------------- */
if( !poODS && !EQUAL(pszInitName,":::VIRTUAL:::") )
{
int bTryFindAssociatedAuxFile = TRUE;
if( papszInitSiblingFiles )
{
CPLString osAuxFilename = CPLResetExtension( pszInitName, "aux");
int iSibling = CSLFindString( papszInitSiblingFiles,
CPLGetFilename(osAuxFilename) );
if( iSibling < 0 )
{
osAuxFilename = pszInitName;
osAuxFilename += ".aux";
iSibling = CSLFindString( papszInitSiblingFiles,
CPLGetFilename(osAuxFilename) );
if( iSibling < 0 )
bTryFindAssociatedAuxFile = FALSE;
}
}
if (bTryFindAssociatedAuxFile)
{
poODS = GDALFindAssociatedAuxFile( pszInitName, poDS->GetAccess(),
poDS );
}
if( poODS )
{
int bUseRRD = CSLTestBoolean(CPLGetConfigOption("USE_RRD","NO"));
bOvrIsAux = TRUE;
if( GetOverviewCount(1) == 0 && !bUseRRD )
{
bOvrIsAux = FALSE;
GDALClose( poODS );
poODS = NULL;
}
else
{
osOvrFilename = poODS->GetDescription();
}
}
}
/* -------------------------------------------------------------------- */
/* If we still don't have an overview, check to see if we have */
/* overview metadata referencing a remote (ie. proxy) or local */
/* subdataset overview dataset. */
/* -------------------------------------------------------------------- */
if( poODS == NULL )
{
const char *pszProxyOvrFilename =
poDS->GetMetadataItem( "OVERVIEW_FILE", "OVERVIEWS" );
if( pszProxyOvrFilename != NULL )
{
if( EQUALN(pszProxyOvrFilename,":::BASE:::",10) )
{
CPLString osPath = CPLGetPath(poDS->GetDescription());
osOvrFilename =
CPLFormFilename( osPath, pszProxyOvrFilename+10, NULL );
}
else
osOvrFilename = pszProxyOvrFilename;
CPLPushErrorHandler(CPLQuietErrorHandler);
poODS = (GDALDataset *) GDALOpen(osOvrFilename,poDS->GetAccess());
CPLPopErrorHandler();
}
}
/* -------------------------------------------------------------------- */
/* If we have an overview dataset, then mark all the overviews */
/* with the base dataset Used later for finding overviews */
/* masks. Uggg. */
/* -------------------------------------------------------------------- */
if( poODS )
{
int nOverviewCount = GetOverviewCount(1);
int iOver;
for( iOver = 0; iOver < nOverviewCount; iOver++ )
{
GDALRasterBand *poBand = GetOverview( 1, iOver );
GDALDataset *poOverDS = NULL;
if( poBand != NULL )
poOverDS = poBand->GetDataset();
if( poOverDS != NULL )
{
poOverDS->oOvManager.poBaseDS = poDS;
poOverDS->oOvManager.poDS = poOverDS;
}
}
}
}
CPLErr JP2LuraRasterBand::IRasterIO(GDALRWFlag eRWFlag,
int nXOff, int nYOff, int nXSize, int nYSize,
void * pData, int nBufXSize, int nBufYSize,
GDALDataType eBufType,
GSpacing nPixelSpace, GSpacing nLineSpace,
GDALRasterIOExtraArg* psExtraArg)
{
JP2LuraDataset *poGDS = reinterpret_cast<JP2LuraDataset *>(poDS);
const int nBufTypeSize = GDALGetDataTypeSizeBytes(eBufType);
if (eRWFlag != GF_Read)
return CE_Failure;
#ifdef DEBUG_VERBOSE
CPLDebug("JP2Lura", "RasterIO(nBand=%d,nLevel=%d %d,%d,%dx%d -> %dx%d)",
nBand, poGDS->iLevel, nXOff, nYOff, nXSize, nYSize,
nBufXSize, nBufYSize);
#endif
if( eBufType != eDataType ||
nPixelSpace != nBufTypeSize ||
nLineSpace != nPixelSpace * nBufXSize )
{
return GDALRasterBand::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize, eBufType,
nPixelSpace, nLineSpace, psExtraArg);
}
// Use cached data
if( poGDS->sOutputData.nXOff == nXOff &&
poGDS->sOutputData.nYOff == nYOff &&
poGDS->sOutputData.nXSize == nXSize &&
poGDS->sOutputData.nYSize == nYSize &&
poGDS->sOutputData.nBufXSize == nBufXSize &&
poGDS->sOutputData.nBufYSize == nBufYSize &&
poGDS->sOutputData.eBufType == eBufType )
{
if (poGDS->sOutputData.pDatacache[nBand - 1] != nullptr)
{
#ifdef DEBUG_VERBOSE
CPLDebug("JP2Lura", "Using cached data");
#endif
memcpy(pData, poGDS->sOutputData.pDatacache[nBand - 1],
static_cast<size_t>(nBufXSize)*nBufYSize*nBufTypeSize);
return CE_None;
}
}
/* ==================================================================== */
/* Do we have overviews that would be appropriate to satisfy */
/* this request? */
/* ==================================================================== */
if ((nBufXSize < nXSize || nBufYSize < nYSize)
&& GetOverviewCount() > 0 && eRWFlag == GF_Read)
{
int nOverview;
GDALRasterIOExtraArg sExtraArg;
GDALCopyRasterIOExtraArg(&sExtraArg, psExtraArg);
nOverview = GDALBandGetBestOverviewLevel2(
this, nXOff, nYOff, nXSize, nYSize,
nBufXSize, nBufYSize, &sExtraArg);
if (nOverview >= 0)
{
GDALRasterBand* poOverviewBand = GetOverview(nOverview);
if (poOverviewBand == nullptr)
return CE_Failure;
return poOverviewBand->RasterIO(
eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize, eBufType,
nPixelSpace, nLineSpace, &sExtraArg);
}
}
if( nBufXSize != nXSize || nBufYSize != nYSize )
{
return GDALRasterBand::IRasterIO(eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize, eBufType,
nPixelSpace, nLineSpace, psExtraArg);
}
JP2_Error error = 0;
const short factor = 1 << poGDS->iLevel;
JP2_Rect comp_region;
comp_region.ulLeft = nXOff;
comp_region.ulRight = nXOff + nXSize;
comp_region.ulTop = nYOff;
comp_region.ulBottom = nYOff + nYSize;
error = JP2_Decompress_SetProp(poGDS->sOutputData.handle,
cJP2_Prop_Scale_Down, factor);
if( error )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Internal library error (%s).",
JP2LuraDataset::GetErrorMessage(error));
return CE_Failure;
}
poGDS->sOutputData.pimage = reinterpret_cast<unsigned char*>(pData);
poGDS->sOutputData.nXOff = nXOff;
poGDS->sOutputData.nYOff = nYOff;
poGDS->sOutputData.nXSize = nXSize;
poGDS->sOutputData.nYSize = nYSize;
poGDS->sOutputData.nBufXSize = nBufXSize;
poGDS->sOutputData.nBufYSize = nBufYSize;
poGDS->sOutputData.eBufType = eBufType;
poGDS->sOutputData.nBand = nBand;
poGDS->sOutputData.nBands = poGDS->nBands;
if( poGDS->sOutputData.pDatacache == nullptr )
{
poGDS->sOutputData.pDatacache = reinterpret_cast<unsigned char**>
(CPLCalloc( poGDS->nBands, sizeof(unsigned char*)));
}
for (int i = 0; i < poGDS->nBands; i++)
{
if (poGDS->sOutputData.pDatacache[i] != nullptr)
{
VSIFree(poGDS->sOutputData.pDatacache[i]);
poGDS->sOutputData.pDatacache[i] = nullptr;
}
if (i == nBand-1)
continue;
poGDS->sOutputData.pDatacache[i] =
reinterpret_cast<unsigned char*>(VSIMalloc(
static_cast<size_t>(nBufXSize)*nBufYSize*nBufTypeSize));
}
/*++++++++++++++++++++++++++++++++++++++++++++++*/
/* Set the callback function and parameter */
/*++++++++++++++++++++++++++++++++++++++++++++++*/
error = JP2_Decompress_SetProp(poGDS->sOutputData.handle,
cJP2_Prop_Output_Parameter,
reinterpret_cast<JP2_Property_Value>(&(poGDS->sOutputData)));
if( error )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Internal library error (%s).",
JP2LuraDataset::GetErrorMessage(error));
return CE_Failure;
}
error = JP2_Decompress_SetProp(poGDS->sOutputData.handle,
cJP2_Prop_Output_Function,
reinterpret_cast<JP2_Property_Value>(
GDALJP2Lura_Callback_Decompress_Write));
if( error )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Internal library error (%s).",
JP2LuraDataset::GetErrorMessage(error));
return CE_Failure;
}
error = JP2_Decompress_Region(poGDS->sOutputData.handle, comp_region);
if( error )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Internal library error during decompress region (%s).",
JP2LuraDataset::GetErrorMessage(error));
return CE_Failure;
}
return CE_None;
}
CPLErr
GDALDefaultOverviews::BuildOverviews(
const char * pszBasename,
const char * pszResampling,
int nOverviews, int * panOverviewList,
int nBands, int * panBandList,
GDALProgressFunc pfnProgress, void * pProgressData)
{
GDALRasterBand **pahBands;
CPLErr eErr;
int i;
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
if( nOverviews == 0 )
return CleanOverviews();
/* -------------------------------------------------------------------- */
/* If we don't already have an overview file, we need to decide */
/* what format to use. */
/* -------------------------------------------------------------------- */
if( poODS == NULL )
{
bOvrIsAux = CSLTestBoolean(CPLGetConfigOption( "USE_RRD", "NO" ));
if( bOvrIsAux )
{
VSIStatBufL sStatBuf;
osOvrFilename = CPLResetExtension(poDS->GetDescription(),"aux");
if( VSIStatL( osOvrFilename, &sStatBuf ) == 0 )
osOvrFilename.Printf( "%s.aux", poDS->GetDescription() );
}
}
/* -------------------------------------------------------------------- */
/* If we already have the overviews open, but they are */
/* read-only, then try and reopen them read-write. */
/* -------------------------------------------------------------------- */
else if( poODS->GetAccess() == GA_ReadOnly )
{
GDALClose( poODS );
poODS = (GDALDataset *) GDALOpen( osOvrFilename, GA_Update );
if( poODS == NULL )
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Our TIFF overview support currently only works safely if all */
/* bands are handled at the same time. */
/* -------------------------------------------------------------------- */
if( !bOvrIsAux && nBands != poDS->GetRasterCount() )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Generation of overviews in external TIFF currently only"
" supported when operating on all bands.\n"
"Operation failed.\n" );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* If a basename is provided, use it to override the internal */
/* overview filename. */
/* -------------------------------------------------------------------- */
if( pszBasename == NULL && osOvrFilename.length() == 0 )
pszBasename = poDS->GetDescription();
if( pszBasename != NULL )
{
if( bOvrIsAux )
osOvrFilename.Printf( "%s.aux", pszBasename );
else
osOvrFilename.Printf( "%s.ovr", pszBasename );
}
/* -------------------------------------------------------------------- */
/* Establish which of the overview levels we already have, and */
/* which are new. We assume that band 1 of the file is */
/* representative. */
/* -------------------------------------------------------------------- */
int nNewOverviews, *panNewOverviewList = NULL;
GDALRasterBand *poBand = poDS->GetRasterBand( 1 );
nNewOverviews = 0;
panNewOverviewList = (int *) CPLCalloc(sizeof(int),nOverviews);
for( i = 0; i < nOverviews && poBand != NULL; i++ )
{
int j;
for( j = 0; j < poBand->GetOverviewCount(); j++ )
{
int nOvFactor;
GDALRasterBand * poOverview = poBand->GetOverview( j );
nOvFactor = (int)
(0.5 + poBand->GetXSize() / (double) poOverview->GetXSize());
if( nOvFactor == panOverviewList[i]
|| nOvFactor == GDALOvLevelAdjust( panOverviewList[i],
poBand->GetXSize() ) )
panOverviewList[i] *= -1;
}
if( panOverviewList[i] > 0 )
panNewOverviewList[nNewOverviews++] = panOverviewList[i];
}
/* -------------------------------------------------------------------- */
/* Build band list. */
/* -------------------------------------------------------------------- */
pahBands = (GDALRasterBand **) CPLCalloc(sizeof(GDALRasterBand *),nBands);
for( i = 0; i < nBands; i++ )
pahBands[i] = poDS->GetRasterBand( panBandList[i] );
/* -------------------------------------------------------------------- */
/* Build new overviews - Imagine. Keep existing file open if */
/* we have it. But mark all overviews as in need of */
/* regeneration, since HFAAuxBuildOverviews() doesn't actually */
/* produce the imagery. */
/* -------------------------------------------------------------------- */
#ifndef WIN32CE
if( bOvrIsAux )
{
eErr = HFAAuxBuildOverviews( osOvrFilename, poDS, &poODS,
nBands, panBandList,
nNewOverviews, panNewOverviewList,
pszResampling,
pfnProgress, pProgressData );
int j;
for( j = 0; j < nOverviews; j++ )
{
if( panOverviewList[j] > 0 )
panOverviewList[j] *= -1;
}
}
/* -------------------------------------------------------------------- */
/* Build new overviews - TIFF. Close TIFF files while we */
/* operate on it. */
/* -------------------------------------------------------------------- */
else
#endif /* WIN32CE */
{
if( poODS != NULL )
{
delete poODS;
poODS = NULL;
}
eErr = GTIFFBuildOverviews( osOvrFilename, nBands, pahBands,
nNewOverviews, panNewOverviewList,
pszResampling, pfnProgress, pProgressData );
// Probe for proxy overview filename.
if( eErr == CE_Failure )
{
const char *pszProxyOvrFilename =
poDS->GetMetadataItem("FILENAME","ProxyOverviewRequest");
if( pszProxyOvrFilename != NULL )
{
osOvrFilename = pszProxyOvrFilename;
eErr = GTIFFBuildOverviews( osOvrFilename, nBands, pahBands,
nNewOverviews, panNewOverviewList,
pszResampling,
pfnProgress, pProgressData );
}
}
if( eErr == CE_None )
{
poODS = (GDALDataset *) GDALOpen( osOvrFilename, GA_Update );
if( poODS == NULL )
eErr = CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Refresh old overviews that were listed. */
/* -------------------------------------------------------------------- */
GDALRasterBand **papoOverviewBands;
papoOverviewBands = (GDALRasterBand **)
CPLCalloc(sizeof(void*),nOverviews);
for( int iBand = 0; iBand < nBands && eErr == CE_None; iBand++ )
{
poBand = poDS->GetRasterBand( panBandList[iBand] );
nNewOverviews = 0;
for( i = 0; i < nOverviews && poBand != NULL; i++ )
{
int j;
for( j = 0; j < poBand->GetOverviewCount(); j++ )
{
int nOvFactor;
GDALRasterBand * poOverview = poBand->GetOverview( j );
int bHasNoData;
double noDataValue = poBand->GetNoDataValue(&bHasNoData);
if (bHasNoData)
poOverview->SetNoDataValue(noDataValue);
nOvFactor = (int)
(0.5 + poBand->GetXSize() / (double) poOverview->GetXSize());
if( nOvFactor == - panOverviewList[i]
|| nOvFactor == GDALOvLevelAdjust( -panOverviewList[i],
poBand->GetXSize() ) )
{
papoOverviewBands[nNewOverviews++] = poOverview;
break;
}
}
}
if( nNewOverviews > 0 )
{
eErr = GDALRegenerateOverviews( (GDALRasterBandH) poBand,
nNewOverviews,
(GDALRasterBandH*)papoOverviewBands,
pszResampling,
pfnProgress, pProgressData );
}
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
CPLFree( papoOverviewBands );
CPLFree( panNewOverviewList );
CPLFree( pahBands );
/* -------------------------------------------------------------------- */
/* If we have a mask file, we need to build it's overviews */
/* too. */
/* -------------------------------------------------------------------- */
if( HaveMaskFile() && poMaskDS )
{
poMaskDS->BuildOverviews( pszResampling, nOverviews, panOverviewList,
0, NULL, pfnProgress, pProgressData );
if( bOwnMaskDS )
GDALClose( poMaskDS );
// force next request to reread mask file.
poMaskDS = NULL;
bOwnMaskDS = FALSE;
bCheckedForMask = FALSE;
}
/* -------------------------------------------------------------------- */
/* If we have an overview dataset, then mark all the overviews */
/* with the base dataset Used later for finding overviews */
/* masks. Uggg. */
/* -------------------------------------------------------------------- */
if( poODS )
{
int nOverviewCount = GetOverviewCount(1);
int iOver;
for( iOver = 0; iOver < nOverviewCount; iOver++ )
{
GDALRasterBand *poBand = GetOverview( 1, iOver );
GDALDataset *poOverDS = NULL;
if( poBand != NULL )
poOverDS = poBand->GetDataset();
if (poOverDS != NULL)
{
poOverDS->oOvManager.poBaseDS = poDS;
poOverDS->oOvManager.poDS = poOverDS;
}
}
}
return eErr;
}
/**
* Read/write a region of image data for this band.
*
* Each of the sources for this derived band will be read and passed to
* the derived band pixel function. The pixel function is responsible
* for applying whatever algorithm is necessary to generate this band's
* pixels from the sources.
*
* The sources will be read using the transfer type specified for sources
* using SetSourceTransferType(). If no transfer type has been set for
* this derived band, the band's data type will be used as the transfer type.
*
* @see gdalrasterband
*
* @param eRWFlag Either GF_Read to read a region of data, or GT_Write to
* write a region of data.
*
* @param nXOff The pixel offset to the top left corner of the region
* of the band to be accessed. This would be zero to start from the left side.
*
* @param nYOff The line offset to the top left corner of the region
* of the band to be accessed. This would be zero to start from the top.
*
* @param nXSize The width of the region of the band to be accessed in pixels.
*
* @param nYSize The height of the region of the band to be accessed in lines.
*
* @param pData The buffer into which the data should be read, or from which
* it should be written. This buffer must contain at least nBufXSize *
* nBufYSize words of type eBufType. It is organized in left to right,
* top to bottom pixel order. Spacing is controlled by the nPixelSpace,
* and nLineSpace parameters.
*
* @param nBufXSize The width of the buffer image into which the desired
* region is to be read, or from which it is to be written.
*
* @param nBufYSize The height of the buffer image into which the desired
* region is to be read, or from which it is to be written.
*
* @param eBufType The type of the pixel values in the pData data buffer. The
* pixel values will automatically be translated to/from the GDALRasterBand
* data type as needed.
*
* @param nPixelSpace The byte offset from the start of one pixel value in
* pData to the start of the next pixel value within a scanline. If defaulted
* (0) the size of the datatype eBufType is used.
*
* @param nLineSpace The byte offset from the start of one scanline in
* pData to the start of the next. If defaulted the size of the datatype
* eBufType * nBufXSize is used.
*
* @return CE_Failure if the access fails, otherwise CE_None.
*/
CPLErr VRTDerivedRasterBand::IRasterIO(GDALRWFlag eRWFlag,
int nXOff, int nYOff, int nXSize,
int nYSize, void * pData, int nBufXSize,
int nBufYSize, GDALDataType eBufType,
int nPixelSpace, int nLineSpace )
{
GDALDerivedPixelFunc pfnPixelFunc;
void **pBuffers;
CPLErr eErr = CE_None;
int iSource, ii, typesize, sourcesize;
GDALDataType eSrcType;
if( eRWFlag == GF_Write )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Writing through VRTSourcedRasterBand is not supported." );
return CE_Failure;
}
typesize = GDALGetDataTypeSize(eBufType) / 8;
if (GDALGetDataTypeSize(eBufType) % 8 > 0) typesize++;
eSrcType = this->eSourceTransferType;
if ((eSrcType == GDT_Unknown) || (eSrcType >= GDT_TypeCount)) {
eSrcType = eBufType;
}
sourcesize = GDALGetDataTypeSize(eSrcType) / 8;
/* -------------------------------------------------------------------- */
/* Initialize the buffer to some background value. Use the */
/* nodata value if available. */
/* -------------------------------------------------------------------- */
if ( nPixelSpace == typesize &&
(!bNoDataValueSet || dfNoDataValue == 0) ) {
memset( pData, 0, nBufXSize * nBufYSize * nPixelSpace );
}
else if ( !bEqualAreas || bNoDataValueSet )
{
double dfWriteValue = 0.0;
int iLine;
if( bNoDataValueSet )
dfWriteValue = dfNoDataValue;
for( iLine = 0; iLine < nBufYSize; iLine++ )
{
GDALCopyWords( &dfWriteValue, GDT_Float64, 0,
((GByte *)pData) + nLineSpace * iLine,
eBufType, nPixelSpace, nBufXSize );
}
}
/* -------------------------------------------------------------------- */
/* Do we have overviews that would be appropriate to satisfy */
/* this request? */
/* -------------------------------------------------------------------- */
if( (nBufXSize < nXSize || nBufYSize < nYSize)
&& GetOverviewCount() > 0 )
{
if( OverviewRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nPixelSpace, nLineSpace ) == CE_None )
return CE_None;
}
/* ---- Get pixel function for band ---- */
pfnPixelFunc = VRTDerivedRasterBand::GetPixelFunction(this->pszFuncName);
if (pfnPixelFunc == NULL) {
CPLError( CE_Failure, CPLE_IllegalArg,
"VRTDerivedRasterBand::IRasterIO:" \
"Derived band pixel function '%s' not registered.\n",
this->pszFuncName);
return CE_Failure;
}
/* TODO: It would be nice to use a MallocBlock function for each
individual buffer that would recycle blocks of memory from a
cache by reassigning blocks that are nearly the same size.
A corresponding FreeBlock might only truly free if the total size
of freed blocks gets to be too great of a percentage of the size
of the allocated blocks. */
/* ---- Get buffers for each source ---- */
pBuffers = (void **) CPLMalloc(sizeof(void *) * nSources);
for (iSource = 0; iSource < nSources; iSource++) {
pBuffers[iSource] = (void *)
VSIMalloc(sourcesize * nBufXSize * nBufYSize);
if (pBuffers[iSource] == NULL)
{
for (ii = 0; ii < iSource; ii++) {
VSIFree(pBuffers[iSource]);
}
CPLError( CE_Failure, CPLE_OutOfMemory,
"VRTDerivedRasterBand::IRasterIO:" \
"Out of memory allocating %d bytes.\n",
nPixelSpace * nBufXSize * nBufYSize);
return CE_Failure;
}
/* ------------------------------------------------------------ */
/* #4045: Initialize the newly allocated buffers before handing */
/* them off to the sources. These buffers are packed, so we */
/* don't need any special line-by-line handling when a nonzero */
/* nodata value is set. */
/* ------------------------------------------------------------ */
if ( !bNoDataValueSet || dfNoDataValue == 0 )
{
memset( pBuffers[iSource], 0, sourcesize * nBufXSize * nBufYSize );
}
else
{
GDALCopyWords( &dfNoDataValue, GDT_Float64, 0,
(GByte *) pBuffers[iSource], eSrcType, sourcesize,
nBufXSize * nBufYSize);
}
}
/* ---- Load values for sources into packed buffers ---- */
for(iSource = 0; iSource < nSources; iSource++) {
eErr = ((VRTSource *)papoSources[iSource])->RasterIO
(nXOff, nYOff, nXSize, nYSize,
pBuffers[iSource], nBufXSize, nBufYSize,
eSrcType, GDALGetDataTypeSize( eSrcType ) / 8,
(GDALGetDataTypeSize( eSrcType ) / 8) * nBufXSize);
}
/* ---- Apply pixel function ---- */
if (eErr == CE_None) {
eErr = pfnPixelFunc((void **)pBuffers, nSources,
pData, nBufXSize, nBufYSize,
eSrcType, eBufType, nPixelSpace, nLineSpace);
}
/* ---- Release buffers ---- */
for (iSource = 0; iSource < nSources; iSource++) {
VSIFree(pBuffers[iSource]);
}
CPLFree(pBuffers);
return eErr;
}
CPLErr RawRasterBand::IRasterIO( GDALRWFlag eRWFlag,
int nXOff, int nYOff, int nXSize, int nYSize,
void * pData, int nBufXSize, int nBufYSize,
GDALDataType eBufType,
int nPixelSpace, int nLineSpace )
{
int nBandDataSize = GDALGetDataTypeSize(eDataType) / 8;
int nBufDataSize = GDALGetDataTypeSize( eBufType ) / 8;
int nBytesToRW = nPixelOffset * nXSize;
/* -------------------------------------------------------------------- */
/* Use direct IO without caching if: */
/* */
/* GDAL_ONE_BIG_READ is enabled */
/* */
/* or */
/* */
/* the length of a scanline on disk is more than 50000 bytes, and the */
/* width of the requested chunk is less than 40% of the whole scanline */
/* and none of the requested scanlines are already in the cache. */
/* -------------------------------------------------------------------- */
if( nPixelOffset < 0 )
{
return GDALRasterBand::IRasterIO( eRWFlag, nXOff, nYOff,
nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType,
nPixelSpace, nLineSpace );
}
if ( !CSLTestBoolean( CPLGetConfigOption( "GDAL_ONE_BIG_READ", "NO") ) )
{
if ( nLineSize < 50000
|| nBytesToRW > nLineSize / 5 * 2
|| IsLineLoaded( nYOff, nYSize ) )
{
return GDALRasterBand::IRasterIO( eRWFlag, nXOff, nYOff,
nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType,
nPixelSpace, nLineSpace );
}
}
/* ==================================================================== */
/* Read data. */
/* ==================================================================== */
if ( eRWFlag == GF_Read )
{
/* -------------------------------------------------------------------- */
/* Do we have overviews that would be appropriate to satisfy */
/* this request? */
/* -------------------------------------------------------------------- */
if( (nBufXSize < nXSize || nBufYSize < nYSize)
&& GetOverviewCount() > 0 )
{
if( OverviewRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nPixelSpace, nLineSpace ) == CE_None )
return CE_None;
}
/* ==================================================================== */
/* 1. Simplest case when we should get contiguous block */
/* of uninterleaved pixels. */
/* ==================================================================== */
if ( nXSize == GetXSize()
&& nXSize == nBufXSize
&& nYSize == nBufYSize
&& eBufType == eDataType
&& nPixelOffset == nBandDataSize
&& nPixelSpace == nBufDataSize
&& nLineSpace == nPixelSpace * nXSize )
{
if ( AccessBlock( nImgOffset
+ (vsi_l_offset)nYOff * nLineOffset + nXOff,
nXSize * nYSize * nBandDataSize, pData ) != CE_None )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read %d bytes at %lu.",
nXSize * nYSize * nBandDataSize,
(unsigned long)
(nImgOffset + (vsi_l_offset)nYOff * nLineOffset
+ nXOff) );
}
}
/* ==================================================================== */
/* 2. Case when we need deinterleave and/or subsample data. */
/* ==================================================================== */
else
{
GByte *pabyData;
double dfSrcXInc, dfSrcYInc;
int iLine;
dfSrcXInc = (double)nXSize / nBufXSize;
dfSrcYInc = (double)nYSize / nBufYSize;
pabyData = (GByte *) CPLMalloc( nBytesToRW );
for ( iLine = 0; iLine < nBufYSize; iLine++ )
{
if ( AccessBlock( nImgOffset
+ ((vsi_l_offset)nYOff
+ (int)(iLine * dfSrcYInc)) * nLineOffset
+ nXOff * nPixelOffset,
nBytesToRW, pabyData ) != CE_None )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read %d bytes at %lu.",
nBytesToRW,
(unsigned long)(nImgOffset
+ ((vsi_l_offset)nYOff
+ (int)(iLine * dfSrcYInc)) * nLineOffset
+ nXOff * nPixelOffset) );
}
/* -------------------------------------------------------------------- */
/* Copy data from disk buffer to user block buffer and subsample, */
/* if needed. */
/* -------------------------------------------------------------------- */
if ( nXSize == nBufXSize && nYSize == nBufYSize )
{
GDALCopyWords( pabyData, eDataType, nPixelOffset,
(GByte *)pData + iLine * nLineSpace,
eBufType, nPixelSpace, nXSize );
}
else
{
int iPixel;
for ( iPixel = 0; iPixel < nBufXSize; iPixel++ )
{
GDALCopyWords( pabyData +
(int)(iPixel * dfSrcXInc) * nPixelOffset,
eDataType, 0,
(GByte *)pData + iLine * nLineSpace +
iPixel * nBufDataSize,
eBufType, nPixelSpace, 1 );
}
}
}
CPLFree( pabyData );
}
}
/* ==================================================================== */
/* Write data. */
/* ==================================================================== */
else
{
int nBytesActuallyWritten;
/* ==================================================================== */
/* 1. Simplest case when we should write contiguous block */
/* of uninterleaved pixels. */
/* ==================================================================== */
if ( nXSize == GetXSize()
&& nXSize == nBufXSize
&& nYSize == nBufYSize
&& eBufType == eDataType
&& nPixelOffset == nBandDataSize
&& nPixelSpace == nBufDataSize
&& nLineSpace == nPixelSpace * nXSize )
{
/* -------------------------------------------------------------------- */
/* Byte swap the data buffer, if required. */
/* -------------------------------------------------------------------- */
if( !bNativeOrder && eDataType != GDT_Byte )
{
if( GDALDataTypeIsComplex( eDataType ) )
{
int nWordSize;
nWordSize = GDALGetDataTypeSize(eDataType)/16;
GDALSwapWords( pData, nWordSize, nXSize, nPixelOffset );
GDALSwapWords( ((GByte *) pData) + nWordSize,
nWordSize, nXSize, nPixelOffset );
}
else
GDALSwapWords( pData, nBandDataSize, nXSize, nPixelOffset );
}
/* -------------------------------------------------------------------- */
/* Seek to the right block. */
/* -------------------------------------------------------------------- */
if( Seek( nImgOffset + (vsi_l_offset)nYOff * nLineOffset + nXOff,
SEEK_SET) == -1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to seek to %lu to write data.\n",
(unsigned long)(nImgOffset + (vsi_l_offset)nYOff
* nLineOffset + nXOff) );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Write the block. */
/* -------------------------------------------------------------------- */
nBytesToRW = nXSize * nYSize * nBandDataSize;
nBytesActuallyWritten = Write( pData, 1, nBytesToRW );
if( nBytesActuallyWritten < nBytesToRW )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to write %d bytes to file. %d bytes written",
nBytesToRW, nBytesActuallyWritten );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Byte swap (if necessary) back into machine order so the */
/* buffer is still usable for reading purposes. */
/* -------------------------------------------------------------------- */
if( !bNativeOrder && eDataType != GDT_Byte )
{
if( GDALDataTypeIsComplex( eDataType ) )
{
int nWordSize;
nWordSize = GDALGetDataTypeSize(eDataType)/16;
GDALSwapWords( pData, nWordSize, nXSize, nPixelOffset );
GDALSwapWords( ((GByte *) pData) + nWordSize,
nWordSize, nXSize, nPixelOffset );
}
else
GDALSwapWords( pData, nBandDataSize, nXSize, nPixelOffset );
}
}
/* ==================================================================== */
/* 2. Case when we need deinterleave and/or subsample data. */
/* ==================================================================== */
else
{
GByte *pabyData;
double dfSrcXInc, dfSrcYInc;
vsi_l_offset nBlockOff;
int iLine;
dfSrcXInc = (double)nXSize / nBufXSize;
dfSrcYInc = (double)nYSize / nBufYSize;
pabyData = (GByte *) CPLMalloc( nBytesToRW );
for ( iLine = 0; iLine < nBufYSize; iLine++ )
{
nBlockOff = nImgOffset
+ ((vsi_l_offset)nYOff + (int)(iLine*dfSrcYInc))*nLineOffset
+ nXOff * nPixelOffset;
/* -------------------------------------------------------------------- */
/* If the data for this band is completely contiguous we don't */
/* have to worry about pre-reading from disk. */
/* -------------------------------------------------------------------- */
if( nPixelOffset > nBandDataSize )
AccessBlock( nBlockOff, nBytesToRW, pabyData );
/* -------------------------------------------------------------------- */
/* Copy data from user block buffer to disk buffer and subsample, */
/* if needed. */
/* -------------------------------------------------------------------- */
if ( nXSize == nBufXSize && nYSize == nBufYSize )
{
GDALCopyWords( (GByte *)pData + iLine * nLineSpace,
eBufType, nPixelSpace,
pabyData, eDataType, nPixelOffset, nXSize );
}
else
{
int iPixel;
for ( iPixel = 0; iPixel < nBufXSize; iPixel++ )
{
GDALCopyWords( (GByte *)pData+iLine*nLineSpace +
iPixel * nBufDataSize,
eBufType, nPixelSpace,
pabyData +
(int)(iPixel * dfSrcXInc) * nPixelOffset,
eDataType, 0, 1 );
}
}
/* -------------------------------------------------------------------- */
/* Byte swap the data buffer, if required. */
/* -------------------------------------------------------------------- */
if( !bNativeOrder && eDataType != GDT_Byte )
{
if( GDALDataTypeIsComplex( eDataType ) )
{
int nWordSize;
nWordSize = GDALGetDataTypeSize(eDataType)/16;
GDALSwapWords( pabyData, nWordSize, nXSize, nPixelOffset );
GDALSwapWords( ((GByte *) pabyData) + nWordSize,
nWordSize, nXSize, nPixelOffset );
}
else
GDALSwapWords( pabyData, nBandDataSize, nXSize,
nPixelOffset );
}
/* -------------------------------------------------------------------- */
/* Seek to the right line in block. */
/* -------------------------------------------------------------------- */
if( Seek( nBlockOff, SEEK_SET) == -1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to seek to %ld to read.\n",
(long)nBlockOff );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Write the line of block. */
/* -------------------------------------------------------------------- */
nBytesActuallyWritten = Write( pabyData, 1, nBytesToRW );
if( nBytesActuallyWritten < nBytesToRW )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to write %d bytes to file. %d bytes written",
nBytesToRW, nBytesActuallyWritten );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Byte swap (if necessary) back into machine order so the */
/* buffer is still usable for reading purposes. */
/* -------------------------------------------------------------------- */
if( !bNativeOrder && eDataType != GDT_Byte )
{
if( GDALDataTypeIsComplex( eDataType ) )
{
int nWordSize;
nWordSize = GDALGetDataTypeSize(eDataType)/16;
GDALSwapWords( pabyData, nWordSize, nXSize, nPixelOffset );
GDALSwapWords( ((GByte *) pabyData) + nWordSize,
nWordSize, nXSize, nPixelOffset );
}
else
GDALSwapWords( pabyData, nBandDataSize, nXSize,
nPixelOffset );
}
}
bDirty = TRUE;
CPLFree( pabyData );
}
}
return CE_None;
}
CPLErr VRTSourcedRasterBand::GetHistogram( double dfMin, double dfMax,
int nBuckets, int *panHistogram,
int bIncludeOutOfRange, int bApproxOK,
GDALProgressFunc pfnProgress,
void *pProgressData )
{
if( nSources != 1 )
return GDALRasterBand::GetHistogram( dfMin, dfMax,
nBuckets, panHistogram,
bIncludeOutOfRange, bApproxOK,
pfnProgress, pProgressData );
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
/* -------------------------------------------------------------------- */
/* If we have overviews, use them for the histogram. */
/* -------------------------------------------------------------------- */
if( bApproxOK && GetOverviewCount() > 0 && !HasArbitraryOverviews() )
{
// FIXME: should we use the most reduced overview here or use some
// minimum number of samples like GDALRasterBand::ComputeStatistics()
// does?
GDALRasterBand *poBestOverview = GetRasterSampleOverview( 0 );
if( poBestOverview != this )
{
return poBestOverview->GetHistogram( dfMin, dfMax, nBuckets,
panHistogram,
bIncludeOutOfRange, bApproxOK,
pfnProgress, pProgressData );
}
}
/* -------------------------------------------------------------------- */
/* Try with source bands. */
/* -------------------------------------------------------------------- */
if ( bAntiRecursionFlag )
{
CPLError( CE_Failure, CPLE_AppDefined,
"VRTSourcedRasterBand::GetHistogram() called recursively on the same band. "
"It looks like the VRT is referencing itself." );
return CE_Failure;
}
bAntiRecursionFlag = TRUE;
CPLErr eErr = papoSources[0]->GetHistogram(GetXSize(), GetYSize(), dfMin, dfMax, nBuckets,
panHistogram,
bIncludeOutOfRange, bApproxOK,
pfnProgress, pProgressData);
if (eErr != CE_None)
{
eErr = GDALRasterBand::GetHistogram( dfMin, dfMax,
nBuckets, panHistogram,
bIncludeOutOfRange, bApproxOK,
pfnProgress, pProgressData );
bAntiRecursionFlag = FALSE;
return eErr;
}
bAntiRecursionFlag = FALSE;
return CE_None;
}
