CPLErr GSBGDataset::SetGeoTransform( double *padfGeoTransform )
{
if( eAccess == GA_ReadOnly )
{
CPLError( CE_Failure, CPLE_NoWriteAccess,
"Unable to set GeoTransform, dataset opened read only.\n" );
return CE_Failure;
}
GSBGRasterBand *poGRB = dynamic_cast<GSBGRasterBand *>(GetRasterBand( 1 ));
if( poGRB == NULL || padfGeoTransform == NULL)
return CE_Failure;
/* non-zero transform 2 or 4 or negative 1 or 5 not supported natively */
CPLErr eErr = CE_None;
/*if( padfGeoTransform[2] != 0.0 || padfGeoTransform[4] != 0.0
|| padfGeoTransform[1] < 0.0 || padfGeoTransform[5] < 0.0 )
eErr = GDALPamDataset::SetGeoTransform( padfGeoTransform );
if( eErr != CE_None )
return eErr;*/
double dfMinX = padfGeoTransform[0] + padfGeoTransform[1] / 2;
double dfMaxX =
padfGeoTransform[1] * (nRasterXSize - 0.5) + padfGeoTransform[0];
double dfMinY =
padfGeoTransform[5] * (nRasterYSize - 0.5) + padfGeoTransform[3];
double dfMaxY = padfGeoTransform[3] + padfGeoTransform[5] / 2;
eErr = WriteHeader( fp,
(GInt16) poGRB->nRasterXSize,
(GInt16) poGRB->nRasterYSize,
dfMinX, dfMaxX, dfMinY, dfMaxY,
poGRB->dfMinZ, poGRB->dfMaxZ );
if( eErr == CE_None )
{
poGRB->dfMinX = dfMinX;
poGRB->dfMaxX = dfMaxX;
poGRB->dfMinY = dfMinY;
poGRB->dfMaxY = dfMaxY;
}
return eErr;
}
void GDALPamDataset::PamInitialize()
{
#ifdef PAM_ENABLED
static const char *pszPamDefault = "YES";
#else
static const char *pszPamDefault = "NO";
#endif
if( psPam || (nPamFlags & GPF_DISABLED) )
return;
if( !CSLTestBoolean( CPLGetConfigOption( "GDAL_PAM_ENABLED",
pszPamDefault ) ) )
{
nPamFlags |= GPF_DISABLED;
return;
}
if( EQUAL( CPLGetConfigOption( "GDAL_PAM_MODE", "PAM" ), "AUX") )
nPamFlags |= GPF_AUXMODE;
psPam = new GDALDatasetPamInfo;
psPam->pszPamFilename = NULL;
psPam->pszProjection = NULL;
psPam->bHaveGeoTransform = FALSE;
psPam->nGCPCount = 0;
psPam->pasGCPList = NULL;
psPam->pszGCPProjection = NULL;
int iBand;
for( iBand = 0; iBand < GetRasterCount(); iBand++ )
{
GDALPamRasterBand *poBand = (GDALPamRasterBand *)
GetRasterBand(iBand+1);
if( poBand == NULL || !(poBand->GetMOFlags() & GMO_PAM_CLASS) )
continue;
poBand->PamInitialize();
}
}
CPLErr GS7BGDataset::GetGeoTransform( double *padfGeoTransform )
{
if( padfGeoTransform == NULL )
return CE_Failure;
GS7BGRasterBand *poGRB = (GS7BGRasterBand *)GetRasterBand( 1 );
if( poGRB == NULL )
{
padfGeoTransform[0] = 0;
padfGeoTransform[1] = 1;
padfGeoTransform[2] = 0;
padfGeoTransform[3] = 0;
padfGeoTransform[4] = 0;
padfGeoTransform[5] = 1;
return CE_Failure;
}
/* check if we have a PAM GeoTransform stored */
CPLPushErrorHandler( CPLQuietErrorHandler );
CPLErr eErr = GDALPamDataset::GetGeoTransform( padfGeoTransform );
CPLPopErrorHandler();
if( eErr == CE_None )
return CE_None;
/* calculate pixel size first */
padfGeoTransform[1] = (poGRB->dfMaxX - poGRB->dfMinX)/(nRasterXSize - 1);
padfGeoTransform[5] = (poGRB->dfMinY - poGRB->dfMaxY)/(nRasterYSize - 1);
/* then calculate image origin */
padfGeoTransform[0] = poGRB->dfMinX - padfGeoTransform[1] / 2;
padfGeoTransform[3] = poGRB->dfMaxY - padfGeoTransform[5] / 2;
/* tilt/rotation does not supported by the GS grids */
padfGeoTransform[4] = 0.0;
padfGeoTransform[2] = 0.0;
return CE_None;
}
CPLErr SAGADataset::GetGeoTransform( double *padfGeoTransform )
{
if( padfGeoTransform == NULL )
return CE_Failure;
SAGARasterBand *poGRB = dynamic_cast<SAGARasterBand *>(GetRasterBand( 1 ));
if( poGRB == NULL )
{
padfGeoTransform[0] = 0;
padfGeoTransform[1] = 1;
padfGeoTransform[2] = 0;
padfGeoTransform[3] = 0;
padfGeoTransform[4] = 0;
padfGeoTransform[5] = 1;
return CE_Failure;
}
/* check if we have a PAM GeoTransform stored */
CPLPushErrorHandler( CPLQuietErrorHandler );
CPLErr eErr = GDALPamDataset::GetGeoTransform( padfGeoTransform );
CPLPopErrorHandler();
if( eErr == CE_None )
return CE_None;
padfGeoTransform[1] = poGRB->m_Cellsize;
padfGeoTransform[5] = poGRB->m_Cellsize * -1.0;
padfGeoTransform[0] = poGRB->m_Xmin - poGRB->m_Cellsize / 2;
padfGeoTransform[3] = poGRB->m_Ymin + (nRasterYSize - 1) * poGRB->m_Cellsize + poGRB->m_Cellsize / 2;
/* tilt/rotation is not supported by SAGA grids */
padfGeoTransform[4] = 0.0;
padfGeoTransform[2] = 0.0;
return CE_None;
}
void LANDataset::CheckForStatistics()
{
/* -------------------------------------------------------------------- */
/* Do we have a statistics file? */
/* -------------------------------------------------------------------- */
osSTAFilename = CPLResetExtension(GetDescription(),"sta");
VSILFILE *fpSTA = VSIFOpenL( osSTAFilename, "r" );
if( fpSTA == NULL && VSIIsCaseSensitiveFS(osSTAFilename) )
{
osSTAFilename = CPLResetExtension(GetDescription(),"STA");
fpSTA = VSIFOpenL( osSTAFilename, "r" );
}
if( fpSTA == NULL )
{
osSTAFilename = "";
return;
}
/* -------------------------------------------------------------------- */
/* Read it one band at a time. */
/* -------------------------------------------------------------------- */
GByte abyBandInfo[1152] = { '\0' };
for( int iBand = 0; iBand < nBands; iBand++ )
{
if( VSIFReadL( abyBandInfo, 1152, 1, fpSTA ) != 1 )
break;
const int nBandNumber = abyBandInfo[7];
GDALRasterBand *poBand = GetRasterBand(nBandNumber);
if( poBand == NULL )
break;
GInt16 nMin = 0;
GInt16 nMax = 0;
if( poBand->GetRasterDataType() != GDT_Byte )
{
memcpy( &nMin, abyBandInfo + 28, 2 );
memcpy( &nMax, abyBandInfo + 30, 2 );
CPL_LSBPTR16( &nMin );
CPL_LSBPTR16( &nMax );
}
else
{
nMin = abyBandInfo[9];
nMax = abyBandInfo[8];
}
float fMean = 0.0;
float fStdDev = 0.0;
memcpy( &fMean, abyBandInfo + 12, 4 );
memcpy( &fStdDev, abyBandInfo + 24, 4 );
CPL_LSBPTR32( &fMean );
CPL_LSBPTR32( &fStdDev );
poBand->SetStatistics( nMin, nMax, fMean, fStdDev );
}
CPL_IGNORE_RET_VAL(VSIFCloseL( fpSTA ));
}
void IDADataset::ReadColorTable()
{
/* -------------------------------------------------------------------- */
/* Decide what .clr file to look for and try to open. */
/* -------------------------------------------------------------------- */
CPLString osCLRFilename;
osCLRFilename = CPLGetConfigOption( "IDA_COLOR_FILE", "" );
if( strlen(osCLRFilename) == 0 )
osCLRFilename = CPLResetExtension(GetDescription(), "clr" );
FILE *fp = VSIFOpen( osCLRFilename, "r" );
if( fp == NULL )
{
osCLRFilename = CPLResetExtension(osCLRFilename, "CLR" );
fp = VSIFOpen( osCLRFilename, "r" );
}
if( fp == NULL )
return;
/* -------------------------------------------------------------------- */
/* Skip first line, with the column titles. */
/* -------------------------------------------------------------------- */
CPLReadLine( fp );
/* -------------------------------------------------------------------- */
/* Create a RAT to populate. */
/* -------------------------------------------------------------------- */
GDALRasterAttributeTable *poRAT = new GDALDefaultRasterAttributeTable();
poRAT->CreateColumn( "FROM", GFT_Integer, GFU_Min );
poRAT->CreateColumn( "TO", GFT_Integer, GFU_Max );
poRAT->CreateColumn( "RED", GFT_Integer, GFU_Red );
poRAT->CreateColumn( "GREEN", GFT_Integer, GFU_Green );
poRAT->CreateColumn( "BLUE", GFT_Integer, GFU_Blue );
poRAT->CreateColumn( "LEGEND", GFT_String, GFU_Name );
/* -------------------------------------------------------------------- */
/* Apply lines. */
/* -------------------------------------------------------------------- */
const char *pszLine = CPLReadLine( fp );
int iRow = 0;
while( pszLine != NULL )
{
char **papszTokens =
CSLTokenizeStringComplex( pszLine, " \t", FALSE, FALSE );
if( CSLCount( papszTokens ) >= 5 )
{
poRAT->SetValue( iRow, 0, atoi(papszTokens[0]) );
poRAT->SetValue( iRow, 1, atoi(papszTokens[1]) );
poRAT->SetValue( iRow, 2, atoi(papszTokens[2]) );
poRAT->SetValue( iRow, 3, atoi(papszTokens[3]) );
poRAT->SetValue( iRow, 4, atoi(papszTokens[4]) );
// find name, first nonspace after 5th token.
const char *pszName = pszLine;
// skip from
while( *pszName == ' ' || *pszName == '\t' )
pszName++;
while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' )
pszName++;
// skip to
while( *pszName == ' ' || *pszName == '\t' )
pszName++;
while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' )
pszName++;
// skip red
while( *pszName == ' ' || *pszName == '\t' )
pszName++;
while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' )
pszName++;
// skip green
while( *pszName == ' ' || *pszName == '\t' )
pszName++;
while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' )
pszName++;
// skip blue
while( *pszName == ' ' || *pszName == '\t' )
pszName++;
while( *pszName != ' ' && *pszName != '\t' && *pszName != '\0' )
pszName++;
// skip pre-name white space
while( *pszName == ' ' || *pszName == '\t' )
pszName++;
poRAT->SetValue( iRow, 5, pszName );
iRow++;
}
CSLDestroy( papszTokens );
pszLine = CPLReadLine( fp );
}
VSIFClose( fp );
/* -------------------------------------------------------------------- */
/* Attach RAT to band. */
/* -------------------------------------------------------------------- */
((IDARasterBand *) GetRasterBand( 1 ))->poRAT = poRAT;
/* -------------------------------------------------------------------- */
/* Build a conventional color table from this. */
/* -------------------------------------------------------------------- */
((IDARasterBand *) GetRasterBand( 1 ))->poColorTable =
poRAT->TranslateToColorTable();
}
CPLErr
VRTWarpedDataset::IBuildOverviews( const char *pszResampling,
int nOverviews, int *panOverviewList,
int nListBands, int *panBandList,
GDALProgressFunc pfnProgress,
void * pProgressData )
{
/* -------------------------------------------------------------------- */
/* Initial progress result. */
/* -------------------------------------------------------------------- */
if( !pfnProgress( 0.0, NULL, pProgressData ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Establish which of the overview levels we already have, and */
/* which are new. */
/* -------------------------------------------------------------------- */
int i, nNewOverviews, *panNewOverviewList = NULL;
nNewOverviews = 0;
panNewOverviewList = (int *) CPLCalloc(sizeof(int),nOverviews);
for( i = 0; i < nOverviews; i++ )
{
int j;
for( j = 0; j < nOverviewCount; j++ )
{
int nOvFactor;
VRTWarpedDataset *poOverview = papoOverviews[j];
nOvFactor = (int)
(0.5+GetRasterXSize() / (double) poOverview->GetRasterXSize());
if( nOvFactor == panOverviewList[i]
|| nOvFactor == GDALOvLevelAdjust( panOverviewList[i],
GetRasterXSize() ) )
panOverviewList[i] *= -1;
}
if( panOverviewList[i] > 0 )
panNewOverviewList[nNewOverviews++] = panOverviewList[i];
}
/* -------------------------------------------------------------------- */
/* Create each missing overview (we don't need to do anything */
/* to update existing overviews). */
/* -------------------------------------------------------------------- */
for( i = 0; i < nNewOverviews; i++ )
{
int nOXSize, nOYSize, iBand;
VWOTInfo *psInfo;
VRTWarpedDataset *poOverviewDS;
/* -------------------------------------------------------------------- */
/* What size should this overview be. */
/* -------------------------------------------------------------------- */
nOXSize = (GetRasterXSize() + panNewOverviewList[i] - 1)
/ panNewOverviewList[i];
nOYSize = (GetRasterYSize() + panNewOverviewList[i] - 1)
/ panNewOverviewList[i];
/* -------------------------------------------------------------------- */
/* Create the overview dataset. */
/* -------------------------------------------------------------------- */
poOverviewDS = new VRTWarpedDataset( nOXSize, nOYSize );
for( iBand = 0; iBand < GetRasterCount(); iBand++ )
{
GDALRasterBand *poOldBand = GetRasterBand(iBand+1);
VRTWarpedRasterBand *poNewBand =
new VRTWarpedRasterBand( poOverviewDS, iBand+1,
poOldBand->GetRasterDataType() );
poNewBand->CopyCommonInfoFrom( poOldBand );
poOverviewDS->SetBand( iBand+1, poNewBand );
}
nOverviewCount++;
papoOverviews = (VRTWarpedDataset **)
CPLRealloc( papoOverviews, sizeof(void*) * nOverviewCount );
papoOverviews[nOverviewCount-1] = poOverviewDS;
/* -------------------------------------------------------------------- */
/* Prepare update transformation information that will apply */
/* the overview decimation. */
/* -------------------------------------------------------------------- */
GDALWarpOptions *psWO = (GDALWarpOptions *) poWarper->GetOptions();
psInfo = (VWOTInfo *) CPLCalloc(sizeof(VWOTInfo),1);
strcpy( psInfo->sTI.szSignature, "GTI" );
psInfo->sTI.pszClassName = "VRTWarpedOverviewTransform";
psInfo->sTI.pfnTransform = VRTWarpedOverviewTransform;
psInfo->sTI.pfnCleanup = VRTWarpedOverviewCleanup;
psInfo->sTI.pfnSerialize = NULL;
psInfo->pfnBaseTransformer = psWO->pfnTransformer;
psInfo->pBaseTransformerArg = psWO->pTransformerArg;
psInfo->dfXOverviewFactor = GetRasterXSize() / (double) nOXSize;
psInfo->dfYOverviewFactor = GetRasterYSize() / (double) nOYSize;
/* -------------------------------------------------------------------- */
/* Initialize the new dataset with adjusted warp options, and */
/* then restore to original condition. */
/* -------------------------------------------------------------------- */
psWO->pfnTransformer = VRTWarpedOverviewTransform;
psWO->pTransformerArg = psInfo;
poOverviewDS->Initialize( psWO );
psWO->pfnTransformer = psInfo->pfnBaseTransformer;
psWO->pTransformerArg = psInfo->pBaseTransformerArg;
}
CPLFree( panNewOverviewList );
/* -------------------------------------------------------------------- */
/* Progress finished. */
/* -------------------------------------------------------------------- */
pfnProgress( 1.0, NULL, pProgressData );
SetNeedsFlush();
return CE_None;
}
CPLErr VRTWarpedDataset::ProcessBlock( int iBlockX, int iBlockY )
{
if( poWarper == NULL )
return CE_Failure;
const GDALWarpOptions *psWO = poWarper->GetOptions();
/* -------------------------------------------------------------------- */
/* Allocate block of memory large enough to hold all the bands */
/* for this block. */
/* -------------------------------------------------------------------- */
int iBand;
GByte *pabyDstBuffer;
int nDstBufferSize;
int nWordSize = (GDALGetDataTypeSize(psWO->eWorkingDataType) / 8);
// FIXME? : risk of overflow in multiplication if nBlockXSize or nBlockYSize are very large
nDstBufferSize = nBlockXSize * nBlockYSize * psWO->nBandCount * nWordSize;
pabyDstBuffer = (GByte *) VSIMalloc(nDstBufferSize);
if( pabyDstBuffer == NULL )
{
CPLError( CE_Failure, CPLE_OutOfMemory,
"Out of memory allocating %d byte buffer in VRTWarpedDataset::ProcessBlock()",
nDstBufferSize );
return CE_Failure;
}
memset( pabyDstBuffer, 0, nDstBufferSize );
/* -------------------------------------------------------------------- */
/* Process INIT_DEST option to initialize the buffer prior to */
/* warping into it. */
/* NOTE:The following code is 99% similar in gdalwarpoperation.cpp and */
/* vrtwarped.cpp. Be careful to keep it in sync ! */
/* -------------------------------------------------------------------- */
const char *pszInitDest = CSLFetchNameValue( psWO->papszWarpOptions,
"INIT_DEST" );
if( pszInitDest != NULL && !EQUAL(pszInitDest, "") )
{
char **papszInitValues =
CSLTokenizeStringComplex( pszInitDest, ",", FALSE, FALSE );
int nInitCount = CSLCount(papszInitValues);
for( iBand = 0; iBand < psWO->nBandCount; iBand++ )
{
double adfInitRealImag[2];
GByte *pBandData;
int nBandSize = nBlockXSize * nBlockYSize * nWordSize;
const char *pszBandInit = papszInitValues[MIN(iBand,nInitCount-1)];
if( EQUAL(pszBandInit,"NO_DATA")
&& psWO->padfDstNoDataReal != NULL )
{
adfInitRealImag[0] = psWO->padfDstNoDataReal[iBand];
adfInitRealImag[1] = psWO->padfDstNoDataImag[iBand];
}
else
{
CPLStringToComplex( pszBandInit,
adfInitRealImag + 0, adfInitRealImag + 1);
}
pBandData = ((GByte *) pabyDstBuffer) + iBand * nBandSize;
if( psWO->eWorkingDataType == GDT_Byte )
memset( pBandData,
MAX(0,MIN(255,(int)adfInitRealImag[0])),
nBandSize);
else if( adfInitRealImag[0] == 0.0 && adfInitRealImag[1] == 0 )
{
memset( pBandData, 0, nBandSize );
}
else if( adfInitRealImag[1] == 0.0 )
{
GDALCopyWords( &adfInitRealImag, GDT_Float64, 0,
pBandData,psWO->eWorkingDataType,nWordSize,
nBlockXSize * nBlockYSize );
}
else
{
GDALCopyWords( &adfInitRealImag, GDT_CFloat64, 0,
pBandData,psWO->eWorkingDataType,nWordSize,
nBlockXSize * nBlockYSize );
}
}
CSLDestroy( papszInitValues );
}
/* -------------------------------------------------------------------- */
/* Warp into this buffer. */
/* -------------------------------------------------------------------- */
CPLErr eErr;
eErr =
poWarper->WarpRegionToBuffer(
iBlockX * nBlockXSize, iBlockY * nBlockYSize,
nBlockXSize, nBlockYSize,
pabyDstBuffer, psWO->eWorkingDataType );
if( eErr != CE_None )
{
VSIFree( pabyDstBuffer );
return eErr;
}
/* -------------------------------------------------------------------- */
/* Copy out into cache blocks for each band. */
/* -------------------------------------------------------------------- */
for( iBand = 0; iBand < psWO->nBandCount; iBand++ )
{
GDALRasterBand *poBand;
GDALRasterBlock *poBlock;
poBand = GetRasterBand(iBand+1);
poBlock = poBand->GetLockedBlockRef( iBlockX, iBlockY, TRUE );
CPLAssert( poBlock != NULL && poBlock->GetDataRef() != NULL );
GDALCopyWords( pabyDstBuffer + iBand*nBlockXSize*nBlockYSize*nWordSize,
psWO->eWorkingDataType, nWordSize,
poBlock->GetDataRef(),
poBlock->GetDataType(),
GDALGetDataTypeSize(poBlock->GetDataType())/8,
nBlockXSize * nBlockYSize );
poBlock->DropLock();
}
VSIFree( pabyDstBuffer );
return CE_None;
}
int JPEG2000Dataset::DecodeImage()
{
if (bAlreadyDecoded)
return psImage != NULL;
bAlreadyDecoded = TRUE;
if ( !( psImage = jas_image_decode(psStream, iFormat, 0) ) )
{
CPLDebug( "JPEG2000", "Unable to decode image. Format: %s, %d",
jas_image_fmttostr( iFormat ), iFormat );
return FALSE;
}
/* Case of a JP2 image : check that the properties given by */
/* the JP2 boxes match the ones of the code stream */
if (nBands != 0)
{
if (nBands != jas_image_numcmpts( psImage ))
{
CPLError(CE_Failure, CPLE_AppDefined,
"The number of components indicated in the IHDR box (%d) mismatch "
"the value specified in the code stream (%d)",
nBands, jas_image_numcmpts( psImage ));
jas_image_destroy( psImage );
psImage = NULL;
return FALSE;
}
if (nRasterXSize != jas_image_cmptwidth( psImage, 0 ) ||
nRasterYSize != jas_image_cmptheight( psImage, 0 ) )
{
CPLError(CE_Failure, CPLE_AppDefined,
"The dimensions indicated in the IHDR box (%d x %d) mismatch "
"the value specified in the code stream (%d x %d)",
nRasterXSize, nRasterYSize,
jas_image_cmptwidth( psImage, 0 ),
jas_image_cmptheight( psImage, 0 ));
jas_image_destroy( psImage );
psImage = NULL;
return FALSE;
}
int iBand;
for ( iBand = 0; iBand < nBands; iBand++ )
{
JPEG2000RasterBand* poBand = (JPEG2000RasterBand*) GetRasterBand(iBand+1);
if (poBand->iDepth != jas_image_cmptprec( psImage, iBand ) ||
poBand->bSignedness != jas_image_cmptsgnd( psImage, iBand ))
{
CPLError(CE_Failure, CPLE_AppDefined,
"The bit depth of band %d indicated in the IHDR box (%d) mismatch "
"the value specified in the code stream (%d)",
iBand + 1, poBand->iDepth, jas_image_cmptprec( psImage, iBand ));
jas_image_destroy( psImage );
psImage = NULL;
return FALSE;
}
}
}
/* Ask for YCbCr -> RGB translation */
if ( jas_clrspc_fam( jas_image_clrspc( psImage ) ) ==
JAS_CLRSPC_FAM_YCBCR )
{
jas_image_t *psRGBImage;
jas_cmprof_t *psRGBProf;
CPLDebug( "JPEG2000", "forcing conversion to sRGB");
if (!(psRGBProf = jas_cmprof_createfromclrspc(JAS_CLRSPC_SRGB))) {
CPLDebug( "JPEG2000", "cannot create sRGB profile");
return TRUE;
}
if (!(psRGBImage = jas_image_chclrspc(psImage, psRGBProf, JAS_CMXFORM_INTENT_PER))) {
CPLDebug( "JPEG2000", "cannot convert to sRGB");
jas_cmprof_destroy(psRGBProf);
return TRUE;
}
jas_image_destroy(psImage);
jas_cmprof_destroy(psRGBProf);
psImage = psRGBImage;
}
return TRUE;
}
void ROIPACDataset::FlushCache( void )
{
RawDataset::FlushCache();
GDALRasterBand *band = (GetRasterCount() > 0) ? GetRasterBand(1) : NULL;
if ( eAccess == GA_ReadOnly || band == NULL )
return;
// If opening an existing file in Update mode (i.e. "r+") we need to make
// sure any existing content is cleared, otherwise the file may contain
// trailing content from the previous write.
CPL_IGNORE_RET_VAL(VSIFTruncateL( fpRsc, 0 ));
CPL_IGNORE_RET_VAL(VSIFSeekL( fpRsc, 0, SEEK_SET ));
/* -------------------------------------------------------------------- */
/* Rewrite out the header. */
/* -------------------------------------------------------------------- */
/* -------------------------------------------------------------------- */
/* Raster dimensions. */
/* -------------------------------------------------------------------- */
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %d\n", "WIDTH", nRasterXSize ));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %d\n", "FILE_LENGTH", nRasterYSize ));
/* -------------------------------------------------------------------- */
/* Georeferencing. */
/* -------------------------------------------------------------------- */
if ( pszProjection != NULL )
{
char *pszProjectionTmp = pszProjection;
OGRSpatialReference oSRS;
if( oSRS.importFromWkt( &pszProjectionTmp ) == OGRERR_NONE )
{
int bNorth;
int iUTMZone = oSRS.GetUTMZone( &bNorth );
if ( iUTMZone != 0 )
{
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s%d\n", "PROJECTION", "UTM", iUTMZone ));
}
else if ( oSRS.IsGeographic() )
{
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "PROJECTION", "LL" ));
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"ROI_PAC format only support Latitude/Longitude and "
"UTM projections, discarding projection.");
}
if ( oSRS.GetAttrValue( "DATUM" ) != NULL )
{
if ( strcmp( oSRS.GetAttrValue( "DATUM" ), "WGS_1984" ) == 0 )
{
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "DATUM", "WGS84" ));
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Datum \"%s\" probably not supported in the "
"ROI_PAC format, saving it anyway",
oSRS.GetAttrValue( "DATUM" ) );
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "DATUM", oSRS.GetAttrValue( "DATUM" ) ));
}
}
if ( oSRS.GetAttrValue( "UNIT" ) != NULL )
{
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "X_UNIT", oSRS.GetAttrValue( "UNIT" ) ));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", "Y_UNIT", oSRS.GetAttrValue( "UNIT" ) ));
}
}
}
if( bValidGeoTransform )
{
if ( adfGeoTransform[2] != 0 || adfGeoTransform[4] != 0 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"ROI_PAC format do not support geotransform with "
"rotation, discarding info.");
}
else
{
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "X_FIRST", adfGeoTransform[0] ));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "X_STEP", adfGeoTransform[1] ));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "Y_FIRST", adfGeoTransform[3] ));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "Y_STEP", adfGeoTransform[5] ));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "Z_OFFSET", band->GetOffset(NULL) ));
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %.16g\n", "Z_SCALE", band->GetScale(NULL) ));
}
}
/* -------------------------------------------------------------------- */
/* Metadata stored in the ROI_PAC domain. */
/* -------------------------------------------------------------------- */
char** papszROIPACMetadata = GetMetadata( "ROI_PAC" );
for (int i = 0; i < CSLCount( papszROIPACMetadata ); i++)
{
/* Get the tokens from the metadata item */
char **papszTokens = CSLTokenizeString2( papszROIPACMetadata[i],
"=",
CSLT_STRIPLEADSPACES
| CSLT_STRIPENDSPACES);
if ( CSLCount( papszTokens ) != 2 )
{
CPLDebug("ROI_PAC",
"Line of header file could not be split at = into two elements: %s",
papszROIPACMetadata[i]);
CSLDestroy( papszTokens );
continue;
}
/* Don't write it out if it is one of the bits of metadata that is
* written out elsewhere in this routine */
if ( strcmp( papszTokens[0], "WIDTH" ) == 0
|| strcmp( papszTokens[0], "FILE_LENGTH" ) == 0 )
{
CSLDestroy( papszTokens );
continue;
}
CPL_IGNORE_RET_VAL(VSIFPrintfL( fpRsc, "%-40s %s\n", papszTokens[0], papszTokens[1] ));
CSLDestroy( papszTokens );
}
}
void ISCEDataset::FlushCache( void )
{
RawDataset::FlushCache();
GDALRasterBand *band = (GetRasterCount() > 0) ? GetRasterBand(1) : NULL;
if ( eAccess == GA_ReadOnly || band == NULL )
return;
/* -------------------------------------------------------------------- */
/* Recreate a XML doc with the dataset information. */
/* -------------------------------------------------------------------- */
char sBuf[64];
CPLXMLNode *psDocNode = CPLCreateXMLNode( NULL, CXT_Element, "imageFile" );
CPLXMLNode *psTmpNode
= CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "WIDTH" );
snprintf(sBuf, sizeof(sBuf), "%d", nRasterXSize);
CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "LENGTH" );
snprintf(sBuf, sizeof(sBuf), "%d", nRasterYSize);
CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "NUMBER_BANDS" );
snprintf(sBuf, sizeof(sBuf), "%d", nBands);
CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf );
const char *sType = GDALGetDataTypeName( band->GetRasterDataType() );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "DATA_TYPE" );
CPLCreateXMLElementAndValue( psTmpNode, "value",
CSLFetchNameValue(
(char **)apszGDAL2ISCEDatatypes,
sType ) );
const char *sScheme = apszSchemeNames[eScheme];
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "SCHEME" );
CPLCreateXMLElementAndValue( psTmpNode, "value", sScheme );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "BYTE_ORDER" );
#ifdef CPL_LSB
CPLCreateXMLElementAndValue( psTmpNode, "value", "l" );
#else
CPLCreateXMLElementAndValue( psTmpNode, "value", "b" );
#endif
/* -------------------------------------------------------------------- */
/* Then, add the ISCE domain metadata. */
/* -------------------------------------------------------------------- */
char **papszISCEMetadata = GetMetadata( "ISCE" );
for (int i = 0; i < CSLCount( papszISCEMetadata ); i++)
{
/* Get the tokens from the metadata item */
char **papszTokens = CSLTokenizeString2( papszISCEMetadata[i],
"=",
CSLT_STRIPLEADSPACES
| CSLT_STRIPENDSPACES);
if ( CSLCount( papszTokens ) != 2 )
{
CPLDebug( "ISCE",
"Line of header file could not be split at = into two"
" elements: %s",
papszISCEMetadata[i] );
CSLDestroy( papszTokens );
continue;
}
/* Don't write it out if it is one of the bits of metadata that is
* written out elsewhere in this routine */
if ( strcmp( papszTokens[0], "WIDTH" ) == 0
|| strcmp( papszTokens[0], "LENGTH" ) == 0
|| strcmp( papszTokens[0], "NUMBER_BANDS" ) == 0
|| strcmp( papszTokens[0], "DATA_TYPE" ) == 0
|| strcmp( papszTokens[0], "SCHEME" ) == 0
|| strcmp( papszTokens[0], "BYTE_ORDER" ) == 0 )
{
CSLDestroy( papszTokens );
continue;
}
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", papszTokens[0] );
CPLCreateXMLElementAndValue( psTmpNode, "value", papszTokens[1] );
CSLDestroy( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Write the XML file. */
/* -------------------------------------------------------------------- */
CPLSerializeXMLTreeToFile( psDocNode, pszXMLFilename );
/* -------------------------------------------------------------------- */
/* Free the XML Doc. */
/* -------------------------------------------------------------------- */
CPLDestroyXMLNode( psDocNode );
}
bool GDALApplyVSGDataset::IsInitOK()
{
GDALApplyVSGRasterBand* poBand =
reinterpret_cast<GDALApplyVSGRasterBand*>(GetRasterBand(1));
return poBand->m_pafSrcData != nullptr && poBand->m_pafGridData != nullptr;
}
int NTv2Dataset::OpenGrid( char *pachHeader, vsi_l_offset nGridOffset )
{
this->nGridOffset = nGridOffset;
/* -------------------------------------------------------------------- */
/* Read the grid header. */
/* -------------------------------------------------------------------- */
double s_lat, n_lat, e_long, w_long, lat_inc, long_inc;
CaptureMetadataItem( pachHeader + 0*16 );
CaptureMetadataItem( pachHeader + 1*16 );
CaptureMetadataItem( pachHeader + 2*16 );
CaptureMetadataItem( pachHeader + 3*16 );
memcpy( &s_lat, pachHeader + 4*16 + 8, 8 );
memcpy( &n_lat, pachHeader + 5*16 + 8, 8 );
memcpy( &e_long, pachHeader + 6*16 + 8, 8 );
memcpy( &w_long, pachHeader + 7*16 + 8, 8 );
memcpy( &lat_inc, pachHeader + 8*16 + 8, 8 );
memcpy( &long_inc, pachHeader + 9*16 + 8, 8 );
e_long *= -1;
w_long *= -1;
nRasterXSize = (int) floor((e_long - w_long) / long_inc + 1.5);
nRasterYSize = (int) floor((n_lat - s_lat) / lat_inc + 1.5);
if (!GDALCheckDatasetDimensions(nRasterXSize, nRasterYSize))
return FALSE;
/* -------------------------------------------------------------------- */
/* Create band information object. */
/* */
/* We use unusual offsets to remap from bottom to top, to top */
/* to bottom orientation, and also to remap east to west, to */
/* west to east. */
/* -------------------------------------------------------------------- */
int iBand;
for( iBand = 0; iBand < 4; iBand++ )
{
RawRasterBand *poBand =
new RawRasterBand( this, iBand+1, fpImage,
nGridOffset + 4*iBand + 11*16
+ (nRasterXSize-1) * 16
+ (nRasterYSize-1) * 16 * nRasterXSize,
-16, -16 * nRasterXSize,
GDT_Float32, CPL_IS_LSB, TRUE, FALSE );
SetBand( iBand+1, poBand );
}
GetRasterBand(1)->SetDescription( "Latitude Offset (arc seconds)" );
GetRasterBand(2)->SetDescription( "Longitude Offset (arc seconds)" );
GetRasterBand(3)->SetDescription( "Latitude Error" );
GetRasterBand(4)->SetDescription( "Longitude Error" );
/* -------------------------------------------------------------------- */
/* Setup georeferencing. */
/* -------------------------------------------------------------------- */
adfGeoTransform[0] = (w_long - long_inc*0.5) / 3600.0;
adfGeoTransform[1] = long_inc / 3600.0;
adfGeoTransform[2] = 0.0;
adfGeoTransform[3] = (n_lat + lat_inc*0.5) / 3600.0;
adfGeoTransform[4] = 0.0;
adfGeoTransform[5] = (-1 * lat_inc) / 3600.0;
return TRUE;
}
CPLErr RasterliteDataset::CreateOverviewLevel(const char * pszResampling,
int nOvrFactor,
char** papszOptions,
GDALProgressFunc pfnProgress,
void * pProgressData)
{
double dfXResolution = padfXResolutions[0] * nOvrFactor;
double dfYResolution = padfXResolutions[0] * nOvrFactor;
CPLString osSQL;
int nOvrXSize = nRasterXSize / nOvrFactor;
int nOvrYSize = nRasterYSize / nOvrFactor;
if (nOvrXSize == 0 || nOvrYSize == 0)
return CE_Failure;
int bTiled = CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "TILED", "YES"));
int nBlockXSize, nBlockYSize;
if (bTiled)
{
nBlockXSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKXSIZE", "256"));
nBlockYSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKYSIZE", "256"));
if (nBlockXSize < 64) nBlockXSize = 64;
else if (nBlockXSize > 4096) nBlockXSize = 4096;
if (nBlockYSize < 64) nBlockYSize = 64;
else if (nBlockYSize > 4096) nBlockYSize = 4096;
}
else
{
nBlockXSize = nOvrXSize;
nBlockYSize = nOvrYSize;
}
int nXBlocks = (nOvrXSize + nBlockXSize - 1) / nBlockXSize;
int nYBlocks = (nOvrYSize + nBlockYSize - 1) / nBlockYSize;
const char* pszDriverName = CSLFetchNameValueDef(papszOptions, "DRIVER", "GTiff");
if (EQUAL(pszDriverName, "MEM") || EQUAL(pszDriverName, "VRT"))
{
CPLError(CE_Failure, CPLE_AppDefined, "GDAL %s driver cannot be used as underlying driver",
pszDriverName);
return CE_Failure;
}
GDALDriverH hTileDriver = GDALGetDriverByName(pszDriverName);
if (hTileDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL %s driver", pszDriverName);
return CE_Failure;
}
GDALDriverH hMemDriver = GDALGetDriverByName("MEM");
if (hMemDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL MEM driver");
return CE_Failure;
}
GDALDataType eDataType = GetRasterBand(1)->GetRasterDataType();
int nDataTypeSize = GDALGetDataTypeSize(eDataType) / 8;
GByte* pabyMEMDSBuffer =
(GByte*)VSIMalloc3(nBlockXSize, nBlockYSize, nBands * nDataTypeSize);
if (pabyMEMDSBuffer == NULL)
{
return CE_Failure;
}
CPLString osTempFileName;
osTempFileName.Printf("/vsimem/%p", hDS);
int nTileId = 0;
int nBlocks = 0;
int nTotalBlocks = nXBlocks * nYBlocks;
CPLString osRasterLayer;
osRasterLayer.Printf("%s_rasters", osTableName.c_str());
CPLString osMetatadataLayer;
osMetatadataLayer.Printf("%s_metadata", osTableName.c_str());
OGRLayerH hRasterLayer = OGR_DS_GetLayerByName(hDS, osRasterLayer.c_str());
OGRLayerH hMetadataLayer = OGR_DS_GetLayerByName(hDS, osMetatadataLayer.c_str());
CPLString osSourceName = "unknown";
osSQL.Printf("SELECT source_name FROM \"%s\" WHERE "
"%s LIMIT 1",
osMetatadataLayer.c_str(),
RasterliteGetPixelSizeCond(padfXResolutions[0], padfYResolutions[0]).c_str());
OGRLayerH hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
const char* pszVal = OGR_F_GetFieldAsString(hFeat, 0);
if (pszVal)
osSourceName = pszVal;
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
/* -------------------------------------------------------------------- */
/* Compute up to which existing overview level we can use for */
/* computing the requested overview */
/* -------------------------------------------------------------------- */
int iLev;
nLimitOvrCount = 0;
for(iLev=1;iLev<nResolutions;iLev++)
{
if (!(padfXResolutions[iLev] < dfXResolution - 1e-10 &&
padfYResolutions[iLev] < dfYResolution - 1e-10))
{
break;
}
nLimitOvrCount++;
}
/* -------------------------------------------------------------------- */
/* Allocate buffer for tile of previous overview level */
/* -------------------------------------------------------------------- */
GDALDataset* poPrevOvrLevel =
(papoOverviews != NULL && iLev >= 2 && iLev <= nResolutions && papoOverviews[iLev-2]) ?
papoOverviews[iLev-2] : this;
double dfRatioPrevOvr = poPrevOvrLevel->GetRasterBand(1)->GetXSize() / nOvrXSize;
int nPrevOvrBlockXSize = (int)(nBlockXSize * dfRatioPrevOvr + 0.5);
int nPrevOvrBlockYSize = (int)(nBlockYSize * dfRatioPrevOvr + 0.5);
GByte* pabyPrevOvrMEMDSBuffer = NULL;
if( !EQUALN(pszResampling, "NEAR", 4))
{
pabyPrevOvrMEMDSBuffer =
(GByte*)VSIMalloc3(nPrevOvrBlockXSize, nPrevOvrBlockYSize, nBands * nDataTypeSize);
if (pabyPrevOvrMEMDSBuffer == NULL)
{
VSIFree(pabyMEMDSBuffer);
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Iterate over blocks to add data into raster and metadata tables */
/* -------------------------------------------------------------------- */
char** papszTileDriverOptions = RasterliteGetTileDriverOptions(papszOptions);
OGR_DS_ExecuteSQL(hDS, "BEGIN", NULL, NULL);
CPLErr eErr = CE_None;
int nBlockXOff, nBlockYOff;
for(nBlockYOff=0;eErr == CE_None && nBlockYOff<nYBlocks;nBlockYOff++)
{
for(nBlockXOff=0;eErr == CE_None && nBlockXOff<nXBlocks;nBlockXOff++)
{
GDALDatasetH hPrevOvrMemDS = NULL;
/* -------------------------------------------------------------------- */
/* Create in-memory tile */
/* -------------------------------------------------------------------- */
int nReqXSize = nBlockXSize, nReqYSize = nBlockYSize;
if ((nBlockXOff+1) * nBlockXSize > nOvrXSize)
nReqXSize = nOvrXSize - nBlockXOff * nBlockXSize;
if ((nBlockYOff+1) * nBlockYSize > nOvrYSize)
nReqYSize = nOvrYSize - nBlockYOff * nBlockYSize;
if( pabyPrevOvrMEMDSBuffer != NULL )
{
int nPrevOvrReqXSize =
(int)(nReqXSize * dfRatioPrevOvr + 0.5);
int nPrevOvrReqYSize =
(int)(nReqYSize * dfRatioPrevOvr + 0.5);
eErr = RasterIO(GF_Read,
nBlockXOff * nBlockXSize * nOvrFactor,
nBlockYOff * nBlockYSize * nOvrFactor,
nReqXSize * nOvrFactor, nReqYSize * nOvrFactor,
pabyPrevOvrMEMDSBuffer, nPrevOvrReqXSize, nPrevOvrReqYSize,
eDataType, nBands, NULL,
0, 0, 0, NULL);
if (eErr != CE_None)
{
break;
}
hPrevOvrMemDS = GDALCreate(hMemDriver, "MEM:::",
nPrevOvrReqXSize, nPrevOvrReqYSize, 0,
eDataType, NULL);
if (hPrevOvrMemDS == NULL)
{
eErr = CE_Failure;
break;
}
int iBand;
for(iBand = 0; iBand < nBands; iBand ++)
{
char** papszOptions = NULL;
char szTmp[64];
memset(szTmp, 0, sizeof(szTmp));
CPLPrintPointer(szTmp,
pabyPrevOvrMEMDSBuffer + iBand * nDataTypeSize *
nPrevOvrReqXSize * nPrevOvrReqYSize, sizeof(szTmp));
papszOptions = CSLSetNameValue(papszOptions, "DATAPOINTER", szTmp);
GDALAddBand(hPrevOvrMemDS, eDataType, papszOptions);
CSLDestroy(papszOptions);
}
}
else
{
eErr = RasterIO(GF_Read,
nBlockXOff * nBlockXSize * nOvrFactor,
nBlockYOff * nBlockYSize * nOvrFactor,
nReqXSize * nOvrFactor, nReqYSize * nOvrFactor,
pabyMEMDSBuffer, nReqXSize, nReqYSize,
eDataType, nBands, NULL,
0, 0, 0, NULL);
if (eErr != CE_None)
{
break;
}
}
GDALDatasetH hMemDS = GDALCreate(hMemDriver, "MEM:::",
nReqXSize, nReqYSize, 0,
eDataType, NULL);
if (hMemDS == NULL)
{
eErr = CE_Failure;
break;
}
int iBand;
for(iBand = 0; iBand < nBands; iBand ++)
{
char** papszOptions = NULL;
char szTmp[64];
memset(szTmp, 0, sizeof(szTmp));
CPLPrintPointer(szTmp,
pabyMEMDSBuffer + iBand * nDataTypeSize *
nReqXSize * nReqYSize, sizeof(szTmp));
papszOptions = CSLSetNameValue(papszOptions, "DATAPOINTER", szTmp);
GDALAddBand(hMemDS, eDataType, papszOptions);
CSLDestroy(papszOptions);
}
if( hPrevOvrMemDS != NULL )
{
for(iBand = 0; iBand < nBands; iBand ++)
{
GDALRasterBandH hDstOvrBand = GDALGetRasterBand(hMemDS, iBand+1);
eErr = GDALRegenerateOverviews( GDALGetRasterBand(hPrevOvrMemDS, iBand+1),
1, &hDstOvrBand,
pszResampling,
NULL, NULL );
if( eErr != CE_None )
break;
}
GDALClose(hPrevOvrMemDS);
}
GDALDatasetH hOutDS = GDALCreateCopy(hTileDriver,
osTempFileName.c_str(), hMemDS, FALSE,
papszTileDriverOptions, NULL, NULL);
GDALClose(hMemDS);
if (hOutDS)
GDALClose(hOutDS);
else
{
eErr = CE_Failure;
break;
}
/* -------------------------------------------------------------------- */
/* Insert new entry into raster table */
/* -------------------------------------------------------------------- */
vsi_l_offset nDataLength;
GByte *pabyData = VSIGetMemFileBuffer( osTempFileName.c_str(),
&nDataLength, FALSE);
OGRFeatureH hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hRasterLayer) );
OGR_F_SetFieldBinary(hFeat, 0, (int)nDataLength, pabyData);
OGR_L_CreateFeature(hRasterLayer, hFeat);
/* Query raster ID to set it as the ID of the associated metadata */
int nRasterID = (int)OGR_F_GetFID(hFeat);
OGR_F_Destroy(hFeat);
VSIUnlink(osTempFileName.c_str());
/* -------------------------------------------------------------------- */
/* Insert new entry into metadata table */
/* -------------------------------------------------------------------- */
hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hMetadataLayer) );
OGR_F_SetFID(hFeat, nRasterID);
OGR_F_SetFieldString(hFeat, 0, osSourceName);
OGR_F_SetFieldInteger(hFeat, 1, nTileId ++);
OGR_F_SetFieldInteger(hFeat, 2, nReqXSize);
OGR_F_SetFieldInteger(hFeat, 3, nReqYSize);
OGR_F_SetFieldDouble(hFeat, 4, dfXResolution);
OGR_F_SetFieldDouble(hFeat, 5, dfYResolution);
double minx, maxx, maxy, miny;
minx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff) * dfXResolution;
maxx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff + nReqXSize) * dfXResolution;
maxy = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff) * (-dfYResolution);
miny = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff + nReqYSize) * (-dfYResolution);
OGRGeometryH hRectangle = OGR_G_CreateGeometry(wkbPolygon);
OGRGeometryH hLinearRing = OGR_G_CreateGeometry(wkbLinearRing);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddGeometryDirectly(hRectangle, hLinearRing);
OGR_F_SetGeometryDirectly(hFeat, hRectangle);
OGR_L_CreateFeature(hMetadataLayer, hFeat);
OGR_F_Destroy(hFeat);
nBlocks++;
if (pfnProgress && !pfnProgress(1.0 * nBlocks / nTotalBlocks,
NULL, pProgressData))
eErr = CE_Failure;
}
}
nLimitOvrCount = -1;
if (eErr == CE_None)
OGR_DS_ExecuteSQL(hDS, "COMMIT", NULL, NULL);
else
OGR_DS_ExecuteSQL(hDS, "ROLLBACK", NULL, NULL);
VSIFree(pabyMEMDSBuffer);
VSIFree(pabyPrevOvrMEMDSBuffer);
CSLDestroy(papszTileDriverOptions);
papszTileDriverOptions = NULL;
/* -------------------------------------------------------------------- */
/* Update raster_pyramids table */
/* -------------------------------------------------------------------- */
if (eErr == CE_None)
{
OGRLayerH hRasterPyramidsLyr = OGR_DS_GetLayerByName(hDS, "raster_pyramids");
if (hRasterPyramidsLyr == NULL)
{
osSQL.Printf ("CREATE TABLE raster_pyramids ("
"table_prefix TEXT NOT NULL,"
"pixel_x_size DOUBLE NOT NULL,"
"pixel_y_size DOUBLE NOT NULL,"
"tile_count INTEGER NOT NULL)");
OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
/* Re-open the DB to take into account the new tables*/
OGRReleaseDataSource(hDS);
hDS = RasterliteOpenSQLiteDB(osFileName.c_str(), GA_Update);
hRasterPyramidsLyr = OGR_DS_GetLayerByName(hDS, "raster_pyramids");
if (hRasterPyramidsLyr == NULL)
return CE_Failure;
}
OGRFeatureDefnH hFDefn = OGR_L_GetLayerDefn(hRasterPyramidsLyr);
/* Insert base resolution into raster_pyramids if not already done */
int bHasBaseResolution = FALSE;
osSQL.Printf("SELECT * FROM raster_pyramids WHERE "
"table_prefix = '%s' AND %s",
osTableName.c_str(),
RasterliteGetPixelSizeCond(padfXResolutions[0], padfYResolutions[0]).c_str());
hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
bHasBaseResolution = TRUE;
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
if (!bHasBaseResolution)
{
osSQL.Printf("SELECT COUNT(*) FROM \"%s\" WHERE %s",
osMetatadataLayer.c_str(),
RasterliteGetPixelSizeCond(padfXResolutions[0], padfYResolutions[0]).c_str());
int nBlocksMainRes = 0;
hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
nBlocksMainRes = OGR_F_GetFieldAsInteger(hFeat, 0);
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
OGRFeatureH hFeat = OGR_F_Create( hFDefn );
OGR_F_SetFieldString(hFeat, OGR_FD_GetFieldIndex(hFDefn, "table_prefix"), osTableName.c_str());
OGR_F_SetFieldDouble(hFeat, OGR_FD_GetFieldIndex(hFDefn, "pixel_x_size"), padfXResolutions[0]);
OGR_F_SetFieldDouble(hFeat, OGR_FD_GetFieldIndex(hFDefn, "pixel_y_size"), padfYResolutions[0]);
OGR_F_SetFieldInteger(hFeat, OGR_FD_GetFieldIndex(hFDefn, "tile_count"), nBlocksMainRes);
OGR_L_CreateFeature(hRasterPyramidsLyr, hFeat);
OGR_F_Destroy(hFeat);
}
OGRFeatureH hFeat = OGR_F_Create( hFDefn );
OGR_F_SetFieldString(hFeat, OGR_FD_GetFieldIndex(hFDefn, "table_prefix"), osTableName.c_str());
OGR_F_SetFieldDouble(hFeat, OGR_FD_GetFieldIndex(hFDefn, "pixel_x_size"), dfXResolution);
OGR_F_SetFieldDouble(hFeat, OGR_FD_GetFieldIndex(hFDefn, "pixel_y_size"), dfYResolution);
OGR_F_SetFieldInteger(hFeat, OGR_FD_GetFieldIndex(hFDefn, "tile_count"), nTotalBlocks);
OGR_L_CreateFeature(hRasterPyramidsLyr, hFeat);
OGR_F_Destroy(hFeat);
}
return eErr;
}
CPLErr GDALPamDataset::CloneInfo( GDALDataset *poSrcDS, int nCloneFlags )
{
int bOnlyIfMissing = nCloneFlags & GCIF_ONLY_IF_MISSING;
int nSavedMOFlags = GetMOFlags();
PamInitialize();
/* -------------------------------------------------------------------- */
/* Supress NotImplemented error messages - mainly needed if PAM */
/* disabled. */
/* -------------------------------------------------------------------- */
SetMOFlags( nSavedMOFlags | GMO_IGNORE_UNIMPLEMENTED );
/* -------------------------------------------------------------------- */
/* GeoTransform */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_GEOTRANSFORM )
{
double adfGeoTransform[6];
if( poSrcDS->GetGeoTransform( adfGeoTransform ) == CE_None )
{
double adfOldGT[6];
if( !bOnlyIfMissing || GetGeoTransform( adfOldGT ) != CE_None )
SetGeoTransform( adfGeoTransform );
}
}
/* -------------------------------------------------------------------- */
/* Projection */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_PROJECTION )
{
const char *pszWKT = poSrcDS->GetProjectionRef();
if( pszWKT != NULL && strlen(pszWKT) > 0 )
{
if( !bOnlyIfMissing
|| GetProjectionRef() == NULL
|| strlen(GetProjectionRef()) == 0 )
SetProjection( pszWKT );
}
}
/* -------------------------------------------------------------------- */
/* GCPs */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_GCPS )
{
if( poSrcDS->GetGCPCount() > 0 )
{
if( !bOnlyIfMissing || GetGCPCount() == 0 )
{
SetGCPs( poSrcDS->GetGCPCount(),
poSrcDS->GetGCPs(),
poSrcDS->GetGCPProjection() );
}
}
}
/* -------------------------------------------------------------------- */
/* Metadata */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_METADATA )
{
if( poSrcDS->GetMetadata() != NULL )
{
if( !bOnlyIfMissing
|| CSLCount(GetMetadata()) != CSLCount(poSrcDS->GetMetadata()) )
{
SetMetadata( poSrcDS->GetMetadata() );
}
}
if( poSrcDS->GetMetadata("RPC") != NULL )
{
if( !bOnlyIfMissing
|| CSLCount(GetMetadata("RPC"))
!= CSLCount(poSrcDS->GetMetadata("RPC")) )
{
SetMetadata( poSrcDS->GetMetadata("RPC"), "RPC" );
}
}
}
/* -------------------------------------------------------------------- */
/* Process bands. */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_PROCESS_BANDS )
{
int iBand;
for( iBand = 0; iBand < GetRasterCount(); iBand++ )
{
GDALPamRasterBand *poBand = (GDALPamRasterBand *)
GetRasterBand(iBand+1);
if( poBand == NULL || !(poBand->GetMOFlags() & GMO_PAM_CLASS) )
continue;
if( poSrcDS->GetRasterCount() >= iBand+1 )
poBand->CloneInfo( poSrcDS->GetRasterBand(iBand+1),
nCloneFlags );
else
CPLDebug( "GDALPamDataset", "Skipping CloneInfo for band not in source, this is a bit unusual!" );
}
}
/* -------------------------------------------------------------------- */
/* Copy masks. These are really copied at a lower level using */
/* GDALDefaultOverviews, for formats with no native mask */
/* support but this is a convenient central point to put this */
/* for most drivers. */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_MASK )
{
GDALDriver::DefaultCopyMasks( poSrcDS, this, FALSE );
}
/* -------------------------------------------------------------------- */
/* Restore MO flags. */
/* -------------------------------------------------------------------- */
SetMOFlags( nSavedMOFlags );
return CE_None;
}
CPLErr GDALPamDataset::XMLInit( CPLXMLNode *psTree, const char *pszVRTPath )
{
/* -------------------------------------------------------------------- */
/* Check for an SRS node. */
/* -------------------------------------------------------------------- */
if( strlen(CPLGetXMLValue(psTree, "SRS", "")) > 0 )
{
OGRSpatialReference oSRS;
CPLFree( psPam->pszProjection );
psPam->pszProjection = NULL;
if( oSRS.SetFromUserInput( CPLGetXMLValue(psTree, "SRS", "") )
== OGRERR_NONE )
oSRS.exportToWkt( &(psPam->pszProjection) );
}
/* -------------------------------------------------------------------- */
/* Check for a GeoTransform node. */
/* -------------------------------------------------------------------- */
if( strlen(CPLGetXMLValue(psTree, "GeoTransform", "")) > 0 )
{
const char *pszGT = CPLGetXMLValue(psTree, "GeoTransform", "");
char **papszTokens;
papszTokens = CSLTokenizeStringComplex( pszGT, ",", FALSE, FALSE );
if( CSLCount(papszTokens) != 6 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"GeoTransform node does not have expected six values.");
}
else
{
for( int iTA = 0; iTA < 6; iTA++ )
psPam->adfGeoTransform[iTA] = atof(papszTokens[iTA]);
psPam->bHaveGeoTransform = TRUE;
}
CSLDestroy( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Check for GCPs. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psGCPList = CPLGetXMLNode( psTree, "GCPList" );
if( psGCPList != NULL )
{
CPLXMLNode *psXMLGCP;
OGRSpatialReference oSRS;
const char *pszRawProj = CPLGetXMLValue(psGCPList, "Projection", "");
CPLFree( psPam->pszGCPProjection );
if( strlen(pszRawProj) > 0
&& oSRS.SetFromUserInput( pszRawProj ) == OGRERR_NONE )
oSRS.exportToWkt( &(psPam->pszGCPProjection) );
else
psPam->pszGCPProjection = CPLStrdup("");
// Count GCPs.
int nGCPMax = 0;
for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;
psXMLGCP = psXMLGCP->psNext )
nGCPMax++;
psPam->pasGCPList = (GDAL_GCP *) CPLCalloc(sizeof(GDAL_GCP),nGCPMax);
for( psXMLGCP = psGCPList->psChild; psXMLGCP != NULL;
psXMLGCP = psXMLGCP->psNext )
{
GDAL_GCP *psGCP = psPam->pasGCPList + psPam->nGCPCount;
if( !EQUAL(psXMLGCP->pszValue,"GCP") ||
psXMLGCP->eType != CXT_Element )
continue;
GDALInitGCPs( 1, psGCP );
CPLFree( psGCP->pszId );
psGCP->pszId = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Id",""));
CPLFree( psGCP->pszInfo );
psGCP->pszInfo = CPLStrdup(CPLGetXMLValue(psXMLGCP,"Info",""));
psGCP->dfGCPPixel = atof(CPLGetXMLValue(psXMLGCP,"Pixel","0.0"));
psGCP->dfGCPLine = atof(CPLGetXMLValue(psXMLGCP,"Line","0.0"));
psGCP->dfGCPX = atof(CPLGetXMLValue(psXMLGCP,"X","0.0"));
psGCP->dfGCPY = atof(CPLGetXMLValue(psXMLGCP,"Y","0.0"));
psGCP->dfGCPZ = atof(CPLGetXMLValue(psXMLGCP,"Z","0.0"));
psPam->nGCPCount++;
}
}
/* -------------------------------------------------------------------- */
/* Apply any dataset level metadata. */
/* -------------------------------------------------------------------- */
oMDMD.XMLInit( psTree, TRUE );
/* -------------------------------------------------------------------- */
/* Process bands. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psBandTree;
for( psBandTree = psTree->psChild;
psBandTree != NULL; psBandTree = psBandTree->psNext )
{
if( psBandTree->eType != CXT_Element
|| !EQUAL(psBandTree->pszValue,"PAMRasterBand") )
continue;
int nBand = atoi(CPLGetXMLValue( psBandTree, "band", "0"));
if( nBand < 1 || nBand > GetRasterCount() )
continue;
GDALPamRasterBand *poBand = (GDALPamRasterBand *)
GetRasterBand(nBand);
if( poBand == NULL || !(poBand->GetMOFlags() & GMO_PAM_CLASS) )
continue;
poBand->XMLInit( psBandTree, pszVRTPath );
}
/* -------------------------------------------------------------------- */
/* Clear dirty flag. */
/* -------------------------------------------------------------------- */
nPamFlags &= ~GPF_DIRTY;
return CE_None;
}
void LANDataset::CheckForStatistics()
{
/* -------------------------------------------------------------------- */
/* Do we have a statistics file? */
/* -------------------------------------------------------------------- */
osSTAFilename = CPLResetExtension(GetDescription(),"sta");
FILE *fpSTA = VSIFOpenL( osSTAFilename, "r" );
#ifndef WIN32
if( fpSTA == NULL )
{
osSTAFilename = CPLResetExtension(GetDescription(),"STA");
fpSTA = VSIFOpenL( osSTAFilename, "r" );
}
#endif
if( fpSTA == NULL )
{
osSTAFilename = "";
return;
}
/* -------------------------------------------------------------------- */
/* Read it one band at a time. */
/* -------------------------------------------------------------------- */
GByte abyBandInfo[1152];
int iBand;
for( iBand = 0; iBand < nBands; iBand++ )
{
if( VSIFReadL( abyBandInfo, 1152, 1, fpSTA ) != 1 )
break;
int nBandNumber = abyBandInfo[7];
GDALRasterBand *poBand = GetRasterBand(nBandNumber);
if( poBand == NULL )
break;
float fMean, fStdDev;
GInt16 nMin, nMax;
if( poBand->GetRasterDataType() != GDT_Byte )
{
memcpy( &nMin, abyBandInfo + 28, 2 );
memcpy( &nMax, abyBandInfo + 30, 2 );
CPL_LSBPTR16( &nMin );
CPL_LSBPTR16( &nMax );
}
else
{
nMin = abyBandInfo[9];
nMax = abyBandInfo[8];
}
memcpy( &fMean, abyBandInfo + 12, 4 );
memcpy( &fStdDev, abyBandInfo + 24, 4 );
CPL_LSBPTR32( &fMean );
CPL_LSBPTR32( &fStdDev );
poBand->SetStatistics( nMin, nMax, fMean, fStdDev );
}
VSIFCloseL( fpSTA );
}
CPLXMLNode *GDALPamDataset::SerializeToXML( const char *pszVRTPath )
{
CPLString oFmt;
if( psPam == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Setup root node and attributes. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psDSTree;
psDSTree = CPLCreateXMLNode( NULL, CXT_Element, "PAMDataset" );
/* -------------------------------------------------------------------- */
/* SRS */
/* -------------------------------------------------------------------- */
if( psPam->pszProjection != NULL && strlen(psPam->pszProjection) > 0 )
CPLSetXMLValue( psDSTree, "SRS", psPam->pszProjection );
/* -------------------------------------------------------------------- */
/* GeoTransform. */
/* -------------------------------------------------------------------- */
if( psPam->bHaveGeoTransform )
{
CPLSetXMLValue( psDSTree, "GeoTransform",
oFmt.Printf( "%24.16e,%24.16e,%24.16e,%24.16e,%24.16e,%24.16e",
psPam->adfGeoTransform[0],
psPam->adfGeoTransform[1],
psPam->adfGeoTransform[2],
psPam->adfGeoTransform[3],
psPam->adfGeoTransform[4],
psPam->adfGeoTransform[5] ) );
}
/* -------------------------------------------------------------------- */
/* Metadata. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psMD;
psMD = oMDMD.Serialize();
if( psMD != NULL )
{
if( psMD->psChild == NULL )
CPLDestroyXMLNode( psMD );
else
CPLAddXMLChild( psDSTree, psMD );
}
/* -------------------------------------------------------------------- */
/* GCPs */
/* -------------------------------------------------------------------- */
if( psPam->nGCPCount > 0 )
{
CPLXMLNode *psPamGCPList = CPLCreateXMLNode( psDSTree, CXT_Element,
"GCPList" );
if( psPam->pszGCPProjection != NULL
&& strlen(psPam->pszGCPProjection) > 0 )
CPLSetXMLValue( psPamGCPList, "#Projection",
psPam->pszGCPProjection );
for( int iGCP = 0; iGCP < psPam->nGCPCount; iGCP++ )
{
CPLXMLNode *psXMLGCP;
GDAL_GCP *psGCP = psPam->pasGCPList + iGCP;
psXMLGCP = CPLCreateXMLNode( psPamGCPList, CXT_Element, "GCP" );
CPLSetXMLValue( psXMLGCP, "#Id", psGCP->pszId );
if( psGCP->pszInfo != NULL && strlen(psGCP->pszInfo) > 0 )
CPLSetXMLValue( psXMLGCP, "Info", psGCP->pszInfo );
CPLSetXMLValue( psXMLGCP, "#Pixel",
oFmt.Printf( "%.4f", psGCP->dfGCPPixel ) );
CPLSetXMLValue( psXMLGCP, "#Line",
oFmt.Printf( "%.4f", psGCP->dfGCPLine ) );
CPLSetXMLValue( psXMLGCP, "#X",
oFmt.Printf( "%.12E", psGCP->dfGCPX ) );
CPLSetXMLValue( psXMLGCP, "#Y",
oFmt.Printf( "%.12E", psGCP->dfGCPY ) );
if( psGCP->dfGCPZ != 0.0 )
CPLSetXMLValue( psXMLGCP, "#GCPZ",
oFmt.Printf( "%.12E", psGCP->dfGCPZ ) );
}
}
/* -------------------------------------------------------------------- */
/* Process bands. */
/* -------------------------------------------------------------------- */
int iBand;
for( iBand = 0; iBand < GetRasterCount(); iBand++ )
{
CPLXMLNode *psBandTree;
GDALPamRasterBand *poBand = (GDALPamRasterBand *)
GetRasterBand(iBand+1);
if( poBand == NULL || !(poBand->GetMOFlags() & GMO_PAM_CLASS) )
continue;
psBandTree = poBand->SerializeToXML( pszVRTPath );
if( psBandTree != NULL )
CPLAddXMLChild( psDSTree, psBandTree );
}
/* -------------------------------------------------------------------- */
/* We don't want to return anything if we had no metadata to */
/* attach. */
/* -------------------------------------------------------------------- */
if( psDSTree->psChild == NULL )
{
CPLDestroyXMLNode( psDSTree );
psDSTree = NULL;
}
return psDSTree;
}
CPLErr GDALPamDataset::TryLoadAux()
{
/* -------------------------------------------------------------------- */
/* Initialize PAM. */
/* -------------------------------------------------------------------- */
PamInitialize();
if( psPam == NULL )
return CE_None;
/* -------------------------------------------------------------------- */
/* What is the name of the physical file we are referencing? */
/* We allow an override via the psPam->pszPhysicalFile item. */
/* -------------------------------------------------------------------- */
const char *pszPhysicalFile = psPam->osPhysicalFilename;
if( strlen(pszPhysicalFile) == 0 && GetDescription() != NULL )
pszPhysicalFile = GetDescription();
if( strlen(pszPhysicalFile) == 0 )
return CE_None;
/* -------------------------------------------------------------------- */
/* Try to open .aux file. */
/* -------------------------------------------------------------------- */
GDALDataset *poAuxDS = GDALFindAssociatedAuxFile( pszPhysicalFile,
GA_ReadOnly, this );
if( poAuxDS == NULL )
return CE_None;
/* -------------------------------------------------------------------- */
/* Do we have an SRS on the aux file? */
/* -------------------------------------------------------------------- */
if( strlen(poAuxDS->GetProjectionRef()) > 0 )
GDALPamDataset::SetProjection( poAuxDS->GetProjectionRef() );
/* -------------------------------------------------------------------- */
/* Geotransform. */
/* -------------------------------------------------------------------- */
if( poAuxDS->GetGeoTransform( psPam->adfGeoTransform ) == CE_None )
psPam->bHaveGeoTransform = TRUE;
/* -------------------------------------------------------------------- */
/* GCPs */
/* -------------------------------------------------------------------- */
if( poAuxDS->GetGCPCount() > 0 )
{
psPam->nGCPCount = poAuxDS->GetGCPCount();
psPam->pasGCPList = GDALDuplicateGCPs( psPam->nGCPCount,
poAuxDS->GetGCPs() );
}
/* -------------------------------------------------------------------- */
/* Apply metadata. We likely ought to be merging this in rather */
/* than overwriting everything that was there. */
/* -------------------------------------------------------------------- */
char **papszMD = poAuxDS->GetMetadata();
if( CSLCount(papszMD) > 0 )
{
char **papszMerged =
CSLMerge( CSLDuplicate(GetMetadata()), papszMD );
GDALPamDataset::SetMetadata( papszMerged );
CSLDestroy( papszMerged );
}
papszMD = poAuxDS->GetMetadata("XFORMS");
if( CSLCount(papszMD) > 0 )
{
char **papszMerged =
CSLMerge( CSLDuplicate(GetMetadata("XFORMS")), papszMD );
GDALPamDataset::SetMetadata( papszMerged, "XFORMS" );
CSLDestroy( papszMerged );
}
/* ==================================================================== */
/* Process bands. */
/* ==================================================================== */
int iBand;
for( iBand = 0; iBand < poAuxDS->GetRasterCount(); iBand++ )
{
if( iBand >= GetRasterCount() )
break;
GDALRasterBand *poAuxBand = poAuxDS->GetRasterBand( iBand+1 );
GDALRasterBand *poBand = GetRasterBand( iBand+1 );
papszMD = poAuxBand->GetMetadata();
if( CSLCount(papszMD) > 0 )
{
char **papszMerged =
CSLMerge( CSLDuplicate(poBand->GetMetadata()), papszMD );
poBand->SetMetadata( papszMerged );
CSLDestroy( papszMerged );
}
if( poAuxBand->GetCategoryNames() != NULL )
poBand->SetCategoryNames( poAuxBand->GetCategoryNames() );
if( poAuxBand->GetColorTable() != NULL
&& poBand->GetColorTable() == NULL )
poBand->SetColorTable( poAuxBand->GetColorTable() );
// histograms?
double dfMin, dfMax;
int nBuckets, *panHistogram=NULL;
if( poAuxBand->GetDefaultHistogram( &dfMin, &dfMax,
&nBuckets, &panHistogram,
FALSE, NULL, NULL ) == CE_None )
{
poBand->SetDefaultHistogram( dfMin, dfMax, nBuckets,
panHistogram );
CPLFree( panHistogram );
}
// RAT
if( poAuxBand->GetDefaultRAT() != NULL )
poBand->SetDefaultRAT( poAuxBand->GetDefaultRAT() );
// NoData
int bSuccess = FALSE;
double dfNoDataValue = poAuxBand->GetNoDataValue( &bSuccess );
if( bSuccess )
poBand->SetNoDataValue( dfNoDataValue );
}
GDALClose( poAuxDS );
/* -------------------------------------------------------------------- */
/* Mark PAM info as clean. */
/* -------------------------------------------------------------------- */
nPamFlags &= ~GPF_DIRTY;
return CE_Failure;
}
bool OsmAnd::HeightmapTileProvider_P::obtainData(
const TileId tileId,
const ZoomLevel zoom,
std::shared_ptr<MapTiledData>& outTiledData,
const IQueryController* const queryController)
{
// Obtain raw data from DB
QByteArray data;
bool ok = _tileDb.obtainTileData(tileId, zoom, data);
if (!ok || data.length() == 0)
{
// There was no data at all, to avoid further requests, mark this tile as empty
outTiledData.reset();
return true;
}
// We have the data, use GDAL to decode this GeoTIFF
const auto tileSize = getTileSize();
bool success = false;
QString vmemFilename;
vmemFilename.sprintf("/vsimem/heightmapTile@%p", data.data());
VSIFileFromMemBuffer(qPrintable(vmemFilename), reinterpret_cast<GByte*>(data.data()), data.length(), FALSE);
auto dataset = reinterpret_cast<GDALDataset*>(GDALOpen(qPrintable(vmemFilename), GA_ReadOnly));
if (dataset != nullptr)
{
bool bad = false;
bad = bad || dataset->GetRasterCount() != 1;
bad = bad || dataset->GetRasterXSize() != tileSize;
bad = bad || dataset->GetRasterYSize() != tileSize;
if (bad)
{
if (dataset->GetRasterCount() != 1)
LogPrintf(LogSeverityLevel::Error, "Height tile %dx%d@%d has %d bands instead of 1", tileId.x, tileId.y, zoom, dataset->GetRasterCount());
if (dataset->GetRasterXSize() != tileSize || dataset->GetRasterYSize() != tileSize)
{
LogPrintf(LogSeverityLevel::Error, "Height tile %dx%d@%d has %dx%x size instead of %d", tileId.x, tileId.y, zoom,
dataset->GetRasterXSize(), dataset->GetRasterYSize(), tileSize);
}
}
else
{
auto band = dataset->GetRasterBand(1);
bad = bad || band->GetColorTable() != nullptr;
bad = bad || band->GetRasterDataType() != GDT_Int16;
if (bad)
{
if (band->GetColorTable() != nullptr)
LogPrintf(LogSeverityLevel::Error, "Height tile %dx%d@%d has color table", tileId.x, tileId.y, zoom);
if (band->GetRasterDataType() != GDT_Int16)
LogPrintf(LogSeverityLevel::Error, "Height tile %dx%d@%d has %s data type in band 1", tileId.x, tileId.y, zoom, GDALGetDataTypeName(band->GetRasterDataType()));
}
else
{
auto buffer = new float[tileSize*tileSize];
auto res = dataset->RasterIO(GF_Read, 0, 0, tileSize, tileSize, buffer, tileSize, tileSize, GDT_Float32, 1, nullptr, 0, 0, 0);
if (res != CE_None)
{
delete[] buffer;
LogPrintf(LogSeverityLevel::Error, "Failed to decode height tile %dx%d@%d: %s", tileId.x, tileId.y, zoom, CPLGetLastErrorMsg());
}
else
{
outTiledData.reset(new ElevationDataTile(buffer, sizeof(float)*tileSize, tileSize, tileId, zoom));
success = true;
}
}
}
GDALClose(dataset);
}
VSIUnlink(qPrintable(vmemFilename));
return success;
}
CPLErr MEMDataset::IRasterIO( GDALRWFlag eRWFlag,
int nXOff, int nYOff, int nXSize, int nYSize,
void * pData, int nBufXSize, int nBufYSize,
GDALDataType eBufType,
int nBandCount, int *panBandMap,
GSpacing nPixelSpaceBuf,
GSpacing nLineSpaceBuf,
GSpacing nBandSpaceBuf,
GDALRasterIOExtraArg* psExtraArg)
{
const int eBufTypeSize = GDALGetDataTypeSize(eBufType) / 8;
// Detect if we have a pixel-interleaved buffer and a pixel-interleaved
// dataset.
if( nXSize == nBufXSize && nYSize == nBufYSize &&
nBandCount == nBands && nBands > 1 &&
nBandSpaceBuf == eBufTypeSize &&
nPixelSpaceBuf == nBandSpaceBuf * nBands )
{
GDALDataType eDT = GDT_Unknown;
GByte* pabyData = NULL;
GSpacing nPixelOffset = 0;
GSpacing nLineOffset = 0;
int eDTSize = 0;
int iBandIndex;
for( iBandIndex = 0; iBandIndex < nBandCount; iBandIndex++ )
{
if( panBandMap[iBandIndex] != iBandIndex + 1 )
break;
MEMRasterBand *poBand = reinterpret_cast<MEMRasterBand *>(
GetRasterBand(iBandIndex + 1) );
if( iBandIndex == 0 )
{
eDT = poBand->GetRasterDataType();
pabyData = poBand->pabyData;
nPixelOffset = poBand->nPixelOffset;
nLineOffset = poBand->nLineOffset;
eDTSize = GDALGetDataTypeSize(eDT) / 8;
if( nPixelOffset != static_cast<GSpacing>(nBands) * eDTSize )
break;
}
else if( poBand->GetRasterDataType() != eDT ||
nPixelOffset != poBand->nPixelOffset ||
nLineOffset != poBand->nLineOffset ||
poBand->pabyData != pabyData + iBandIndex * eDTSize )
{
break;
}
}
if( iBandIndex == nBandCount )
{
FlushCache();
if( eRWFlag == GF_Read )
{
for(int iLine=0;iLine<nYSize;iLine++)
{
GDALCopyWords(
pabyData +
nLineOffset*static_cast<size_t>(iLine + nYOff) +
nXOff*nPixelOffset,
eDT,
eDTSize,
reinterpret_cast<GByte *>( pData ) +
nLineSpaceBuf * static_cast<size_t>(iLine),
eBufType,
eBufTypeSize,
nXSize * nBands );
}
}
else
{
for(int iLine=0;iLine<nYSize;iLine++)
{
GDALCopyWords(
reinterpret_cast<GByte *>( pData ) +
nLineSpaceBuf*(size_t)iLine,
eBufType,
eBufTypeSize,
pabyData +
nLineOffset * static_cast<size_t>(iLine + nYOff) +
nXOff*nPixelOffset,
eDT,
eDTSize,
nXSize * nBands);
}
}
return CE_None;
}
}
if( nBufXSize != nXSize || nBufYSize != nYSize )
return GDALDataset::IRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize,
eBufType, nBandCount, panBandMap,
nPixelSpaceBuf, nLineSpaceBuf, nBandSpaceBuf,
psExtraArg );
GDALProgressFunc pfnProgressGlobal = psExtraArg->pfnProgress;
void *pProgressDataGlobal = psExtraArg->pProgressData;
CPLErr eErr = CE_None;
for( int iBandIndex = 0;
iBandIndex < nBandCount && eErr == CE_None;
iBandIndex++ )
{
GDALRasterBand *poBand = GetRasterBand(panBandMap[iBandIndex]);
if (poBand == NULL)
{
eErr = CE_Failure;
break;
}
GByte *pabyBandData
= reinterpret_cast<GByte *>(pData) + iBandIndex * nBandSpaceBuf;
psExtraArg->pfnProgress = GDALScaledProgress;
psExtraArg->pProgressData =
GDALCreateScaledProgress( 1.0 * iBandIndex / nBandCount,
1.0 * (iBandIndex + 1) / nBandCount,
pfnProgressGlobal,
pProgressDataGlobal );
eErr = poBand->RasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
reinterpret_cast<void *>( pabyBandData ),
nBufXSize, nBufYSize,
eBufType, nPixelSpaceBuf, nLineSpaceBuf,
psExtraArg );
GDALDestroyScaledProgress( psExtraArg->pProgressData );
}
psExtraArg->pfnProgress = pfnProgressGlobal;
psExtraArg->pProgressData = pProgressDataGlobal;
return eErr;
}
CPLErr SDEDataset::ComputeRasterInfo() {
long nSDEErr;
SE_RASTERINFO raster;
nSDEErr = SE_rasterinfo_create(&raster);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rasterinfo_create" );
return CE_Fatal;
}
LONG nRasterColumnId = 0;
nSDEErr = SE_rascolinfo_get_id( hRasterColumn,
&nRasterColumnId);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rascolinfo_get_id" );
return CE_Fatal;
}
nSDEErr = SE_raster_get_info_by_id( hConnection,
nRasterColumnId,
1,
raster);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rascolinfo_get_id" );
return CE_Fatal;
}
LONG nBandsRet;
nSDEErr = SE_raster_get_bands( hConnection,
raster,
&paohSDERasterBands,
&nBandsRet);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_raster_get_bands" );
return CE_Fatal;
}
nBands = nBandsRet;
SE_RASBANDINFO band;
// grab our other stuff from the first band and hope for the best
band = paohSDERasterBands[0];
LONG nXSRet, nYSRet;
nSDEErr = SE_rasbandinfo_get_band_size( band, &nXSRet, &nYSRet );
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rasbandinfo_get_band_size" );
return CE_Fatal;
}
nRasterXSize = nXSRet;
nRasterYSize = nYSRet;
SE_ENVELOPE extent;
nSDEErr = SE_rasbandinfo_get_extent(band, &extent);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rasbandinfo_get_extent" );
return CE_Fatal;
}
dfMinX = extent.minx;
dfMinY = extent.miny;
dfMaxX = extent.maxx;
dfMaxY = extent.maxy;
CPLDebug("SDERASTER", "minx: %.5f, miny: %.5f, maxx: %.5f, maxy: %.5f", dfMinX, dfMinY, dfMaxX, dfMaxY);
// x0 roughly corresponds to dfMinX
// y0 roughly corresponds to dfMaxY
// They can be different than the extent parameters because
// SDE uses offsets. The following info is from Duarte Carreira
// in relation to bug #2063 http://trac.osgeo.org/gdal/ticket/2063 :
// Depending on how the data was loaded, the pixel width
// or pixel height may include a pixel offset from the nearest
// tile boundary. An offset will be indicated by aplus sign
// "+" followed by a value. The value indicates the number
// of pixels the nearest tile boundary is to the left of
// the image for the x dimension or the number of
// pixels the nearest tile boundary is above the image for
// the y dimension. The offset information is only useful
// for advanced application developers who need to know
// where the image begins in relation to the underlying tile structure
LFLOAT x0, y0;
nSDEErr = SE_rasbandinfo_get_tile_origin(band, &x0, &y0);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rasbandinfo_get_tile_origin" );
return CE_Fatal;
}
CPLDebug("SDERASTER", "Tile origin: %.5f, %.5f", x0, y0);
// we also need to adjust dfMaxX and dfMinY otherwise the cell size will change
dfMaxX = (x0-dfMinX) + dfMaxX;
dfMinY = (y0-dfMaxY) + dfMinY;
// adjust the bbox based on the tile origin.
dfMinX = MIN(x0, dfMinX);
dfMaxY = MAX(y0, dfMaxY);
nSDEErr = SE_rasterattr_create(&hAttributes, false);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_rasterattr_create" );
return CE_Fatal;
}
// Grab the pointer for our member variable
nSDEErr = SE_stream_create(hConnection, &hStream);
if( nSDEErr != SE_SUCCESS )
{
IssueSDEError( nSDEErr, "SE_stream_create" );
return CE_Fatal;
}
for (int i=0; i < nBands; i++) {
SetBand( i+1, new SDERasterBand( this, i+1, -1, &(paohSDERasterBands[i]) ));
}
GDALRasterBand* b = GetRasterBand(1);
eDataType = b->GetRasterDataType();
SE_rasterinfo_free(raster);
return CE_None;
}
CPLErr GSAGDataset::UpdateHeader()
{
GSAGRasterBand *poBand = (GSAGRasterBand *)GetRasterBand( 1 );
if( poBand == NULL )
{
CPLError( CE_Failure, CPLE_FileIO, "Unable to open raster band.\n" );
return CE_Failure;
}
std::ostringstream ssOutBuf;
ssOutBuf.precision( nFIELD_PRECISION );
ssOutBuf.setf( std::ios::uppercase );
/* signature */
ssOutBuf << "DSAA" << szEOL;
/* columns rows */
ssOutBuf << nRasterXSize << " " << nRasterYSize << szEOL;
/* x range */
ssOutBuf << poBand->dfMinX << " " << poBand->dfMaxX << szEOL;
/* y range */
ssOutBuf << poBand->dfMinY << " " << poBand->dfMaxY << szEOL;
/* z range */
ssOutBuf << poBand->dfMinZ << " " << poBand->dfMaxZ << szEOL;
CPLString sOut = ssOutBuf.str();
if( sOut.length() != poBand->panLineOffset[0] )
{
int nShiftSize = (int) (sOut.length() - poBand->panLineOffset[0]);
if( ShiftFileContents( fp, poBand->panLineOffset[0], nShiftSize,
szEOL ) != CE_None )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to update grid header, "
"failure shifting file contents.\n" );
return CE_Failure;
}
for( size_t iLine=0;
iLine < static_cast<unsigned>(nRasterYSize+1)
&& poBand->panLineOffset[iLine] != 0;
iLine++ )
poBand->panLineOffset[iLine] += nShiftSize;
}
if( VSIFSeekL( fp, 0, SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to seek to start of grid file.\n" );
return CE_Failure;
}
if( VSIFWriteL( sOut.c_str(), 1, sOut.length(), fp ) != sOut.length() )
{
CPLError( CE_Failure, CPLE_FileIO,
"Unable to update file header. Disk full?\n" );
return CE_Failure;
}
return CE_None;
}
CPLErr RasterliteDataset::CreateOverviewLevel(int nOvrFactor,
GDALProgressFunc pfnProgress,
void * pProgressData)
{
double dfXResolution = padfXResolutions[0] * nOvrFactor;
double dfYResolution = padfXResolutions[0] * nOvrFactor;
CPLString osSQL;
int nBlockXSize = 256;
int nBlockYSize = 256;
int nOvrXSize = nRasterXSize / nOvrFactor;
int nOvrYSize = nRasterYSize / nOvrFactor;
if (nOvrXSize == 0 || nOvrYSize == 0)
return CE_Failure;
int nXBlocks = (nOvrXSize + nBlockXSize - 1) / nBlockXSize;
int nYBlocks = (nOvrYSize + nBlockYSize - 1) / nBlockYSize;
const char* pszDriverName = "GTiff";
GDALDriverH hTileDriver = GDALGetDriverByName(pszDriverName);
if (hTileDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL %s driver", pszDriverName);
return CE_Failure;
}
GDALDriverH hMemDriver = GDALGetDriverByName("MEM");
if (hMemDriver == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load GDAL MEM driver");
return CE_Failure;
}
GDALDataType eDataType = GetRasterBand(1)->GetRasterDataType();
int nDataTypeSize = GDALGetDataTypeSize(eDataType) / 8;
GByte* pabyMEMDSBuffer =
(GByte*)VSIMalloc3(nBlockXSize, nBlockYSize, nBands * nDataTypeSize);
if (pabyMEMDSBuffer == NULL)
{
return CE_Failure;
}
char** papszTileDriverOptions = NULL;
CPLString osTempFileName;
osTempFileName.Printf("/vsimem/%p", hDS);
int nTileId = 0;
int nBlocks = 0;
int nTotalBlocks = nXBlocks * nYBlocks;
CPLString osRasterLayer;
osRasterLayer.Printf("%s_rasters", osTableName.c_str());
CPLString osMetatadataLayer;
osMetatadataLayer.Printf("%s_metadata", osTableName.c_str());
OGRLayerH hRasterLayer = OGR_DS_GetLayerByName(hDS, osRasterLayer.c_str());
OGRLayerH hMetadataLayer = OGR_DS_GetLayerByName(hDS, osMetatadataLayer.c_str());
CPLString osSourceName = "unknown";
osSQL.Printf("SELECT source_name FROM \"%s\" WHERE "
"pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND "
"pixel_y_size >= %.15f AND pixel_y_size <= %.15f LIMIT 1",
osMetatadataLayer.c_str(),
padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15,
padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15);
OGRLayerH hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
const char* pszVal = OGR_F_GetFieldAsString(hFeat, 0);
if (pszVal)
osSourceName = pszVal;
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
/* -------------------------------------------------------------------- */
/* Compute up to which existing overview level we can use for */
/* computing the requested overview */
/* -------------------------------------------------------------------- */
int iLev;
nLimitOvrCount = 0;
for(iLev=1;iLev<nResolutions;iLev++)
{
if (!(padfXResolutions[iLev] < dfXResolution - 1e-10 &&
padfYResolutions[iLev] < dfYResolution - 1e-10))
{
break;
}
nLimitOvrCount++;
}
/* -------------------------------------------------------------------- */
/* Iterate over blocks to add data into raster and metadata tables */
/* -------------------------------------------------------------------- */
OGR_DS_ExecuteSQL(hDS, "BEGIN", NULL, NULL);
CPLErr eErr = CE_None;
int nBlockXOff, nBlockYOff;
for(nBlockYOff=0;eErr == CE_None && nBlockYOff<nYBlocks;nBlockYOff++)
{
for(nBlockXOff=0;eErr == CE_None && nBlockXOff<nXBlocks;nBlockXOff++)
{
/* -------------------------------------------------------------------- */
/* Create in-memory tile */
/* -------------------------------------------------------------------- */
int nReqXSize = nBlockXSize, nReqYSize = nBlockYSize;
if ((nBlockXOff+1) * nBlockXSize > nOvrXSize)
nReqXSize = nOvrXSize - nBlockXOff * nBlockXSize;
if ((nBlockYOff+1) * nBlockYSize > nOvrYSize)
nReqYSize = nOvrYSize - nBlockYOff * nBlockYSize;
eErr = RasterIO(GF_Read,
nBlockXOff * nBlockXSize * nOvrFactor,
nBlockYOff * nBlockYSize * nOvrFactor,
nReqXSize * nOvrFactor, nReqYSize * nOvrFactor,
pabyMEMDSBuffer, nReqXSize, nReqYSize,
eDataType, nBands, NULL,
0, 0, 0);
if (eErr != CE_None)
{
break;
}
GDALDatasetH hMemDS = GDALCreate(hMemDriver, "MEM:::",
nReqXSize, nReqYSize, 0,
eDataType, NULL);
if (hMemDS == NULL)
{
eErr = CE_Failure;
break;
}
int iBand;
for(iBand = 0; iBand < nBands; iBand ++)
{
char** papszOptions = NULL;
char szTmp[64];
memset(szTmp, 0, sizeof(szTmp));
CPLPrintPointer(szTmp,
pabyMEMDSBuffer + iBand * nDataTypeSize *
nReqXSize * nReqYSize, sizeof(szTmp));
papszOptions = CSLSetNameValue(papszOptions, "DATAPOINTER", szTmp);
GDALAddBand(hMemDS, eDataType, papszOptions);
CSLDestroy(papszOptions);
}
GDALDatasetH hOutDS = GDALCreateCopy(hTileDriver,
osTempFileName.c_str(), hMemDS, FALSE,
papszTileDriverOptions, NULL, NULL);
GDALClose(hMemDS);
if (hOutDS)
GDALClose(hOutDS);
else
{
eErr = CE_Failure;
break;
}
/* -------------------------------------------------------------------- */
/* Insert new entry into raster table */
/* -------------------------------------------------------------------- */
vsi_l_offset nDataLength;
GByte *pabyData = VSIGetMemFileBuffer( osTempFileName.c_str(),
&nDataLength, FALSE);
OGRFeatureH hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hRasterLayer) );
OGR_F_SetFieldBinary(hFeat, 0, (int)nDataLength, pabyData);
OGR_L_CreateFeature(hRasterLayer, hFeat);
/* Query raster ID to set it as the ID of the associated metadata */
int nRasterID = (int)OGR_F_GetFID(hFeat);
OGR_F_Destroy(hFeat);
VSIUnlink(osTempFileName.c_str());
/* -------------------------------------------------------------------- */
/* Insert new entry into metadata table */
/* -------------------------------------------------------------------- */
hFeat = OGR_F_Create( OGR_L_GetLayerDefn(hMetadataLayer) );
OGR_F_SetFID(hFeat, nRasterID);
OGR_F_SetFieldString(hFeat, 0, osSourceName);
OGR_F_SetFieldInteger(hFeat, 1, nTileId ++);
OGR_F_SetFieldInteger(hFeat, 2, nReqXSize);
OGR_F_SetFieldInteger(hFeat, 3, nReqYSize);
OGR_F_SetFieldDouble(hFeat, 4, dfXResolution);
OGR_F_SetFieldDouble(hFeat, 5, dfYResolution);
double minx, maxx, maxy, miny;
minx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff) * dfXResolution;
maxx = adfGeoTransform[0] +
(nBlockXSize * nBlockXOff + nReqXSize) * dfXResolution;
maxy = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff) * (-dfYResolution);
miny = adfGeoTransform[3] +
(nBlockYSize * nBlockYOff + nReqYSize) * (-dfYResolution);
OGRGeometryH hRectangle = OGR_G_CreateGeometry(wkbPolygon);
OGRGeometryH hLinearRing = OGR_G_CreateGeometry(wkbLinearRing);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, maxy);
OGR_G_AddPoint_2D(hLinearRing, maxx, miny);
OGR_G_AddPoint_2D(hLinearRing, minx, miny);
OGR_G_AddGeometryDirectly(hRectangle, hLinearRing);
OGR_F_SetGeometryDirectly(hFeat, hRectangle);
OGR_L_CreateFeature(hMetadataLayer, hFeat);
OGR_F_Destroy(hFeat);
nBlocks++;
if (pfnProgress && !pfnProgress(1.0 * nBlocks / nTotalBlocks,
NULL, pProgressData))
eErr = CE_Failure;
}
}
nLimitOvrCount = -1;
if (eErr == CE_None)
OGR_DS_ExecuteSQL(hDS, "COMMIT", NULL, NULL);
else
OGR_DS_ExecuteSQL(hDS, "ROLLBACK", NULL, NULL);
VSIFree(pabyMEMDSBuffer);
/* -------------------------------------------------------------------- */
/* Update raster_pyramids table */
/* -------------------------------------------------------------------- */
if (eErr == CE_None)
{
OGRLayerH hRasterPyramidsLyr = OGR_DS_GetLayerByName(hDS, "raster_pyramids");
if (hRasterPyramidsLyr == NULL)
{
osSQL.Printf ("CREATE TABLE raster_pyramids ("
"table_prefix TEXT NOT NULL,"
"pixel_x_size DOUBLE NOT NULL,"
"pixel_y_size DOUBLE NOT NULL,"
"tile_count INTEGER NOT NULL)");
OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
/* Re-open the DB to take into account the new tables*/
OGRReleaseDataSource(hDS);
CPLString osOldVal = CPLGetConfigOption("SQLITE_LIST_ALL_TABLES", "FALSE");
CPLSetThreadLocalConfigOption("SQLITE_LIST_ALL_TABLES", "TRUE");
hDS = OGROpen(osFileName.c_str(), TRUE, NULL);
CPLSetThreadLocalConfigOption("SQLITE_LIST_ALL_TABLES", osOldVal.c_str());
}
/* Insert base resolution into raster_pyramids if not already done */
int bHasBaseResolution = FALSE;
osSQL.Printf("SELECT * FROM raster_pyramids WHERE "
"table_prefix = '%s' AND pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND "
"pixel_y_size >= %.15f AND pixel_y_size <= %.15f",
osTableName.c_str(),
padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15,
padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15);
hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
bHasBaseResolution = TRUE;
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
if (!bHasBaseResolution)
{
osSQL.Printf("SELECT COUNT(*) FROM \"%s\" WHERE "
"pixel_x_size >= %.15f AND pixel_x_size <= %.15f AND "
"pixel_y_size >= %.15f AND pixel_y_size <= %.15f",
osMetatadataLayer.c_str(),
padfXResolutions[0] - 1e-15, padfXResolutions[0] + 1e-15,
padfYResolutions[0] - 1e-15, padfYResolutions[0] + 1e-15);
int nBlocksMainRes = 0;
hSQLLyr = OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
if (hSQLLyr)
{
OGRFeatureH hFeat = OGR_L_GetNextFeature(hSQLLyr);
if (hFeat)
{
nBlocksMainRes = OGR_F_GetFieldAsInteger(hFeat, 0);
OGR_F_Destroy(hFeat);
}
OGR_DS_ReleaseResultSet(hDS, hSQLLyr);
}
osSQL.Printf("INSERT INTO raster_pyramids "
"( table_prefix, pixel_x_size, pixel_y_size, tile_count ) "
"VALUES ( '%s', %.18f, %.18f, %d )",
osTableName.c_str(), padfXResolutions[0], padfYResolutions[0],
nBlocksMainRes);
OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
}
osSQL.Printf("INSERT INTO raster_pyramids "
"( table_prefix, pixel_x_size, pixel_y_size, tile_count ) "
"VALUES ( '%s', %.18f, %.18f, %d )",
osTableName.c_str(), dfXResolution, dfYResolution,
nTotalBlocks);
OGR_DS_ExecuteSQL(hDS, osSQL.c_str(), NULL, NULL);
}
return eErr;
}
CPLErr RawDataset::IRasterIO( GDALRWFlag eRWFlag,
int nXOff, int nYOff, int nXSize, int nYSize,
void *pData, int nBufXSize, int nBufYSize,
GDALDataType eBufType,
int nBandCount, int *panBandMap,
GSpacing nPixelSpace, GSpacing nLineSpace,
GSpacing nBandSpace,
GDALRasterIOExtraArg* psExtraArg )
{
const char* pszInterleave;
/* The default GDALDataset::IRasterIO() implementation would go to */
/* BlockBasedRasterIO if the dataset is interleaved. However if the */
/* access pattern is compatible with DirectIO() we don't want to go */
/* BlockBasedRasterIO, but rather used our optimized path in RawRasterBand::IRasterIO() */
if (nXSize == nBufXSize && nYSize == nBufYSize && nBandCount > 1 &&
(pszInterleave = GetMetadataItem("INTERLEAVE", "IMAGE_STRUCTURE")) != NULL &&
EQUAL(pszInterleave, "PIXEL"))
{
int iBandIndex;
for(iBandIndex = 0; iBandIndex < nBandCount; iBandIndex ++ )
{
RawRasterBand* poBand = (RawRasterBand*) GetRasterBand(panBandMap[iBandIndex]);
if( !poBand->CanUseDirectIO(nXOff, nYOff, nXSize, nYSize, eBufType ) )
{
break;
}
}
if( iBandIndex == nBandCount )
{
GDALProgressFunc pfnProgressGlobal = psExtraArg->pfnProgress;
void *pProgressDataGlobal = psExtraArg->pProgressData;
CPLErr eErr = CE_None;
for( iBandIndex = 0;
iBandIndex < nBandCount && eErr == CE_None;
iBandIndex++ )
{
GDALRasterBand *poBand = GetRasterBand(panBandMap[iBandIndex]);
GByte *pabyBandData;
if (poBand == NULL)
{
eErr = CE_Failure;
break;
}
pabyBandData = ((GByte *) pData) + iBandIndex * nBandSpace;
psExtraArg->pfnProgress = GDALScaledProgress;
psExtraArg->pProgressData =
GDALCreateScaledProgress( 1.0 * iBandIndex / nBandCount,
1.0 * (iBandIndex + 1) / nBandCount,
pfnProgressGlobal,
pProgressDataGlobal );
eErr = poBand->RasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
(void *) pabyBandData, nBufXSize, nBufYSize,
eBufType, nPixelSpace, nLineSpace, psExtraArg );
GDALDestroyScaledProgress( psExtraArg->pProgressData );
}
psExtraArg->pfnProgress = pfnProgressGlobal;
psExtraArg->pProgressData = pProgressDataGlobal;
return eErr;
}
}
return GDALDataset::IRasterIO( eRWFlag, nXOff, nYOff, nXSize, nYSize,
pData, nBufXSize, nBufYSize, eBufType,
nBandCount, panBandMap,
nPixelSpace, nLineSpace, nBandSpace,
psExtraArg);
}
