bool ncepHrrrSurfInitialization::identify( std::string fileName )
{
bool identified = true;
if( fileName.find("nam") != fileName.npos ) {
identified = false;
return identified;
}
//ID based on 10u band
GDALDataset *srcDS;
srcDS = (GDALDataset*)GDALOpenShared( fileName.c_str(), GA_ReadOnly );
if( srcDS == NULL ) {
CPLDebug( "ncepHRRRSurfaceInitialization::identify()",
"Bad forecast file" );
return false;
}
if( srcDS->GetRasterCount() < 8 )
{
/* Short circuit */
GDALClose( (GDALDatasetH)srcDS );
identified = false;
return identified;
}
GDALRasterBand *poBand = srcDS->GetRasterBand( 33 ); //2010 structure
const char *gc;
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
std::string bandName( gc );
if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){
poBand = srcDS->GetRasterBand( 49 ); //files after 2010 have different structure
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
bandName = gc;
if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){
poBand = srcDS->GetRasterBand( 50 ); //2012 files have different structure
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
bandName = gc;
if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){
poBand = srcDS->GetRasterBand( 53 ); //2013 files have different structure
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
bandName = gc;
if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){
identified = false;
}
}
}
}
GDALClose( (GDALDatasetH)srcDS );
return identified;
}
const char *GDALProxyPoolRasterBand::GetMetadataItem( const char * pszName,
const char * pszDomain )
{
if (metadataItemSet == NULL)
metadataItemSet = CPLHashSetNew(hash_func_get_metadata_item,
equal_func_get_metadata_item,
free_func_get_metadata_item);
GDALRasterBand* poUnderlyingRasterBand = RefUnderlyingRasterBand();
if (poUnderlyingRasterBand == NULL)
return NULL;
const char* pszUnderlyingMetadataItem =
poUnderlyingRasterBand->GetMetadataItem(pszName, pszDomain);
GetMetadataItemElt* pElt = (GetMetadataItemElt*) CPLMalloc(sizeof(GetMetadataItemElt));
pElt->pszName = (pszName) ? CPLStrdup(pszName) : NULL;
pElt->pszDomain = (pszDomain) ? CPLStrdup(pszDomain) : NULL;
pElt->pszMetadataItem = (pszUnderlyingMetadataItem) ? CPLStrdup(pszUnderlyingMetadataItem) : NULL;
CPLHashSetInsert(metadataItemSet, pElt);
UnrefUnderlyingRasterBand(poUnderlyingRasterBand);
return pElt->pszMetadataItem;
}
CPLErr
GTIFFBuildOverviews( const char * pszFilename,
int nBands, GDALRasterBand **papoBandList,
int nOverviews, int * panOverviewList,
const char * pszResampling,
GDALProgressFunc pfnProgress, void * pProgressData )
{
TIFF *hOTIFF;
int nBitsPerPixel=0, nCompression=COMPRESSION_NONE, nPhotometric=0;
int nSampleFormat=0, nPlanarConfig, iOverview, iBand;
int nXSize=0, nYSize=0;
if( nBands == 0 || nOverviews == 0 )
return CE_None;
if (!GTiffOneTimeInit())
return CE_Failure;
/* -------------------------------------------------------------------- */
/* Verify that the list of bands is suitable for emitting in */
/* TIFF file. */
/* -------------------------------------------------------------------- */
for( iBand = 0; iBand < nBands; iBand++ )
{
int nBandBits, nBandFormat;
GDALRasterBand *hBand = papoBandList[iBand];
switch( hBand->GetRasterDataType() )
{
case GDT_Byte:
nBandBits = 8;
nBandFormat = SAMPLEFORMAT_UINT;
break;
case GDT_UInt16:
nBandBits = 16;
nBandFormat = SAMPLEFORMAT_UINT;
break;
case GDT_Int16:
nBandBits = 16;
nBandFormat = SAMPLEFORMAT_INT;
break;
case GDT_UInt32:
nBandBits = 32;
nBandFormat = SAMPLEFORMAT_UINT;
break;
case GDT_Int32:
nBandBits = 32;
nBandFormat = SAMPLEFORMAT_INT;
break;
case GDT_Float32:
nBandBits = 32;
nBandFormat = SAMPLEFORMAT_IEEEFP;
break;
case GDT_Float64:
nBandBits = 64;
nBandFormat = SAMPLEFORMAT_IEEEFP;
break;
case GDT_CInt16:
nBandBits = 32;
nBandFormat = SAMPLEFORMAT_COMPLEXINT;
break;
case GDT_CInt32:
nBandBits = 64;
nBandFormat = SAMPLEFORMAT_COMPLEXINT;
break;
case GDT_CFloat32:
nBandBits = 64;
nBandFormat = SAMPLEFORMAT_COMPLEXIEEEFP;
break;
case GDT_CFloat64:
nBandBits = 128;
nBandFormat = SAMPLEFORMAT_COMPLEXIEEEFP;
break;
default:
CPLAssert( FALSE );
return CE_Failure;
}
if( hBand->GetMetadataItem( "NBITS", "IMAGE_STRUCTURE" ) )
{
nBandBits =
atoi(hBand->GetMetadataItem("NBITS","IMAGE_STRUCTURE"));
if( nBandBits == 1
&& EQUALN(pszResampling,"AVERAGE_BIT2",12) )
nBandBits = 8;
}
if( iBand == 0 )
{
nBitsPerPixel = nBandBits;
nSampleFormat = nBandFormat;
nXSize = hBand->GetXSize();
nYSize = hBand->GetYSize();
}
else if( nBitsPerPixel != nBandBits || nSampleFormat != nBandFormat )
{
CPLError( CE_Failure, CPLE_NotSupported,
"GTIFFBuildOverviews() doesn't support a mixture of band"
" data types." );
return CE_Failure;
}
else if( hBand->GetColorTable() != NULL )
{
CPLError( CE_Failure, CPLE_NotSupported,
"GTIFFBuildOverviews() doesn't support building"
" overviews of multiple colormapped bands." );
return CE_Failure;
}
else if( hBand->GetXSize() != nXSize
|| hBand->GetYSize() != nYSize )
{
CPLError( CE_Failure, CPLE_NotSupported,
"GTIFFBuildOverviews() doesn't support building"
" overviews of different sized bands." );
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Use specified compression method. */
/* -------------------------------------------------------------------- */
const char *pszCompress = CPLGetConfigOption( "COMPRESS_OVERVIEW", NULL );
if( pszCompress != NULL && pszCompress[0] != '\0' )
{
nCompression = GTIFFGetCompressionMethod(pszCompress, "COMPRESS_OVERVIEW");
if (nCompression < 0)
return CE_Failure;
}
if( nCompression == COMPRESSION_JPEG && nBitsPerPixel > 8 )
{
if( nBitsPerPixel > 16 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"GTIFFBuildOverviews() doesn't support building"
" JPEG compressed overviews of nBitsPerPixel > 16." );
return CE_Failure;
}
nBitsPerPixel = 12;
}
/* -------------------------------------------------------------------- */
/* Figure out the planar configuration to use. */
/* -------------------------------------------------------------------- */
if( nBands == 1 )
nPlanarConfig = PLANARCONFIG_CONTIG;
else
nPlanarConfig = PLANARCONFIG_SEPARATE;
const char* pszInterleave = CPLGetConfigOption( "INTERLEAVE_OVERVIEW", NULL );
if (pszInterleave != NULL && pszInterleave[0] != '\0')
{
if( EQUAL( pszInterleave, "PIXEL" ) )
nPlanarConfig = PLANARCONFIG_CONTIG;
else if( EQUAL( pszInterleave, "BAND" ) )
nPlanarConfig = PLANARCONFIG_SEPARATE;
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"INTERLEAVE_OVERVIEW=%s unsupported, value must be PIXEL or BAND. ignoring",
pszInterleave );
}
}
/* -------------------------------------------------------------------- */
/* Figure out the photometric interpretation to use. */
/* -------------------------------------------------------------------- */
if( nBands == 3 )
nPhotometric = PHOTOMETRIC_RGB;
else if( papoBandList[0]->GetColorTable() != NULL
&& !EQUALN(pszResampling,"AVERAGE_BIT2",12) )
{
nPhotometric = PHOTOMETRIC_PALETTE;
/* should set the colormap up at this point too! */
}
else
nPhotometric = PHOTOMETRIC_MINISBLACK;
const char* pszPhotometric = CPLGetConfigOption( "PHOTOMETRIC_OVERVIEW", NULL );
if (pszPhotometric != NULL && pszPhotometric[0] != '\0')
{
if( EQUAL( pszPhotometric, "MINISBLACK" ) )
nPhotometric = PHOTOMETRIC_MINISBLACK;
else if( EQUAL( pszPhotometric, "MINISWHITE" ) )
nPhotometric = PHOTOMETRIC_MINISWHITE;
else if( EQUAL( pszPhotometric, "RGB" ))
{
nPhotometric = PHOTOMETRIC_RGB;
}
else if( EQUAL( pszPhotometric, "CMYK" ))
{
nPhotometric = PHOTOMETRIC_SEPARATED;
}
else if( EQUAL( pszPhotometric, "YCBCR" ))
{
nPhotometric = PHOTOMETRIC_YCBCR;
/* Because of subsampling, setting YCBCR without JPEG compression leads */
/* to a crash currently. Would need to make GTiffRasterBand::IWriteBlock() */
/* aware of subsampling so that it doesn't overrun buffer size returned */
/* by libtiff */
if ( nCompression != COMPRESSION_JPEG )
{
CPLError(CE_Failure, CPLE_NotSupported,
"Currently, PHOTOMETRIC_OVERVIEW=YCBCR requires COMPRESS_OVERVIEW=JPEG");
return CE_Failure;
}
if (pszInterleave != NULL && pszInterleave[0] != '\0' && nPlanarConfig == PLANARCONFIG_SEPARATE)
{
CPLError(CE_Failure, CPLE_NotSupported,
"PHOTOMETRIC_OVERVIEW=YCBCR requires INTERLEAVE_OVERVIEW=PIXEL");
return CE_Failure;
}
else
{
nPlanarConfig = PLANARCONFIG_CONTIG;
}
/* YCBCR strictly requires 3 bands. Not less, not more */
/* Issue an explicit error message as libtiff one is a bit cryptic : */
/* JPEGLib:Bogus input colorspace */
if ( nBands != 3 )
{
CPLError(CE_Failure, CPLE_NotSupported,
"PHOTOMETRIC_OVERVIEW=YCBCR requires a source raster with only 3 bands (RGB)");
return CE_Failure;
}
}
else if( EQUAL( pszPhotometric, "CIELAB" ))
{
nPhotometric = PHOTOMETRIC_CIELAB;
}
else if( EQUAL( pszPhotometric, "ICCLAB" ))
{
nPhotometric = PHOTOMETRIC_ICCLAB;
}
else if( EQUAL( pszPhotometric, "ITULAB" ))
{
nPhotometric = PHOTOMETRIC_ITULAB;
}
else
{
CPLError( CE_Warning, CPLE_IllegalArg,
"PHOTOMETRIC_OVERVIEW=%s value not recognised, ignoring.\n",
pszPhotometric );
}
}
/* -------------------------------------------------------------------- */
/* Figure out the predictor value to use. */
/* -------------------------------------------------------------------- */
int nPredictor = PREDICTOR_NONE;
if ( nCompression == COMPRESSION_LZW ||
nCompression == COMPRESSION_ADOBE_DEFLATE )
{
const char* pszPredictor = CPLGetConfigOption( "PREDICTOR_OVERVIEW", NULL );
if( pszPredictor != NULL )
{
nPredictor = atoi( pszPredictor );
}
}
/* -------------------------------------------------------------------- */
/* Create the file, if it does not already exist. */
/* -------------------------------------------------------------------- */
VSIStatBufL sStatBuf;
VSILFILE* fpL = NULL;
if( VSIStatExL( pszFilename, &sStatBuf, VSI_STAT_EXISTS_FLAG ) != 0 )
{
/* -------------------------------------------------------------------- */
/* Compute the uncompressed size. */
/* -------------------------------------------------------------------- */
double dfUncompressedOverviewSize = 0;
int nDataTypeSize = GDALGetDataTypeSize(papoBandList[0]->GetRasterDataType())/8;
for( iOverview = 0; iOverview < nOverviews; iOverview++ )
{
int nOXSize, nOYSize;
nOXSize = (nXSize + panOverviewList[iOverview] - 1)
/ panOverviewList[iOverview];
nOYSize = (nYSize + panOverviewList[iOverview] - 1)
/ panOverviewList[iOverview];
dfUncompressedOverviewSize +=
nOXSize * ((double)nOYSize) * nBands * nDataTypeSize;
}
if( nCompression == COMPRESSION_NONE
&& dfUncompressedOverviewSize > 4200000000.0 )
{
#ifndef BIGTIFF_SUPPORT
CPLError( CE_Failure, CPLE_NotSupported,
"The overview file would be larger than 4GB\n"
"but this is the largest size a TIFF can be, and BigTIFF is unavailable.\n"
"Creation failed." );
return CE_Failure;
#endif
}
/* -------------------------------------------------------------------- */
/* Should the file be created as a bigtiff file? */
/* -------------------------------------------------------------------- */
const char *pszBIGTIFF = CPLGetConfigOption( "BIGTIFF_OVERVIEW", NULL );
if( pszBIGTIFF == NULL )
pszBIGTIFF = "IF_NEEDED";
int bCreateBigTIFF = FALSE;
if( EQUAL(pszBIGTIFF,"IF_NEEDED") )
{
if( nCompression == COMPRESSION_NONE
&& dfUncompressedOverviewSize > 4200000000.0 )
bCreateBigTIFF = TRUE;
}
else if( EQUAL(pszBIGTIFF,"IF_SAFER") )
{
/* Look at the size of the base image and suppose that */
/* the added overview levels won't be more than 1/2 of */
/* the size of the base image. The theory says 1/3 of the */
/* base image size if the overview levels are 2, 4, 8, 16... */
/* Thus take 1/2 as the security margin for 1/3 */
double dfUncompressedImageSize =
nXSize * ((double)nYSize) * nBands * nDataTypeSize;
if( dfUncompressedImageSize * .5 > 4200000000.0 )
bCreateBigTIFF = TRUE;
}
else
{
bCreateBigTIFF = CSLTestBoolean( pszBIGTIFF );
if (!bCreateBigTIFF && nCompression == COMPRESSION_NONE
&& dfUncompressedOverviewSize > 4200000000.0 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The overview file will be larger than 4GB, so BigTIFF is necessary.\n"
"Creation failed.");
return CE_Failure;
}
}
#ifndef BIGTIFF_SUPPORT
if( bCreateBigTIFF )
{
CPLError( CE_Warning, CPLE_NotSupported,
"BigTIFF requested, but GDAL built without BigTIFF\n"
"enabled libtiff, request ignored." );
bCreateBigTIFF = FALSE;
}
#endif
if( bCreateBigTIFF )
CPLDebug( "GTiff", "File being created as a BigTIFF." );
fpL = VSIFOpenL( pszFilename, "w+" );
if( fpL == NULL )
hOTIFF = NULL;
else
hOTIFF = VSI_TIFFOpen( pszFilename, (bCreateBigTIFF) ? "w+8" : "w+", fpL );
if( hOTIFF == NULL )
{
if( CPLGetLastErrorNo() == 0 )
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create new tiff file `%s'\n"
"failed in VSI_TIFFOpen().\n",
pszFilename );
if( fpL != NULL )
VSIFCloseL(fpL);
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Otherwise just open it for update access. */
/* -------------------------------------------------------------------- */
else
{
fpL = VSIFOpenL( pszFilename, "r+" );
if( fpL == NULL )
hOTIFF = NULL;
else
hOTIFF = VSI_TIFFOpen( pszFilename, "r+", fpL );
if( hOTIFF == NULL )
{
if( CPLGetLastErrorNo() == 0 )
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create new tiff file `%s'\n"
"failed in VSI_TIFFOpen().\n",
pszFilename );
if( fpL != NULL )
VSIFCloseL(fpL);
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Do we have a palette? If so, create a TIFF compatible version. */
/* -------------------------------------------------------------------- */
unsigned short *panRed=NULL, *panGreen=NULL, *panBlue=NULL;
if( nPhotometric == PHOTOMETRIC_PALETTE )
{
GDALColorTable *poCT = papoBandList[0]->GetColorTable();
int nColorCount;
if( nBitsPerPixel <= 8 )
nColorCount = 256;
else
nColorCount = 65536;
panRed = (unsigned short *)
CPLCalloc(nColorCount,sizeof(unsigned short));
panGreen = (unsigned short *)
CPLCalloc(nColorCount,sizeof(unsigned short));
panBlue = (unsigned short *)
CPLCalloc(nColorCount,sizeof(unsigned short));
for( int iColor = 0; iColor < nColorCount; iColor++ )
{
GDALColorEntry sRGB;
if( poCT->GetColorEntryAsRGB( iColor, &sRGB ) )
{
panRed[iColor] = (unsigned short) (257 * sRGB.c1);
panGreen[iColor] = (unsigned short) (257 * sRGB.c2);
panBlue[iColor] = (unsigned short) (257 * sRGB.c3);
}
}
}
/* -------------------------------------------------------------------- */
/* Do we need some metadata for the overviews? */
/* -------------------------------------------------------------------- */
CPLString osMetadata;
GDALDataset *poBaseDS = papoBandList[0]->GetDataset();
GTIFFBuildOverviewMetadata( pszResampling, poBaseDS, osMetadata );
/* -------------------------------------------------------------------- */
/* Loop, creating overviews. */
/* -------------------------------------------------------------------- */
int nOvrBlockXSize, nOvrBlockYSize;
GTIFFGetOverviewBlockSize(&nOvrBlockXSize, &nOvrBlockYSize);
for( iOverview = 0; iOverview < nOverviews; iOverview++ )
{
int nOXSize, nOYSize;
nOXSize = (nXSize + panOverviewList[iOverview] - 1)
/ panOverviewList[iOverview];
nOYSize = (nYSize + panOverviewList[iOverview] - 1)
/ panOverviewList[iOverview];
GTIFFWriteDirectory(hOTIFF, FILETYPE_REDUCEDIMAGE,
nOXSize, nOYSize, nBitsPerPixel,
nPlanarConfig, nBands,
nOvrBlockXSize, nOvrBlockYSize, TRUE, nCompression,
nPhotometric, nSampleFormat, nPredictor,
panRed, panGreen, panBlue,
0, NULL, /* FIXME? how can we fetch extrasamples */
osMetadata );
}
if (panRed)
{
CPLFree(panRed);
CPLFree(panGreen);
CPLFree(panBlue);
panRed = panGreen = panBlue = NULL;
}
XTIFFClose( hOTIFF );
VSIFCloseL(fpL);
fpL = NULL;
/* -------------------------------------------------------------------- */
/* Open the overview dataset so that we can get at the overview */
/* bands. */
/* -------------------------------------------------------------------- */
GDALDataset *hODS;
CPLErr eErr = CE_None;
hODS = (GDALDataset *) GDALOpen( pszFilename, GA_Update );
if( hODS == NULL )
return CE_Failure;
/* -------------------------------------------------------------------- */
/* Do we need to set the jpeg quality? */
/* -------------------------------------------------------------------- */
TIFF *hTIFF = (TIFF*) hODS->GetInternalHandle(NULL);
if( nCompression == COMPRESSION_JPEG
&& CPLGetConfigOption( "JPEG_QUALITY_OVERVIEW", NULL ) != NULL )
{
int nJpegQuality = atoi(CPLGetConfigOption("JPEG_QUALITY_OVERVIEW","75"));
TIFFSetField( hTIFF, TIFFTAG_JPEGQUALITY,
nJpegQuality );
GTIFFSetJpegQuality((GDALDatasetH)hODS, nJpegQuality);
}
/* -------------------------------------------------------------------- */
/* Loop writing overview data. */
/* -------------------------------------------------------------------- */
if (nCompression != COMPRESSION_NONE &&
nPlanarConfig == PLANARCONFIG_CONTIG &&
GDALDataTypeIsComplex(papoBandList[0]->GetRasterDataType()) == FALSE &&
papoBandList[0]->GetColorTable() == NULL &&
(EQUALN(pszResampling, "NEAR", 4) || EQUAL(pszResampling, "AVERAGE") ||
EQUAL(pszResampling, "GAUSS") || EQUAL(pszResampling, "CUBIC") ||
EQUAL(pszResampling, "CUBICSPLINE") || EQUAL(pszResampling, "LANCZOS") ||
EQUAL(pszResampling, "BILINEAR")))
{
/* In the case of pixel interleaved compressed overviews, we want to generate */
/* the overviews for all the bands block by block, and not band after band, */
/* in order to write the block once and not loose space in the TIFF file */
GDALRasterBand ***papapoOverviewBands;
papapoOverviewBands = (GDALRasterBand ***) CPLCalloc(sizeof(void*),nBands);
for( iBand = 0; iBand < nBands && eErr == CE_None; iBand++ )
{
GDALRasterBand *hSrcBand = papoBandList[iBand];
GDALRasterBand *hDstBand = hODS->GetRasterBand( iBand+1 );
papapoOverviewBands[iBand] = (GDALRasterBand **) CPLCalloc(sizeof(void*),nOverviews);
papapoOverviewBands[iBand][0] = hDstBand;
int bHasNoData;
double noDataValue = hSrcBand->GetNoDataValue(&bHasNoData);
if (bHasNoData)
hDstBand->SetNoDataValue(noDataValue);
for( int i = 0; i < nOverviews-1 && eErr == CE_None; i++ )
{
papapoOverviewBands[iBand][i+1] = hDstBand->GetOverview(i);
if (papapoOverviewBands[iBand][i+1] == NULL)
eErr = CE_Failure;
else
{
if (bHasNoData)
papapoOverviewBands[iBand][i+1]->SetNoDataValue(noDataValue);
}
}
}
if (eErr == CE_None)
eErr = GDALRegenerateOverviewsMultiBand(nBands, papoBandList,
nOverviews, papapoOverviewBands,
pszResampling, pfnProgress, pProgressData );
for( iBand = 0; iBand < nBands; iBand++ )
{
CPLFree(papapoOverviewBands[iBand]);
}
CPLFree(papapoOverviewBands);
}
else
{
GDALRasterBand **papoOverviews;
papoOverviews = (GDALRasterBand **) CPLCalloc(sizeof(void*),128);
for( iBand = 0; iBand < nBands && eErr == CE_None; iBand++ )
{
GDALRasterBand *hSrcBand = papoBandList[iBand];
GDALRasterBand *hDstBand;
int nDstOverviews;
hDstBand = hODS->GetRasterBand( iBand+1 );
int bHasNoData;
double noDataValue = hSrcBand->GetNoDataValue(&bHasNoData);
if (bHasNoData)
hDstBand->SetNoDataValue(noDataValue);
papoOverviews[0] = hDstBand;
nDstOverviews = hDstBand->GetOverviewCount() + 1;
CPLAssert( nDstOverviews < 128 );
nDstOverviews = MIN(128,nDstOverviews);
for( int i = 0; i < nDstOverviews-1 && eErr == CE_None; i++ )
{
papoOverviews[i+1] = hDstBand->GetOverview(i);
if (papoOverviews[i+1] == NULL)
eErr = CE_Failure;
else
{
if (bHasNoData)
papoOverviews[i+1]->SetNoDataValue(noDataValue);
}
}
void *pScaledProgressData;
pScaledProgressData =
GDALCreateScaledProgress( iBand / (double) nBands,
(iBand+1) / (double) nBands,
pfnProgress, pProgressData );
if (eErr == CE_None)
eErr =
GDALRegenerateOverviews( (GDALRasterBandH) hSrcBand,
nDstOverviews,
(GDALRasterBandH *) papoOverviews,
pszResampling,
GDALScaledProgress,
pScaledProgressData);
GDALDestroyScaledProgress( pScaledProgressData );
}
CPLFree( papoOverviews );
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
if (eErr == CE_None)
hODS->FlushCache();
delete hODS;
pfnProgress( 1.0, NULL, pProgressData );
return eErr;
}
CPLErr
GTIFFBuildOverviews( const char * pszFilename,
int nBands, GDALRasterBand **papoBandList,
int nOverviews, int * panOverviewList,
const char * pszResampling,
GDALProgressFunc pfnProgress, void * pProgressData )
{
if( nBands == 0 || nOverviews == 0 )
return CE_None;
if( !GTiffOneTimeInit() )
return CE_Failure;
TIFF *hOTIFF = nullptr;
int nBitsPerPixel = 0;
int nCompression = COMPRESSION_NONE;
int nPhotometric = 0;
int nSampleFormat = 0;
int nPlanarConfig = 0;
int iOverview = 0;
int nXSize = 0;
int nYSize = 0;
/* -------------------------------------------------------------------- */
/* Verify that the list of bands is suitable for emitting in */
/* TIFF file. */
/* -------------------------------------------------------------------- */
for( int iBand = 0; iBand < nBands; iBand++ )
{
int nBandBits = 0;
int nBandFormat = 0;
GDALRasterBand *hBand = papoBandList[iBand];
switch( hBand->GetRasterDataType() )
{
case GDT_Byte:
nBandBits = 8;
nBandFormat = SAMPLEFORMAT_UINT;
break;
case GDT_UInt16:
nBandBits = 16;
nBandFormat = SAMPLEFORMAT_UINT;
break;
case GDT_Int16:
nBandBits = 16;
nBandFormat = SAMPLEFORMAT_INT;
break;
case GDT_UInt32:
nBandBits = 32;
nBandFormat = SAMPLEFORMAT_UINT;
break;
case GDT_Int32:
nBandBits = 32;
nBandFormat = SAMPLEFORMAT_INT;
break;
case GDT_Float32:
nBandBits = 32;
nBandFormat = SAMPLEFORMAT_IEEEFP;
break;
case GDT_Float64:
nBandBits = 64;
nBandFormat = SAMPLEFORMAT_IEEEFP;
break;
case GDT_CInt16:
nBandBits = 32;
nBandFormat = SAMPLEFORMAT_COMPLEXINT;
break;
case GDT_CInt32:
nBandBits = 64;
nBandFormat = SAMPLEFORMAT_COMPLEXINT;
break;
case GDT_CFloat32:
nBandBits = 64;
nBandFormat = SAMPLEFORMAT_COMPLEXIEEEFP;
break;
case GDT_CFloat64:
nBandBits = 128;
nBandFormat = SAMPLEFORMAT_COMPLEXIEEEFP;
break;
default:
CPLAssert( false );
return CE_Failure;
}
if( hBand->GetMetadataItem( "NBITS", "IMAGE_STRUCTURE" ) )
{
nBandBits =
atoi(hBand->GetMetadataItem("NBITS", "IMAGE_STRUCTURE"));
if( nBandBits == 1
&& STARTS_WITH_CI(pszResampling, "AVERAGE_BIT2") )
nBandBits = 8;
}
if( iBand == 0 )
{
nBitsPerPixel = nBandBits;
nSampleFormat = nBandFormat;
nXSize = hBand->GetXSize();
nYSize = hBand->GetYSize();
}
else if( nBitsPerPixel != nBandBits || nSampleFormat != nBandFormat )
{
CPLError( CE_Failure, CPLE_NotSupported,
"GTIFFBuildOverviews() doesn't support a mixture of band"
" data types." );
return CE_Failure;
}
else if( hBand->GetColorTable() != nullptr )
{
CPLError( CE_Failure, CPLE_NotSupported,
"GTIFFBuildOverviews() doesn't support building"
" overviews of multiple colormapped bands." );
return CE_Failure;
}
else if( hBand->GetXSize() != nXSize
|| hBand->GetYSize() != nYSize )
{
CPLError( CE_Failure, CPLE_NotSupported,
"GTIFFBuildOverviews() doesn't support building"
" overviews of different sized bands." );
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Use specified compression method. */
/* -------------------------------------------------------------------- */
const char *pszCompress = CPLGetConfigOption( "COMPRESS_OVERVIEW", nullptr );
if( pszCompress != nullptr && pszCompress[0] != '\0' )
{
nCompression =
GTIFFGetCompressionMethod(pszCompress, "COMPRESS_OVERVIEW");
if( nCompression < 0 )
return CE_Failure;
}
if( nCompression == COMPRESSION_JPEG && nBitsPerPixel > 8 )
{
if( nBitsPerPixel > 16 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"GTIFFBuildOverviews() doesn't support building"
" JPEG compressed overviews of nBitsPerPixel > 16." );
return CE_Failure;
}
nBitsPerPixel = 12;
}
/* -------------------------------------------------------------------- */
/* Figure out the planar configuration to use. */
/* -------------------------------------------------------------------- */
if( nBands == 1 )
nPlanarConfig = PLANARCONFIG_CONTIG;
else
nPlanarConfig = PLANARCONFIG_SEPARATE;
bool bSourceIsPixelInterleaved = false;
bool bSourceIsJPEG2000 = false;
if( nBands > 1 )
{
GDALDataset* poSrcDS = papoBandList[0]->GetDataset();
if( poSrcDS )
{
const char* pszSrcInterleave = poSrcDS->GetMetadataItem("INTERLEAVE",
"IMAGE_STRUCTURE");
if( pszSrcInterleave && EQUAL(pszSrcInterleave, "PIXEL") )
{
bSourceIsPixelInterleaved = true;
}
}
const char* pszSrcCompression = papoBandList[0]->GetMetadataItem("COMPRESSION",
"IMAGE_STRUCTURE");
if( pszSrcCompression )
{
bSourceIsJPEG2000 = EQUAL(pszSrcCompression, "JPEG2000");
}
if( bSourceIsPixelInterleaved && bSourceIsJPEG2000 )
{
nPlanarConfig = PLANARCONFIG_CONTIG;
}
}
const char* pszInterleave =
CPLGetConfigOption( "INTERLEAVE_OVERVIEW", nullptr );
if( pszInterleave != nullptr && pszInterleave[0] != '\0' )
{
if( EQUAL( pszInterleave, "PIXEL" ) )
nPlanarConfig = PLANARCONFIG_CONTIG;
else if( EQUAL( pszInterleave, "BAND" ) )
nPlanarConfig = PLANARCONFIG_SEPARATE;
else
{
CPLError(
CE_Failure, CPLE_AppDefined,
"INTERLEAVE_OVERVIEW=%s unsupported, "
"value must be PIXEL or BAND. ignoring",
pszInterleave );
}
}
/* -------------------------------------------------------------------- */
/* Figure out the photometric interpretation to use. */
/* -------------------------------------------------------------------- */
if( nBands == 3 )
nPhotometric = PHOTOMETRIC_RGB;
else if( papoBandList[0]->GetColorTable() != nullptr
&& !STARTS_WITH_CI(pszResampling, "AVERAGE_BIT2") )
{
nPhotometric = PHOTOMETRIC_PALETTE;
// Should set the colormap up at this point too!
}
else if( nBands >= 3 &&
papoBandList[0]->GetColorInterpretation() == GCI_RedBand &&
papoBandList[1]->GetColorInterpretation() == GCI_GreenBand &&
papoBandList[2]->GetColorInterpretation() == GCI_BlueBand )
{
nPhotometric = PHOTOMETRIC_RGB;
}
else
nPhotometric = PHOTOMETRIC_MINISBLACK;
const char* pszPhotometric =
CPLGetConfigOption( "PHOTOMETRIC_OVERVIEW", nullptr );
if( pszPhotometric != nullptr && pszPhotometric[0] != '\0' )
{
if( EQUAL( pszPhotometric, "MINISBLACK" ) )
nPhotometric = PHOTOMETRIC_MINISBLACK;
else if( EQUAL( pszPhotometric, "MINISWHITE" ) )
nPhotometric = PHOTOMETRIC_MINISWHITE;
else if( EQUAL( pszPhotometric, "RGB" ))
{
nPhotometric = PHOTOMETRIC_RGB;
}
else if( EQUAL( pszPhotometric, "CMYK" ))
{
nPhotometric = PHOTOMETRIC_SEPARATED;
}
else if( EQUAL( pszPhotometric, "YCBCR" ))
{
nPhotometric = PHOTOMETRIC_YCBCR;
// Because of subsampling, setting YCBCR without JPEG compression
// leads to a crash currently. Would need to make
// GTiffRasterBand::IWriteBlock() aware of subsampling so that it
// doesn't overrun buffer size returned by libtiff.
if( nCompression != COMPRESSION_JPEG )
{
CPLError(
CE_Failure, CPLE_NotSupported,
"Currently, PHOTOMETRIC_OVERVIEW=YCBCR requires "
"COMPRESS_OVERVIEW=JPEG" );
return CE_Failure;
}
if( pszInterleave != nullptr &&
pszInterleave[0] != '\0' &&
nPlanarConfig == PLANARCONFIG_SEPARATE )
{
CPLError(
CE_Failure, CPLE_NotSupported,
"PHOTOMETRIC_OVERVIEW=YCBCR requires "
"INTERLEAVE_OVERVIEW=PIXEL" );
return CE_Failure;
}
else
{
nPlanarConfig = PLANARCONFIG_CONTIG;
}
// YCBCR strictly requires 3 bands. Not less, not more
// Issue an explicit error message as libtiff one is a bit cryptic:
// JPEGLib:Bogus input colorspace.
if( nBands != 3 )
{
CPLError(
CE_Failure, CPLE_NotSupported,
"PHOTOMETRIC_OVERVIEW=YCBCR requires a source raster "
"with only 3 bands (RGB)" );
return CE_Failure;
}
}
else if( EQUAL( pszPhotometric, "CIELAB" ))
{
nPhotometric = PHOTOMETRIC_CIELAB;
}
else if( EQUAL( pszPhotometric, "ICCLAB" ))
{
nPhotometric = PHOTOMETRIC_ICCLAB;
}
else if( EQUAL( pszPhotometric, "ITULAB" ))
{
nPhotometric = PHOTOMETRIC_ITULAB;
}
else
{
CPLError(
CE_Warning, CPLE_IllegalArg,
"PHOTOMETRIC_OVERVIEW=%s value not recognised, ignoring.",
pszPhotometric );
}
}
/* -------------------------------------------------------------------- */
/* Figure out the predictor value to use. */
/* -------------------------------------------------------------------- */
int nPredictor = PREDICTOR_NONE;
if( nCompression == COMPRESSION_LZW ||
nCompression == COMPRESSION_ADOBE_DEFLATE )
{
const char* pszPredictor =
CPLGetConfigOption( "PREDICTOR_OVERVIEW", nullptr );
if( pszPredictor != nullptr )
{
nPredictor = atoi( pszPredictor );
}
}
/* -------------------------------------------------------------------- */
/* Create the file, if it does not already exist. */
/* -------------------------------------------------------------------- */
VSIStatBufL sStatBuf;
VSILFILE* fpL = nullptr;
if( VSIStatExL( pszFilename, &sStatBuf, VSI_STAT_EXISTS_FLAG ) != 0 )
{
/* -------------------------------------------------------------------- */
/* Compute the uncompressed size. */
/* -------------------------------------------------------------------- */
double dfUncompressedOverviewSize = 0;
int nDataTypeSize =
GDALGetDataTypeSizeBytes(papoBandList[0]->GetRasterDataType());
for( iOverview = 0; iOverview < nOverviews; iOverview++ )
{
const int nOXSize = (nXSize + panOverviewList[iOverview] - 1)
/ panOverviewList[iOverview];
const int nOYSize = (nYSize + panOverviewList[iOverview] - 1)
/ panOverviewList[iOverview];
dfUncompressedOverviewSize +=
nOXSize * static_cast<double>(nOYSize) * nBands * nDataTypeSize;
}
if( nCompression == COMPRESSION_NONE
&& dfUncompressedOverviewSize > 4200000000.0 )
{
#ifndef BIGTIFF_SUPPORT
CPLError(
CE_Failure, CPLE_NotSupported,
"The overview file would be larger than 4GB, "
"but this is the largest size a TIFF can be, "
"and BigTIFF is unavailable. "
"Creation failed." );
return CE_Failure;
#endif
}
/* -------------------------------------------------------------------- */
/* Should the file be created as a bigtiff file? */
/* -------------------------------------------------------------------- */
const char *pszBIGTIFF = CPLGetConfigOption( "BIGTIFF_OVERVIEW", nullptr );
if( pszBIGTIFF == nullptr )
pszBIGTIFF = "IF_SAFER";
bool bCreateBigTIFF = false;
if( EQUAL(pszBIGTIFF,"IF_NEEDED") )
{
if( nCompression == COMPRESSION_NONE
&& dfUncompressedOverviewSize > 4200000000.0 )
bCreateBigTIFF = true;
}
else if( EQUAL(pszBIGTIFF,"IF_SAFER") )
{
// Look at the size of the base image and suppose that
// the added overview levels won't be more than 1/2 of
// the size of the base image. The theory says 1/3 of the
// base image size if the overview levels are 2, 4, 8, 16.
// Thus take 1/2 as the security margin for 1/3.
const double dfUncompressedImageSize =
nXSize * static_cast<double>(nYSize) * nBands * nDataTypeSize;
if( dfUncompressedImageSize * 0.5 > 4200000000.0 )
bCreateBigTIFF = true;
}
else
{
bCreateBigTIFF = CPLTestBool( pszBIGTIFF );
if( !bCreateBigTIFF && nCompression == COMPRESSION_NONE
&& dfUncompressedOverviewSize > 4200000000.0 )
{
CPLError(
CE_Failure, CPLE_NotSupported,
"The overview file will be larger than 4GB, "
"so BigTIFF is necessary. "
"Creation failed.");
return CE_Failure;
}
}
#ifndef BIGTIFF_SUPPORT
if( bCreateBigTIFF )
{
CPLError(
CE_Warning, CPLE_NotSupported,
"BigTIFF requested, but GDAL built without BigTIFF "
"enabled libtiff, request ignored." );
bCreateBigTIFF = false;
}
#endif
if( bCreateBigTIFF )
CPLDebug( "GTiff", "File being created as a BigTIFF." );
fpL = VSIFOpenL( pszFilename, "w+" );
if( fpL == nullptr )
hOTIFF = nullptr;
else
hOTIFF =
VSI_TIFFOpen( pszFilename, bCreateBigTIFF ? "w+8" : "w+", fpL );
if( hOTIFF == nullptr )
{
if( CPLGetLastErrorNo() == 0 )
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create new tiff file `%s' "
"failed in VSI_TIFFOpen().",
pszFilename );
if( fpL != nullptr )
CPL_IGNORE_RET_VAL(VSIFCloseL(fpL));
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Otherwise just open it for update access. */
/* -------------------------------------------------------------------- */
else
{
fpL = VSIFOpenL( pszFilename, "r+" );
if( fpL == nullptr )
hOTIFF = nullptr;
else
hOTIFF = VSI_TIFFOpen( pszFilename, "r+", fpL );
if( hOTIFF == nullptr )
{
if( CPLGetLastErrorNo() == 0 )
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create new tiff file `%s' "
"failed in VSI_TIFFOpen().",
pszFilename );
if( fpL != nullptr )
CPL_IGNORE_RET_VAL(VSIFCloseL(fpL));
return CE_Failure;
}
}
/* -------------------------------------------------------------------- */
/* Do we have a palette? If so, create a TIFF compatible version. */
/* -------------------------------------------------------------------- */
unsigned short *panRed = nullptr;
unsigned short *panGreen = nullptr;
unsigned short *panBlue = nullptr;
if( nPhotometric == PHOTOMETRIC_PALETTE )
{
GDALColorTable *poCT = papoBandList[0]->GetColorTable();
int nColorCount = 65536;
if( nBitsPerPixel <= 8 )
nColorCount = 256;
panRed = static_cast<unsigned short *>(
CPLCalloc(nColorCount, sizeof(unsigned short)) );
panGreen = static_cast<unsigned short *>(
CPLCalloc(nColorCount, sizeof(unsigned short)) );
panBlue = static_cast<unsigned short *>(
CPLCalloc(nColorCount, sizeof(unsigned short)) );
for( int iColor = 0; iColor < nColorCount; iColor++ )
{
GDALColorEntry sRGB = { 0, 0, 0, 0 };
if( poCT->GetColorEntryAsRGB( iColor, &sRGB ) )
{
// TODO(schwehr): Check for underflow.
// Going from signed short to unsigned short.
panRed[iColor] = static_cast<unsigned short>(257 * sRGB.c1);
panGreen[iColor] = static_cast<unsigned short>(257 * sRGB.c2);
panBlue[iColor] = static_cast<unsigned short>(257 * sRGB.c3);
}
}
}
/* -------------------------------------------------------------------- */
/* Do we need some metadata for the overviews? */
/* -------------------------------------------------------------------- */
CPLString osMetadata;
GDALDataset *poBaseDS = papoBandList[0]->GetDataset();
GTIFFBuildOverviewMetadata( pszResampling, poBaseDS, osMetadata );
/* -------------------------------------------------------------------- */
/* Loop, creating overviews. */
/* -------------------------------------------------------------------- */
int nOvrBlockXSize = 0;
int nOvrBlockYSize = 0;
GTIFFGetOverviewBlockSize(&nOvrBlockXSize, &nOvrBlockYSize);
CPLString osNoData; // don't move this in inner scope
const char* pszNoData = nullptr;
int bNoDataSet = FALSE;
const double dfNoDataValue = papoBandList[0]->GetNoDataValue(&bNoDataSet);
if( bNoDataSet )
{
osNoData = GTiffFormatGDALNoDataTagValue(dfNoDataValue);
pszNoData = osNoData.c_str();
}
std::vector<uint16> anExtraSamples;
for( int i = GTIFFGetMaxColorChannels(nPhotometric)+1; i <= nBands; i++ )
{
if( papoBandList[i-1]->GetColorInterpretation() == GCI_AlphaBand )
{
anExtraSamples.push_back(
GTiffGetAlphaValue(CPLGetConfigOption("GTIFF_ALPHA", nullptr),
DEFAULT_ALPHA_TYPE));
}
else
{
anExtraSamples.push_back(EXTRASAMPLE_UNSPECIFIED);
}
}
for( iOverview = 0; iOverview < nOverviews; iOverview++ )
{
const int nOXSize = (nXSize + panOverviewList[iOverview] - 1)
/ panOverviewList[iOverview];
const int nOYSize = (nYSize + panOverviewList[iOverview] - 1)
/ panOverviewList[iOverview];
GTIFFWriteDirectory( hOTIFF, FILETYPE_REDUCEDIMAGE,
nOXSize, nOYSize, nBitsPerPixel,
nPlanarConfig, nBands,
nOvrBlockXSize, nOvrBlockYSize, TRUE, nCompression,
nPhotometric, nSampleFormat, nPredictor,
panRed, panGreen, panBlue,
static_cast<int>(anExtraSamples.size()),
anExtraSamples.empty() ? nullptr : anExtraSamples.data(),
osMetadata,
CPLGetConfigOption( "JPEG_QUALITY_OVERVIEW", nullptr ),
CPLGetConfigOption( "JPEG_TABLESMODE_OVERVIEW", nullptr ),
pszNoData,
nullptr
);
}
if( panRed )
{
CPLFree(panRed);
CPLFree(panGreen);
CPLFree(panBlue);
panRed = nullptr;
panGreen = nullptr;
panBlue = nullptr;
}
XTIFFClose( hOTIFF );
if( VSIFCloseL(fpL) != 0 )
return CE_Failure;
fpL = nullptr;
/* -------------------------------------------------------------------- */
/* Open the overview dataset so that we can get at the overview */
/* bands. */
/* -------------------------------------------------------------------- */
GDALDataset *hODS = GDALDataset::Open( pszFilename,
GDAL_OF_RASTER | GDAL_OF_UPDATE );
if( hODS == nullptr )
return CE_Failure;
/* -------------------------------------------------------------------- */
/* Do we need to set the jpeg quality? */
/* -------------------------------------------------------------------- */
TIFF *hTIFF = static_cast<TIFF *>( hODS->GetInternalHandle(nullptr) );
if( nCompression == COMPRESSION_JPEG
&& CPLGetConfigOption( "JPEG_QUALITY_OVERVIEW", nullptr ) != nullptr )
{
const int nJpegQuality =
atoi(CPLGetConfigOption("JPEG_QUALITY_OVERVIEW","75"));
TIFFSetField( hTIFF, TIFFTAG_JPEGQUALITY,
nJpegQuality );
GTIFFSetJpegQuality(GDALDataset::ToHandle(hODS), nJpegQuality);
}
if( nCompression == COMPRESSION_JPEG
&& CPLGetConfigOption( "JPEG_TABLESMODE_OVERVIEW", nullptr ) != nullptr )
{
const int nJpegTablesMode =
atoi(CPLGetConfigOption("JPEG_TABLESMODE_OVERVIEW",
CPLSPrintf("%d", knGTIFFJpegTablesModeDefault)));
TIFFSetField( hTIFF, TIFFTAG_JPEGTABLESMODE,
nJpegTablesMode );
GTIFFSetJpegTablesMode(GDALDataset::ToHandle(hODS), nJpegTablesMode);
}
/* -------------------------------------------------------------------- */
/* Loop writing overview data. */
/* -------------------------------------------------------------------- */
int *panOverviewListSorted =
static_cast<int*>(CPLMalloc(sizeof(int) * nOverviews));
memcpy( panOverviewListSorted, panOverviewList, sizeof(int) * nOverviews);
std::sort(panOverviewListSorted, panOverviewListSorted + nOverviews);
GTIFFSetInExternalOvr(true);
CPLErr eErr = CE_None;
if( ((bSourceIsPixelInterleaved && bSourceIsJPEG2000) ||
(nCompression != COMPRESSION_NONE)) &&
nPlanarConfig == PLANARCONFIG_CONTIG &&
!GDALDataTypeIsComplex(papoBandList[0]->GetRasterDataType()) &&
papoBandList[0]->GetColorTable() == nullptr &&
(STARTS_WITH_CI(pszResampling, "NEAR") ||
EQUAL(pszResampling, "AVERAGE") ||
EQUAL(pszResampling, "GAUSS") ||
EQUAL(pszResampling, "CUBIC") ||
EQUAL(pszResampling, "CUBICSPLINE") ||
EQUAL(pszResampling, "LANCZOS") ||
EQUAL(pszResampling, "BILINEAR")) )
{
// In the case of pixel interleaved compressed overviews, we want to
// generate the overviews for all the bands block by block, and not
// band after band, in order to write the block once and not loose
// space in the TIFF file.
GDALRasterBand ***papapoOverviewBands =
static_cast<GDALRasterBand ***>(
CPLCalloc(sizeof(void *), nBands) );
for( int iBand = 0; iBand < nBands && eErr == CE_None; iBand++ )
{
GDALRasterBand *poSrcBand = papoBandList[iBand];
GDALRasterBand *poDstBand = hODS->GetRasterBand( iBand + 1 );
papapoOverviewBands[iBand] =
static_cast<GDALRasterBand **>(
CPLCalloc(sizeof(void *), nOverviews) );
int bHasNoData = FALSE;
const double noDataValue = poSrcBand->GetNoDataValue(&bHasNoData);
if( bHasNoData )
poDstBand->SetNoDataValue(noDataValue);
for( int i = 0; i < nOverviews && eErr == CE_None; i++ )
{
for( int j = -1; j < poDstBand->GetOverviewCount() &&
eErr == CE_None; j++ )
{
GDALRasterBand * poOverview =
(j < 0 ) ? poDstBand : poDstBand->GetOverview( j );
if( poOverview == nullptr )
{
eErr = CE_Failure;
continue;
}
const int nOvFactor =
GDALComputeOvFactor(poOverview->GetXSize(),
poSrcBand->GetXSize(),
poOverview->GetYSize(),
poSrcBand->GetYSize());
if( nOvFactor == panOverviewListSorted[i]
|| nOvFactor == GDALOvLevelAdjust2(
panOverviewListSorted[i],
poSrcBand->GetXSize(),
poSrcBand->GetYSize() ) )
{
papapoOverviewBands[iBand][i] = poOverview;
if( bHasNoData )
poOverview->SetNoDataValue(noDataValue);
break;
}
}
CPLAssert( papapoOverviewBands[iBand][i] != nullptr );
}
}
if( eErr == CE_None )
eErr =
GDALRegenerateOverviewsMultiBand(
nBands, papoBandList,
nOverviews, papapoOverviewBands,
pszResampling, pfnProgress, pProgressData );
for( int iBand = 0; iBand < nBands; iBand++ )
{
CPLFree(papapoOverviewBands[iBand]);
}
CPLFree(papapoOverviewBands);
}
else
{
GDALRasterBand **papoOverviews =
static_cast<GDALRasterBand **>(
CPLCalloc( sizeof(void*), knMaxOverviews ) );
for( int iBand = 0; iBand < nBands && eErr == CE_None; iBand++ )
{
GDALRasterBand *hSrcBand = papoBandList[iBand];
GDALRasterBand *hDstBand = hODS->GetRasterBand( iBand + 1 );
int bHasNoData = FALSE;
const double noDataValue = hSrcBand->GetNoDataValue(&bHasNoData);
if( bHasNoData )
hDstBand->SetNoDataValue(noDataValue);
// FIXME: this logic regenerates all overview bands, not only the
// ones requested.
papoOverviews[0] = hDstBand;
int nDstOverviews = hDstBand->GetOverviewCount() + 1;
CPLAssert( nDstOverviews < knMaxOverviews );
nDstOverviews = std::min(knMaxOverviews, nDstOverviews);
// TODO(schwehr): Convert to starting with i = 1 and remove +1.
for( int i = 0; i < nDstOverviews - 1 && eErr == CE_None; i++ )
{
papoOverviews[i+1] = hDstBand->GetOverview(i);
if( papoOverviews[i+1] == nullptr )
{
eErr = CE_Failure;
}
else
{
if( bHasNoData )
papoOverviews[i+1]->SetNoDataValue(noDataValue);
}
}
void *pScaledProgressData =
GDALCreateScaledProgress(
iBand / static_cast<double>( nBands ),
(iBand + 1) / static_cast<double>( nBands ),
pfnProgress, pProgressData );
if( eErr == CE_None )
eErr =
GDALRegenerateOverviews(
hSrcBand,
nDstOverviews,
reinterpret_cast<GDALRasterBandH *>( papoOverviews ),
pszResampling,
GDALScaledProgress,
pScaledProgressData );
GDALDestroyScaledProgress( pScaledProgressData );
}
CPLFree( papoOverviews );
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
if( eErr == CE_None )
hODS->FlushCache();
delete hODS;
GTIFFSetInExternalOvr(false);
CPLFree(panOverviewListSorted);
pfnProgress( 1.0, nullptr, pProgressData );
return eErr;
}
const char *GDALWMSRasterBand::GetMetadataItem( const char * pszName,
const char * pszDomain )
{
/* ==================================================================== */
/* LocationInfo handling. */
/* ==================================================================== */
if( pszDomain != NULL
&& EQUAL(pszDomain,"LocationInfo")
&& (STARTS_WITH_CI(pszName, "Pixel_") || STARTS_WITH_CI(pszName, "GeoPixel_")) )
{
int iPixel, iLine;
/* -------------------------------------------------------------------- */
/* What pixel are we aiming at? */
/* -------------------------------------------------------------------- */
if( STARTS_WITH_CI(pszName, "Pixel_") )
{
if( sscanf( pszName+6, "%d_%d", &iPixel, &iLine ) != 2 )
return NULL;
}
else if( STARTS_WITH_CI(pszName, "GeoPixel_") )
{
double adfGeoTransform[6];
double adfInvGeoTransform[6];
double dfGeoX, dfGeoY;
{
dfGeoX = CPLAtof(pszName + 9);
const char* pszUnderscore = strchr(pszName + 9, '_');
if( !pszUnderscore )
return NULL;
dfGeoY = CPLAtof(pszUnderscore+1);
}
if( m_parent_dataset->GetGeoTransform( adfGeoTransform ) != CE_None )
return NULL;
if( !GDALInvGeoTransform( adfGeoTransform, adfInvGeoTransform ) )
return NULL;
iPixel = (int) floor(
adfInvGeoTransform[0]
+ adfInvGeoTransform[1] * dfGeoX
+ adfInvGeoTransform[2] * dfGeoY );
iLine = (int) floor(
adfInvGeoTransform[3]
+ adfInvGeoTransform[4] * dfGeoX
+ adfInvGeoTransform[5] * dfGeoY );
/* The GetDataset() for the WMS driver is always the main overview level, so rescale */
/* the values if we are an overview */
if (m_overview >= 0)
{
iPixel = (int) (1.0 * iPixel * GetXSize() / m_parent_dataset->GetRasterBand(1)->GetXSize());
iLine = (int) (1.0 * iLine * GetYSize() / m_parent_dataset->GetRasterBand(1)->GetYSize());
}
}
else
return NULL;
if( iPixel < 0 || iLine < 0
|| iPixel >= GetXSize()
|| iLine >= GetYSize() )
return NULL;
if (nBand != 1)
{
GDALRasterBand* poFirstBand = m_parent_dataset->GetRasterBand(1);
if (m_overview >= 0)
poFirstBand = poFirstBand->GetOverview(m_overview);
if (poFirstBand)
return poFirstBand->GetMetadataItem(pszName, pszDomain);
}
GDALWMSImageRequestInfo iri;
GDALWMSTiledImageRequestInfo tiri;
int nBlockXOff = iPixel / nBlockXSize;
int nBlockYOff = iLine / nBlockYSize;
ComputeRequestInfo(iri, tiri, nBlockXOff, nBlockYOff);
CPLString url;
m_parent_dataset->m_mini_driver->GetTiledImageInfo(&url,
iri, tiri,
iPixel % nBlockXSize,
iLine % nBlockXSize);
char* pszRes = NULL;
if (url.size() != 0)
{
if (url == osMetadataItemURL)
{
return osMetadataItem.size() != 0 ? osMetadataItem.c_str() : NULL;
}
osMetadataItemURL = url;
char **http_request_opts = BuildHTTPRequestOpts();
CPLHTTPResult* psResult = CPLHTTPFetch( url.c_str(), http_request_opts);
if( psResult && psResult->pabyData )
pszRes = CPLStrdup((const char*) psResult->pabyData);
CPLHTTPDestroyResult(psResult);
CSLDestroy(http_request_opts);
}
if (pszRes)
{
osMetadataItem = "<LocationInfo>";
CPLPushErrorHandler(CPLQuietErrorHandler);
CPLXMLNode* psXML = CPLParseXMLString(pszRes);
CPLPopErrorHandler();
if (psXML != NULL && psXML->eType == CXT_Element)
{
if (strcmp(psXML->pszValue, "?xml") == 0)
{
if (psXML->psNext)
{
char* pszXML = CPLSerializeXMLTree(psXML->psNext);
osMetadataItem += pszXML;
CPLFree(pszXML);
}
}
else
{
osMetadataItem += pszRes;
}
}
else
{
char* pszEscapedXML = CPLEscapeString(pszRes, -1, CPLES_XML_BUT_QUOTES);
osMetadataItem += pszEscapedXML;
CPLFree(pszEscapedXML);
}
if (psXML != NULL)
CPLDestroyXMLNode(psXML);
osMetadataItem += "</LocationInfo>";
CPLFree(pszRes);
return osMetadataItem.c_str();
}
else
{
osMetadataItem = "";
return NULL;
}
}
return GDALPamRasterBand::GetMetadataItem(pszName, pszDomain);
}
GDALDataset* SIGDEMDataset::CreateCopy(
const char * pszFilename,
GDALDataset * poSrcDS,
int /*bStrict*/,
char ** /*papszOptions*/,
GDALProgressFunc pfnProgress,
void * pProgressData) {
const int nBands = poSrcDS->GetRasterCount();
double adfGeoTransform[6] = { };
if (poSrcDS->GetGeoTransform(adfGeoTransform) != CE_None) {
CPLError(CE_Failure, CPLE_NotSupported,
"SIGDEM driver requires a valid GeoTransform.");
return nullptr;
}
if (nBands != 1) {
CPLError(CE_Failure, CPLE_NotSupported,
"SIGDEM driver doesn't support %d bands. Must be 1 band.",
nBands);
return nullptr;
}
VSILFILE *fp = VSIFOpenL(pszFilename, "wb");
if (fp == nullptr) {
CPLError(CE_Failure, CPLE_OpenFailed,
"Attempt to create file `%s' failed.", pszFilename);
return nullptr;
}
GDALRasterBand* band = poSrcDS->GetRasterBand(1);
const char* pszProjection = poSrcDS->GetProjectionRef();
int32_t nCols = poSrcDS->GetRasterXSize();
int32_t nRows = poSrcDS->GetRasterYSize();
int32_t nCoordinateSystemId = GetCoordinateSystemId(pszProjection);
SIGDEMHeader sHeader;
sHeader.nCoordinateSystemId = nCoordinateSystemId;
sHeader.dfMinX = adfGeoTransform[0];
const char* pszMin = band->GetMetadataItem("STATISTICS_MINIMUM");
if (pszMin == nullptr) {
sHeader.dfMinZ = -10000;
} else {
sHeader.dfMinZ = CPLAtof(pszMin);
}
sHeader.dfMaxY = adfGeoTransform[3];
const char* pszMax = band->GetMetadataItem("STATISTICS_MAXIMUM");
if (pszMax == nullptr) {
sHeader.dfMaxZ = 10000;
} else {
sHeader.dfMaxZ = CPLAtof(pszMax);
}
sHeader.nCols = poSrcDS->GetRasterXSize();
sHeader.nRows = poSrcDS->GetRasterYSize();
sHeader.dfXDim = adfGeoTransform[1];
sHeader.dfYDim = -adfGeoTransform[5];
sHeader.dfMaxX = sHeader.dfMinX + sHeader.nCols * sHeader.dfXDim;
sHeader.dfMinY = sHeader.dfMaxY - sHeader.nRows * sHeader.dfYDim;
sHeader.dfOffsetX = sHeader.dfMinX;
sHeader.dfOffsetY = sHeader.dfMinY;
if( !sHeader.Write(fp) )
{
VSIUnlink(pszFilename);
VSIFCloseL(fp);
return nullptr;
}
// Write fill with all NO_DATA values
int32_t* row = static_cast<int32_t*>(VSI_MALLOC2_VERBOSE(nCols, sizeof(int32_t)));
if( !row ) {
VSIUnlink(pszFilename);
VSIFCloseL(fp);
return nullptr;
}
std::fill(row, row + nCols, CPL_MSBWORD32(NO_DATA));
for (int i = 0; i < nRows; i++) {
if( VSIFWriteL(row, CELL_SIZE_FILE, nCols, fp) !=
static_cast<size_t>(nCols) )
{
VSIFree(row);
VSIUnlink(pszFilename);
VSIFCloseL(fp);
return nullptr;
}
}
VSIFree(row);
if (VSIFCloseL(fp) != 0) {
return nullptr;
}
if (nCoordinateSystemId <= 0) {
if (!EQUAL(pszProjection, "")) {
CPLString osPrjFilename = CPLResetExtension(pszFilename, "prj");
VSILFILE *fpProj = VSIFOpenL(osPrjFilename, "wt");
if (fpProj != nullptr) {
OGRSpatialReference oSRS;
oSRS.importFromWkt(pszProjection);
oSRS.morphToESRI();
char *pszESRIProjection = nullptr;
oSRS.exportToWkt(&pszESRIProjection);
CPL_IGNORE_RET_VAL(
VSIFWriteL(pszESRIProjection, 1,
strlen(pszESRIProjection), fpProj));
CPL_IGNORE_RET_VAL(VSIFCloseL(fpProj));
CPLFree(pszESRIProjection);
} else {
CPLError(CE_Failure, CPLE_FileIO, "Unable to create file %s.",
osPrjFilename.c_str());
}
}
}
GDALOpenInfo oOpenInfo(pszFilename, GA_Update);
GDALDataset * poDstDS = Open(&oOpenInfo);
if (poDstDS != nullptr &&
GDALDatasetCopyWholeRaster(poSrcDS, poDstDS, nullptr, pfnProgress,
pProgressData) == OGRERR_NONE) {
return poDstDS;
} else {
VSIUnlink(pszFilename);
return nullptr;
}
}
virtual const char* GetMetadataItem(const char* pszKey, const char* pszDomain)
{
return poUnderlyingBand->GetMetadataItem(pszKey, pszDomain);
}
/**
* Sets the surface grids based on a ncep HRRR (surface only!) forecast.
* @param input The WindNinjaInputs for misc. info.
* @param airGrid The air temperature grid to be filled.
* @param cloudGrid The cloud cover grid to be filled.
* @param uGrid The u velocity grid to be filled.
* @param vGrid The v velocity grid to be filled.
* @param wGrid The w velocity grid to be filled (filled with zeros here?).
*/
void ncepHrrrSurfInitialization::setSurfaceGrids( WindNinjaInputs &input,
AsciiGrid<double> &airGrid,
AsciiGrid<double> &cloudGrid,
AsciiGrid<double> &uGrid,
AsciiGrid<double> &vGrid,
AsciiGrid<double> &wGrid )
{
int bandNum = -1;
GDALDataset *srcDS;
srcDS = (GDALDataset*)GDALOpenShared( input.forecastFilename.c_str(), GA_ReadOnly );
if( srcDS == NULL ) {
CPLDebug( "ncepHRRRSurfaceInitialization::identify()",
"Bad forecast file" );
}
GDALRasterBand *poBand;
const char *gc;
//get time list
std::vector<boost::local_time::local_date_time> timeList( getTimeList( input.ninjaTimeZone ) );
//Search time list for our time to identify our band number for cloud/speed/dir
//Right now, just one time step per file
std::vector<int> bandList;
for(unsigned int i = 0; i < timeList.size(); i++)
{
if(input.ninjaTime == timeList[i])
{
for(unsigned int j = 1; j < srcDS->GetRasterCount(); j++)
{
poBand = srcDS->GetRasterBand( j );
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
std::string bandName( gc );
if( bandName.find( "Temperature [K]" ) != bandName.npos ){
gc = poBand->GetMetadataItem( "GRIB_SHORT_NAME" );
std::string bandName( gc );
if( bandName.find( "2-HTGL" ) != bandName.npos ){
bandList.push_back( j ); // 2t
break;
}
}
}
for(unsigned int j = 1; j < srcDS->GetRasterCount(); j++)
{
poBand = srcDS->GetRasterBand( j );
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
std::string bandName( gc );
if( bandName.find( "v-component of wind [m/s]" ) != bandName.npos ){
gc = poBand->GetMetadataItem( "GRIB_SHORT_NAME" );
std::string bandName( gc );
if( bandName.find( "10-HTGL" ) != bandName.npos ){
bandList.push_back( j ); // 10v
break;
}
}
}
for(unsigned int j = 1; j < srcDS->GetRasterCount(); j++)
{
poBand = srcDS->GetRasterBand( j );
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
std::string bandName( gc );
if( bandName.find( "u-component of wind [m/s]" ) != bandName.npos ){
gc = poBand->GetMetadataItem( "GRIB_SHORT_NAME" );
std::string bandName( gc );
if( bandName.find( "10-HTGL" ) != bandName.npos ){
bandList.push_back( j ); // 10u
break;
}
}
}
for(unsigned int j = 1; j < srcDS->GetRasterCount(); j++)
{
poBand = srcDS->GetRasterBand( j );
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
std::string bandName( gc );
if( bandName.find( "Total cloud cover [%]" ) != bandName.npos ){
gc = poBand->GetMetadataItem( "GRIB_SHORT_NAME" );
std::string bandName( gc );
if( bandName.find( "0-RESERVED" ) != bandName.npos ){
bandList.push_back( j ); // Total cloud cover in %
break;
}
}
}
}
}
CPLDebug("HRRR", "2t: bandList[0] = %d", bandList[0]);
CPLDebug("HRRR", "10v: bandList[1] = %d", bandList[1]);
CPLDebug("HRRR", "10u: bandList[2] = %d", bandList[2]);
CPLDebug("HRRR", "tcc: bandList[3] = %d", bandList[3]);
if(bandList.size() < 4)
throw std::runtime_error("Could not match ninjaTime with a band number in the forecast file.");
std::string dstWkt;
dstWkt = input.dem.prjString;
GDALDataset *wrpDS;
std::string temp;
std::string srcWkt;
GDALWarpOptions* psWarpOptions;
srcWkt = srcDS->GetProjectionRef();
poBand = srcDS->GetRasterBand( 9 );
int pbSuccess;
double dfNoData = poBand->GetNoDataValue( &pbSuccess );
psWarpOptions = GDALCreateWarpOptions();
int nBandCount = bandList.size();
psWarpOptions->nBandCount = nBandCount;
psWarpOptions->panSrcBands =
(int*) CPLMalloc( sizeof( int ) * nBandCount );
psWarpOptions->panDstBands =
(int*) CPLMalloc( sizeof( int ) * nBandCount );
psWarpOptions->padfDstNoDataReal =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
psWarpOptions->padfDstNoDataImag =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
psWarpOptions->padfDstNoDataReal =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
psWarpOptions->padfDstNoDataImag =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
if( pbSuccess == false )
dfNoData = -9999.0;
psWarpOptions->panSrcBands =
(int *) CPLMalloc(sizeof(int) * psWarpOptions->nBandCount );
psWarpOptions->panSrcBands[0] = bandList[0];
psWarpOptions->panSrcBands[1] = bandList[1];
psWarpOptions->panSrcBands[2] = bandList[2];
psWarpOptions->panSrcBands[3] = bandList[3];
psWarpOptions->panDstBands =
(int *) CPLMalloc(sizeof(int) * psWarpOptions->nBandCount );
psWarpOptions->panDstBands[0] = 1;
psWarpOptions->panDstBands[1] = 2;
psWarpOptions->panDstBands[2] = 3;
psWarpOptions->panDstBands[3] = 4;
wrpDS = (GDALDataset*) GDALAutoCreateWarpedVRT( srcDS, srcWkt.c_str(),
dstWkt.c_str(),
GRA_NearestNeighbour,
1.0, psWarpOptions );
std::vector<std::string> varList = getVariableList();
for( unsigned int i = 0; i < varList.size(); i++ ) {
if( varList[i] == "2t" ) {
GDAL2AsciiGrid( wrpDS, i+1, airGrid );
if( CPLIsNan( dfNoData ) ) {
airGrid.set_noDataValue( -9999.0 );
airGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "10v" ) {
GDAL2AsciiGrid( wrpDS, i+1, vGrid );
if( CPLIsNan( dfNoData ) ) {
vGrid.set_noDataValue( -9999.0 );
vGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "10u" ) {
GDAL2AsciiGrid( wrpDS, i+1, uGrid );
if( CPLIsNan( dfNoData ) ) {
uGrid.set_noDataValue( -9999.0 );
uGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "tcc" ) {
GDAL2AsciiGrid( wrpDS, i+1, cloudGrid );
if( CPLIsNan( dfNoData ) ) {
cloudGrid.set_noDataValue( -9999.0 );
cloudGrid.replaceNan( -9999.0 );
}
}
}
//if there are any clouds set cloud fraction to 1, otherwise set to 0.
for(int i = 0; i < cloudGrid.get_nRows(); i++){
for(int j = 0; j < cloudGrid.get_nCols(); j++){
if(cloudGrid(i,j) < 0.0){
cloudGrid(i,j) = 0.0;
}
else{
cloudGrid(i,j) = 1.0;
}
}
}
wGrid.set_headerData( uGrid );
wGrid = 0.0;
airGrid += 273.15;
GDALDestroyWarpOptions( psWarpOptions );
GDALClose((GDALDatasetH) srcDS );
GDALClose((GDALDatasetH) wrpDS );
}
/**
* Sets the surface grids based on a ncep HRRR (surface only!) forecast.
* @param input The WindNinjaInputs for misc. info.
* @param airGrid The air temperature grid to be filled.
* @param cloudGrid The cloud cover grid to be filled.
* @param uGrid The u velocity grid to be filled.
* @param vGrid The v velocity grid to be filled.
* @param wGrid The w velocity grid to be filled (filled with zeros here?).
*/
void ncepHrrrSurfInitialization::setSurfaceGrids( WindNinjaInputs &input,
AsciiGrid<double> &airGrid,
AsciiGrid<double> &cloudGrid,
AsciiGrid<double> &uGrid,
AsciiGrid<double> &vGrid,
AsciiGrid<double> &wGrid )
{
int bandNum = -1;
GDALDataset *srcDS;
srcDS = (GDALDataset*)GDALOpenShared( input.forecastFilename.c_str(), GA_ReadOnly );
if( srcDS == NULL ) {
CPLDebug( "ncepHRRRSurfaceInitialization::identify()",
"Bad forecast file" );
}
GDALRasterBand *poBand = srcDS->GetRasterBand( 49 );
const char *gc;
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
std::string bandName( gc );
//get time list
std::vector<boost::local_time::local_date_time> timeList( getTimeList( input.ninjaTimeZone ) );
//Search time list for our time to identify our band number for cloud/speed/dir
//Right now, just one time step per file
std::vector<int> bandList;
for(unsigned int i = 0; i < timeList.size(); i++)
{
if(input.ninjaTime == timeList[i])
{
//check which HRRR format we have
if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){ //if band 49 isn't u10, it's either 2010 or 2012 format
GDALRasterBand *poBand = srcDS->GetRasterBand( 50 );
const char *gc;
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
std::string bandName( gc );
if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){ //if band 50 isn't u10, it's the 2010 format
bandList.push_back( 29 ); // 2t
bandList.push_back( 34 ); // 10v
bandList.push_back( 33 ); // 10u
bandList.push_back( 52 ); // geopotential height at cloud top
}
else{
bandList.push_back( 45 ); // 2t
bandList.push_back( 51 ); // 10v
bandList.push_back( 50 ); // 10u
bandList.push_back( 78 ); // geopotential height at cloud top
}
}
else{ //otherwise, should be 2011 format, but check for u10 band to be sure
poBand = srcDS->GetRasterBand( 44 );
gc = poBand->GetMetadataItem( "GRIB_COMMENT" );
bandName = gc;
if( bandName.find( "u-component of wind [m/s]" ) == bandName.npos ){
CPLDebug( "ncepHRRRSurfaceInitialization::identify()",
"Can't find the u-10 band in the forecast file." );
}
bandList.push_back( 44 ); // 2t
bandList.push_back( 50 ); // 10v
bandList.push_back( 49 ); // 10u
bandList.push_back( 73 ); // geopotential height at cloud top
}
break;
}
}
if(bandList.size() < 4)
throw std::runtime_error("Could not match ninjaTime with a band number in the forecast file.");
std::string dstWkt;
dstWkt = input.dem.prjString;
GDALDataset *wrpDS;
std::string temp;
std::string srcWkt;
GDALWarpOptions* psWarpOptions;
srcWkt = srcDS->GetProjectionRef();
poBand = srcDS->GetRasterBand( 9 );
int pbSuccess;
double dfNoData = poBand->GetNoDataValue( &pbSuccess );
psWarpOptions = GDALCreateWarpOptions();
int nBandCount = bandList.size();
psWarpOptions->nBandCount = nBandCount;
psWarpOptions->panSrcBands =
(int*) CPLMalloc( sizeof( int ) * nBandCount );
psWarpOptions->panDstBands =
(int*) CPLMalloc( sizeof( int ) * nBandCount );
psWarpOptions->padfDstNoDataReal =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
psWarpOptions->padfDstNoDataImag =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
psWarpOptions->padfDstNoDataReal =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
psWarpOptions->padfDstNoDataImag =
(double*) CPLMalloc( sizeof( double ) * nBandCount );
if( pbSuccess == false )
dfNoData = -9999.0;
psWarpOptions->panSrcBands =
(int *) CPLMalloc(sizeof(int) * psWarpOptions->nBandCount );
psWarpOptions->panSrcBands[0] = bandList[0];
psWarpOptions->panSrcBands[1] = bandList[1];
psWarpOptions->panSrcBands[2] = bandList[2];
psWarpOptions->panSrcBands[3] = bandList[3];
psWarpOptions->panDstBands =
(int *) CPLMalloc(sizeof(int) * psWarpOptions->nBandCount );
psWarpOptions->panDstBands[0] = 1;
psWarpOptions->panDstBands[1] = 2;
psWarpOptions->panDstBands[2] = 3;
psWarpOptions->panDstBands[3] = 4;
wrpDS = (GDALDataset*) GDALAutoCreateWarpedVRT( srcDS, srcWkt.c_str(),
dstWkt.c_str(),
GRA_NearestNeighbour,
1.0, psWarpOptions );
std::vector<std::string> varList = getVariableList();
for( unsigned int i = 0; i < varList.size(); i++ ) {
if( varList[i] == "2t" ) {
GDAL2AsciiGrid( wrpDS, i+1, airGrid );
if( CPLIsNan( dfNoData ) ) {
airGrid.set_noDataValue( -9999.0 );
airGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "10v" ) {
GDAL2AsciiGrid( wrpDS, i+1, vGrid );
if( CPLIsNan( dfNoData ) ) {
vGrid.set_noDataValue( -9999.0 );
vGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "10u" ) {
GDAL2AsciiGrid( wrpDS, i+1, uGrid );
if( CPLIsNan( dfNoData ) ) {
uGrid.set_noDataValue( -9999.0 );
uGrid.replaceNan( -9999.0 );
}
}
else if( varList[i] == "gh" ) {
GDAL2AsciiGrid( wrpDS, i+1, cloudGrid );
if( CPLIsNan( dfNoData ) ) {
cloudGrid.set_noDataValue( -9999.0 );
cloudGrid.replaceNan( -9999.0 );
}
}
}
//if there are any clouds set cloud fraction to 1, otherwise set to 0.
for(int i = 0; i < cloudGrid.get_nRows(); i++){
for(int j = 0; j < cloudGrid.get_nCols(); j++){
if(cloudGrid(i,j) < 0.0){
cloudGrid(i,j) = 0.0;
}
else{
cloudGrid(i,j) = 1.0;
}
}
}
wGrid.set_headerData( uGrid );
wGrid = 0.0;
airGrid += 273.15;
GDALDestroyWarpOptions( psWarpOptions );
GDALClose((GDALDatasetH) srcDS );
GDALClose((GDALDatasetH) wrpDS );
}
