const char *GDALProxyPoolDataset::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);
GDALDataset* poUnderlyingDataset = RefUnderlyingDataset();
if (poUnderlyingDataset == NULL)
return NULL;
const char* pszUnderlyingMetadataItem =
poUnderlyingDataset->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);
UnrefUnderlyingDataset(poUnderlyingDataset);
return pElt->pszMetadataItem;
}
const char *GDALOverviewDataset::GetMetadataItem( const char * pszName,
const char * pszDomain )
{
if (poOvrDS != NULL)
{
const char* pszValue = poOvrDS->GetMetadataItem(pszName, pszDomain);
if( pszValue != NULL )
return pszValue;
}
if( pszDomain != NULL && (EQUAL(pszDomain, "RPC") ||
EQUAL(pszDomain, "GEOLOCATION")) )
{
char** papszMD = GetMetadata(pszDomain);
return CSLFetchNameValue(papszMD, pszName);
}
return poMainDS->GetMetadataItem(pszName, pszDomain);
}
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;
}
IRaster* ingestGDALRaster()
{
GDALDataset* ds = gdalDataset;
cout << "Reading raster metadata...";
GDALRasterBand* band = ds->GetRasterBand(bandNum);
int xSize = band->GetXSize();
int ySize = band->GetYSize();
int hasNoDataValue;
double noDataValue = band->GetNoDataValue(&hasNoDataValue);
if (hasNoDataValue != 0)
noDataValue = NULL_DOUBLE_;
double xForm[6];
ds->GetGeoTransform(xForm);
double minX = xForm[0];
double cellSizeX = xForm[1];
double skewX = xForm[2];
double minY = xForm[3];
double skewY = xForm[4];
double cellSizeY = xForm[5];
string* spatialRef = new string(ds->GetProjectionRef());
if( ds->GetMetadataItem("NC_GLOBAL#IOAPI_VERSION", "") != NULL) {
// Get georeference from IOAPI metadata
// See: http://www.baronams.com/products/ioapi/GRIDS.html#horiz
// Build the affine transform from metadata
minX = atof(ds->GetMetadataItem("NC_GLOBAL#XORIG", ""));
minY = atof(ds->GetMetadataItem("NC_GLOBAL#YORIG", ""));
cellSizeX = atof(ds->GetMetadataItem("NC_GLOBAL#XCELL", ""));
cellSizeY = atof(ds->GetMetadataItem("NC_GLOBAL#YCELL", ""));
skewX = 0;
skewY = 0;
// Build the SpatialReference
double xcent, ycent, p_alp, p_bet, p_gam;
char *gdnam;
OGRSpatialReference* sref = new OGRSpatialReference("");
// Assume datum is WGS84 (may not be, but IO/API files don't (can't?) say...)
sref->SetWellKnownGeogCS("WGS84");
int gdtyp = atoi(ds->GetMetadataItem("NC_GLOBAL#GDTYP", ""));
switch(gdtyp) {
case 0:
// Unknown projection (we assume lat-lon)
break;
case 1:
// LATGRD3 -- Latitude/longitude
break;
case 2:
// LAMGRD3 -- Lambert Conformal Conic (two standard parallels)
xcent = atof(ds->GetMetadataItem("NC_GLOBAL#XCENT", ""));
ycent = atof(ds->GetMetadataItem("NC_GLOBAL#YCENT", ""));
p_alp = atof(ds->GetMetadataItem("NC_GLOBAL#P_ALP", ""));
p_bet = atof(ds->GetMetadataItem("NC_GLOBAL#P_BET", ""));
sref->SetLCC(p_alp, p_bet, ycent, xcent, 0, 0);
gdnam = (char *)ds->GetMetadataItem("NC_GLOBAL#GDNAM", "");
sref->SetProjCS(gdnam);
break;
case 9:
// ALBGRD3 -- Albers Equal-Area Conic
xcent = atof(ds->GetMetadataItem("NC_GLOBAL#XCENT", ""));
ycent = atof(ds->GetMetadataItem("NC_GLOBAL#YCENT", ""));
p_alp = atof(ds->GetMetadataItem("NC_GLOBAL#P_ALP", ""));
p_bet = atof(ds->GetMetadataItem("NC_GLOBAL#P_BET", ""));
sref->SetACEA(p_alp, p_bet, ycent, xcent, 0, 0);
gdnam = (char *)ds->GetMetadataItem("NC_GLOBAL#GDNAM", "");
sref->SetProjCS(gdnam);
break;
case 10:
// LEQGRID3 -- Lambert Azimuthal Equal-Area
p_alp = atof(ds->GetMetadataItem("NC_GLOBAL#P_ALP", ""));
// Correct for bad metadata on some files
if(p_alp == 0.0) {
xcent = atof(ds->GetMetadataItem("NC_GLOBAL#XCENT", ""));
ycent = atof(ds->GetMetadataItem("NC_GLOBAL#YCENT", ""));
p_alp = ycent;
p_gam = xcent;
} else {
p_gam = atof(ds->GetMetadataItem("NC_GLOBAL#P_GAM", ""));
}
sref->SetLAEA(p_alp, p_gam, 0, 0);
gdnam = (char *)ds->GetMetadataItem("NC_GLOBAL#GDNAM", "");
sref->SetProjCS(gdnam);
break;
default:
throw new runtime_error("ERROR: Unable to parse IO/API GDTYP variable");
}
char* wktSrStr = new char[spatialRef->length()];
strcpy((char *)spatialRef->c_str(), wktSrStr);
sref->exportToWkt(&wktSrStr);
//CPLFree(sref);
spatialRef->assign(wktSrStr);
}
cout << "...Done.\nReading raster band " << bandNum << "...";
IRaster* result = NULL;
CPLErr retval;
switch (band->GetRasterDataType()) {
//retval = band->RasterIO(GF_Read, 0, 0, band->XSize, band->YSize, floatArray, band->XSize, band->YSize, 0, 0);
case GDT_Float32: {
float* floatArray = new float[xSize * ySize];
retval = band->RasterIO(GF_Read, 0, 0, xSize, ySize, floatArray, xSize, ySize, band->GetRasterDataType(), 0, 0);
if (retval != CE_None)
throw new runtime_error("GDALRasterBand::ReadBlock() returned error");
result = new Raster<float>(floatArray, xSize, ySize, cellSizeX, cellSizeY, minX, minY, skewX, skewY, spatialRef, noDataValue);
cout << " -- Pixel type: Float32 -- ...Done\n";
} break;
case GDT_Float64: {
double* doubleArray = new double[xSize * ySize];
retval = band->RasterIO(GF_Read, 0, 0, xSize, ySize, doubleArray, xSize, ySize, band->GetRasterDataType(), 0, 0);
if (retval != CE_None)
throw new runtime_error("GDALRasterBand::ReadBlock() returned error");
result = new Raster<double>(doubleArray, xSize, ySize, cellSizeX, cellSizeY, minX, minY, skewX, skewY, spatialRef, noDataValue);
cout << " -- Pixel type: Float64 -- ...Done\n";
} break;
case GDT_Int32: {
int* intArray = new int[xSize * ySize];
retval = band->RasterIO(GF_Read, 0, 0, xSize, ySize, intArray, xSize, ySize, band->GetRasterDataType(), 0, 0);
if (retval != CE_None)
throw new runtime_error("GDALRasterBand::ReadBlock() returned error");
result = new Raster<int>(intArray, xSize, ySize, cellSizeX, cellSizeY, minX, minY, skewX, skewY, spatialRef, noDataValue);
cout << " -- Pixel type: Int32 -- ...Done\n";
} break;
case GDT_Int16: {
short* shortArray = new short[xSize * ySize];
retval = band->RasterIO(GF_Read, 0, 0, xSize, ySize, shortArray, xSize, ySize, band->GetRasterDataType(), 0, 0);
if (retval != CE_None)
throw new runtime_error("GDALRasterBand::ReadBlock() returned error");
result = new Raster<short>(shortArray, xSize, ySize, cellSizeX, cellSizeY, minX, minY, skewX, skewY, spatialRef, noDataValue);
cout << " -- Pixel type: Int32 -- ...Done\n";
} break;
case GDT_Byte: {
char* byteArray = new char[xSize * ySize];
retval = band->RasterIO(GF_Read, 0, 0, xSize, ySize, byteArray, xSize, ySize, band->GetRasterDataType(), 0, 0);
if (retval != CE_None)
throw new runtime_error("GDALRasterBand::ReadBlock() returned error");
result = new Raster<char>(byteArray, xSize, ySize, cellSizeX, cellSizeY, minX, minY, skewX, skewY, spatialRef, noDataValue);
cout << " -- Pixel type: Byte -- ...Done\n";
} break;
default:
throw new runtime_error("Unsupported pixel type");
}
return result;
}