SEXP
RGDAL_GetCategoryNames(SEXP sxpRasterBand) {
GDALRasterBand *pRasterBand = getGDALRasterPtr(sxpRasterBand);
char **pcCNames = pRasterBand->GetCategoryNames();
if (pcCNames == NULL) return(R_NilValue);
pcCNames = CSLDuplicate(pcCNames);
SEXP sxpCNames;
PROTECT(sxpCNames = allocVector(STRSXP, CSLCount(pcCNames)));
int i;
for (i = 0; i < CSLCount(pcCNames); ++i) {
const char *field = CSLGetField(pcCNames, i);
SET_VECTOR_ELT(sxpCNames, i, mkChar(field));
}
UNPROTECT(1);
return(sxpCNames);
}
SEXP
RGDAL_GetCategoryNames(SEXP sxpRasterBand) {
GDALRasterBand *pRasterBand = getGDALRasterPtr(sxpRasterBand);
installErrorHandler();
char **pcCNames = pRasterBand->GetCategoryNames();
uninstallErrorHandlerAndTriggerError();
if (pcCNames == NULL) return(R_NilValue);
installErrorHandler();
pcCNames = CSLDuplicate(pcCNames);
uninstallErrorHandlerAndTriggerError();
SEXP sxpCNames;
installErrorHandler();
int ii = CSLCount(pcCNames);
uninstallErrorHandlerAndTriggerError();
PROTECT(sxpCNames = allocVector(STRSXP, ii));
int i;
installErrorHandler();
for (i = 0; i < ii; ++i) {
const char *field = CSLGetField(pcCNames, i);
SET_STRING_ELT(sxpCNames, i, mkChar(field));
}
uninstallErrorHandlerAndTriggerError();
UNPROTECT(1);
return(sxpCNames);
}
GDALDataset *IntergraphDataset::CreateCopy( const char *pszFilename,
GDALDataset *poSrcDS,
int bStrict,
char **papszOptions,
GDALProgressFunc pfnProgress,
void *pProgressData )
{
(void) bStrict;
int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Intergraph driver does not support source dataset with zero band.\n");
return NULL;
}
if( !pfnProgress( 0.0, NULL, pProgressData ) )
{
return NULL;
}
// --------------------------------------------------------------------
// Query GDAL Data Type
// --------------------------------------------------------------------
GDALDataType eType = poSrcDS->GetRasterBand(1)->GetRasterDataType();
// --------------------------------------------------------------------
// Copy metadata
// --------------------------------------------------------------------
char **papszCreateOptions = CSLDuplicate( papszOptions );
const char *pszValue;
pszValue = CSLFetchNameValue(papszCreateOptions, "RESOLUTION");
if( pszValue == NULL )
{
const char *value = poSrcDS->GetMetadataItem("RESOLUTION");
if (value)
{
papszCreateOptions = CSLSetNameValue( papszCreateOptions, "RESOLUTION",
value );
}
}
// --------------------------------------------------------------------
// Create IntergraphDataset
// --------------------------------------------------------------------
IntergraphDataset *poDstDS;
poDstDS = (IntergraphDataset*) IntergraphDataset::Create( pszFilename,
poSrcDS->GetRasterXSize(),
poSrcDS->GetRasterYSize(),
poSrcDS->GetRasterCount(),
eType,
papszCreateOptions );
CSLDestroy( papszCreateOptions );
if( poDstDS == NULL )
{
return NULL;
}
// --------------------------------------------------------------------
// Copy Transformation Matrix to the dataset
// --------------------------------------------------------------------
double adfGeoTransform[6];
poDstDS->SetProjection( poSrcDS->GetProjectionRef() );
poSrcDS->GetGeoTransform( adfGeoTransform );
poDstDS->SetGeoTransform( adfGeoTransform );
// --------------------------------------------------------------------
// Copy information to the raster band
// --------------------------------------------------------------------
GDALRasterBand *poSrcBand;
GDALRasterBand *poDstBand;
double dfMin;
double dfMax;
double dfMean;
double dfStdDev = -1;
for( int i = 1; i <= poDstDS->nBands; i++)
{
delete poDstDS->GetRasterBand(i);
}
poDstDS->nBands = 0;
if( poDstDS->hHeaderOne.DataTypeCode == Uncompressed24bit )
{
poDstDS->SetBand( 1, new IntergraphRGBBand( poDstDS, 1, 0, 3 ) );
poDstDS->SetBand( 2, new IntergraphRGBBand( poDstDS, 2, 0, 2 ) );
poDstDS->SetBand( 3, new IntergraphRGBBand( poDstDS, 3, 0, 1 ) );
poDstDS->nBands = 3;
}
else
{
for( int i = 1; i <= poSrcDS->GetRasterCount(); i++ )
{
poSrcBand = poSrcDS->GetRasterBand(i);
eType = poSrcDS->GetRasterBand(i)->GetRasterDataType();
poDstBand = new IntergraphRasterBand( poDstDS, i, 0, eType );
poDstDS->SetBand( i, poDstBand );
poDstBand->SetCategoryNames( poSrcBand->GetCategoryNames() );
poDstBand->SetColorTable( poSrcBand->GetColorTable() );
poSrcBand->GetStatistics( false, true, &dfMin, &dfMax, &dfMean, &dfStdDev );
poDstBand->SetStatistics( dfMin, dfMax, dfMean, dfStdDev );
}
}
// --------------------------------------------------------------------
// Copy image data
// --------------------------------------------------------------------
int nXSize = poDstDS->GetRasterXSize();
int nYSize = poDstDS->GetRasterYSize();
int nBlockXSize;
int nBlockYSize;
CPLErr eErr = CE_None;
for( int iBand = 1; iBand <= poSrcDS->GetRasterCount(); iBand++ )
{
GDALRasterBand *poDstBand = poDstDS->GetRasterBand( iBand );
GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand( iBand );
// ------------------------------------------------------------
// Copy Untiled / Uncompressed
// ------------------------------------------------------------
int iYOffset, iXOffset;
void *pData;
poSrcBand->GetBlockSize( &nBlockXSize, &nBlockYSize );
nBlockXSize = nXSize;
nBlockYSize = 1;
pData = CPLMalloc( nBlockXSize * nBlockYSize * GDALGetDataTypeSize( eType ) / 8 );
for( iYOffset = 0; iYOffset < nYSize; iYOffset += nBlockYSize )
{
for( iXOffset = 0; iXOffset < nXSize; iXOffset += nBlockXSize )
{
eErr = poSrcBand->RasterIO( GF_Read,
iXOffset, iYOffset,
nBlockXSize, nBlockYSize,
pData, nBlockXSize, nBlockYSize,
eType, 0, 0, NULL );
if( eErr != CE_None )
{
return NULL;
}
eErr = poDstBand->RasterIO( GF_Write,
iXOffset, iYOffset,
nBlockXSize, nBlockYSize,
pData, nBlockXSize, nBlockYSize,
eType, 0, 0, NULL );
if( eErr != CE_None )
{
return NULL;
}
}
if( ( eErr == CE_None ) && ( ! pfnProgress(
( iYOffset + 1 ) / ( double ) nYSize, NULL, pProgressData ) ) )
{
eErr = CE_Failure;
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated CreateCopy()" );
}
}
CPLFree( pData );
}
// --------------------------------------------------------------------
// Finalize
// --------------------------------------------------------------------
poDstDS->FlushCache();
return poDstDS;
}
GDALDataset *GSBGDataset::CreateCopy( const char *pszFilename,
GDALDataset *poSrcDS,
int bStrict, char **papszOptions,
GDALProgressFunc pfnProgress,
void *pProgressData )
{
if( pfnProgress == NULL )
pfnProgress = GDALDummyProgress;
int nBands = poSrcDS->GetRasterCount();
if (nBands == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"GSBG driver does not support source dataset with zero band.\n");
return NULL;
}
else if (nBands > 1)
{
if( bStrict )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Unable to create copy, Golden Software Binary Grid "
"format only supports one raster band.\n" );
return NULL;
}
else
CPLError( CE_Warning, CPLE_NotSupported,
"Golden Software Binary Grid format only supports one "
"raster band, first band will be copied.\n" );
}
GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand( 1 );
if( poSrcBand->GetXSize() > SHRT_MAX
|| poSrcBand->GetYSize() > SHRT_MAX )
{
CPLError( CE_Failure, CPLE_IllegalArg,
"Unable to create grid, Golden Software Binary Grid format "
"only supports sizes up to %dx%d. %dx%d not supported.\n",
SHRT_MAX, SHRT_MAX,
poSrcBand->GetXSize(), poSrcBand->GetYSize() );
return NULL;
}
if( !pfnProgress( 0.0, NULL, pProgressData ) )
{
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated\n" );
return NULL;
}
VSILFILE *fp = VSIFOpenL( pszFilename, "w+b" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create file '%s' failed.\n",
pszFilename );
return NULL;
}
GInt16 nXSize = poSrcBand->GetXSize();
GInt16 nYSize = poSrcBand->GetYSize();
double adfGeoTransform[6];
poSrcDS->GetGeoTransform( adfGeoTransform );
double dfMinX = adfGeoTransform[0] + adfGeoTransform[1] / 2;
double dfMaxX = adfGeoTransform[1] * (nXSize - 0.5) + adfGeoTransform[0];
double dfMinY = adfGeoTransform[5] * (nYSize - 0.5) + adfGeoTransform[3];
double dfMaxY = adfGeoTransform[3] + adfGeoTransform[5] / 2;
CPLErr eErr = WriteHeader( fp, nXSize, nYSize,
dfMinX, dfMaxX, dfMinY, dfMaxY, 0.0, 0.0 );
if( eErr != CE_None )
{
VSIFCloseL( fp );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Copy band data. */
/* -------------------------------------------------------------------- */
float *pfData = (float *)VSIMalloc2( nXSize, sizeof( float ) );
if( pfData == NULL )
{
VSIFCloseL( fp );
CPLError( CE_Failure, CPLE_OutOfMemory,
"Unable to create copy, unable to allocate line buffer.\n" );
return NULL;
}
int bSrcHasNDValue;
float fSrcNoDataValue = poSrcBand->GetNoDataValue( &bSrcHasNDValue );
double dfMinZ = DBL_MAX;
double dfMaxZ = -DBL_MAX;
for( GInt16 iRow = nYSize - 1; iRow >= 0; iRow-- )
{
eErr = poSrcBand->RasterIO( GF_Read, 0, iRow,
nXSize, 1, pfData,
nXSize, 1, GDT_Float32, 0, 0 );
if( eErr != CE_None )
{
VSIFCloseL( fp );
VSIFree( pfData );
return NULL;
}
for( int iCol=0; iCol<nXSize; iCol++ )
{
if( bSrcHasNDValue && pfData[iCol] == fSrcNoDataValue )
{
pfData[iCol] = fNODATA_VALUE;
}
else
{
if( pfData[iCol] > dfMaxZ )
dfMaxZ = pfData[iCol];
if( pfData[iCol] < dfMinZ )
dfMinZ = pfData[iCol];
}
CPL_LSBPTR32( pfData+iCol );
}
if( VSIFWriteL( (void *)pfData, 4, nXSize,
fp ) != static_cast<unsigned>(nXSize) )
{
VSIFCloseL( fp );
VSIFree( pfData );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to write grid row. Disk full?\n" );
return NULL;
}
if( !pfnProgress( static_cast<double>(iRow)/nYSize,
NULL, pProgressData ) )
{
VSIFCloseL( fp );
VSIFree( pfData );
CPLError( CE_Failure, CPLE_UserInterrupt, "User terminated" );
return NULL;
}
}
VSIFree( pfData );
/* write out the min and max values */
eErr = WriteHeader( fp, nXSize, nYSize,
dfMinX, dfMaxX, dfMinY, dfMaxY, dfMinZ, dfMaxZ );
if( eErr != CE_None )
{
VSIFCloseL( fp );
return NULL;
}
VSIFCloseL( fp );
GDALPamDataset *poDstDS = (GDALPamDataset *)GDALOpen( pszFilename,
GA_Update );
if( poDstDS == NULL )
{
VSIUnlink( pszFilename );
CPLError( CE_Failure, CPLE_FileIO,
"Unable to open copy of dataset.\n" );
return NULL;
}
else if( dynamic_cast<GSBGDataset *>(poDstDS) == NULL )
{
VSIUnlink( pszFilename );
delete poDstDS;
CPLError( CE_Failure, CPLE_FileIO,
"Copy dataset not opened as Golden Surfer Binary Grid!?\n" );
return NULL;
}
GDALRasterBand *poDstBand = poSrcDS->GetRasterBand(1);
if( poDstBand == NULL )
{
VSIUnlink( pszFilename );
delete poDstDS;
CPLError( CE_Failure, CPLE_FileIO,
"Unable to open copy of raster band?\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Attempt to copy metadata. */
/* -------------------------------------------------------------------- */
if( !bStrict )
CPLPushErrorHandler( CPLQuietErrorHandler );
/* non-zero transform 2 or 4 or negative 1 or 5 not supported natively */
/*if( adfGeoTransform[2] != 0.0 || adfGeoTransform[4] != 0.0
|| adfGeoTransform[1] < 0.0 || adfGeoTransform[5] < 0.0 )
poDstDS->GDALPamDataset::SetGeoTransform( adfGeoTransform );*/
const char *szProjectionRef = poSrcDS->GetProjectionRef();
if( *szProjectionRef != '\0' )
poDstDS->SetProjection( szProjectionRef );
char **pszMetadata = poSrcDS->GetMetadata();
if( pszMetadata != NULL )
poDstDS->SetMetadata( pszMetadata );
/* FIXME: Should the dataset description be copied as well, or is it
* always the file name? */
poDstBand->SetDescription( poSrcBand->GetDescription() );
int bSuccess;
double dfOffset = poSrcBand->GetOffset( &bSuccess );
if( bSuccess && dfOffset != 0.0 )
poDstBand->SetOffset( dfOffset );
double dfScale = poSrcBand->GetScale( &bSuccess );
if( bSuccess && dfScale != 1.0 )
poDstBand->SetScale( dfScale );
GDALColorInterp oColorInterp = poSrcBand->GetColorInterpretation();
if( oColorInterp != GCI_Undefined )
poDstBand->SetColorInterpretation( oColorInterp );
char **pszCatNames = poSrcBand->GetCategoryNames();
if( pszCatNames != NULL)
poDstBand->SetCategoryNames( pszCatNames );
GDALColorTable *poColorTable = poSrcBand->GetColorTable();
if( poColorTable != NULL )
poDstBand->SetColorTable( poColorTable );
if( !bStrict )
CPLPopErrorHandler();
return poDstDS;
}
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;
}
