CPLErr GDALPamRasterBand::SetUnitType( const char *pszNewValue )
{
PamInitialize();
if( psPam )
{
if( pszNewValue == NULL || pszNewValue[0] == '\0' )
{
if (psPam->pszUnitType != NULL)
psPam->poParentDS->MarkPamDirty();
CPLFree( psPam->pszUnitType );
psPam->pszUnitType = NULL;
}
else
{
if (psPam->pszUnitType == NULL ||
strcmp(psPam->pszUnitType, pszNewValue) != 0)
psPam->poParentDS->MarkPamDirty();
CPLFree( psPam->pszUnitType );
psPam->pszUnitType = CPLStrdup(pszNewValue);
}
return CE_None;
}
else
return GDALRasterBand::SetUnitType( pszNewValue );
}
CPLErr GDALPamRasterBand::SetColorTable( GDALColorTable *poTableIn )
{
PamInitialize();
if( psPam )
{
if( psPam->poColorTable != NULL )
{
delete psPam->poColorTable;
psPam->poColorTable = NULL;
}
if( poTableIn )
{
psPam->poColorTable = poTableIn->Clone();
psPam->eColorInterp = GCI_PaletteIndex;
}
psPam->poParentDS->MarkPamDirty();
return CE_None;
}
else
return GDALRasterBand::SetColorTable( poTableIn );
}
CPLErr GDALPamDataset::SetGCPs( int nGCPCount, const GDAL_GCP *pasGCPList,
const char *pszGCPProjection )
{
PamInitialize();
if( psPam )
{
CPLFree( psPam->pszGCPProjection );
if( psPam->nGCPCount > 0 )
{
GDALDeinitGCPs( psPam->nGCPCount, psPam->pasGCPList );
CPLFree( psPam->pasGCPList );
}
psPam->pszGCPProjection = CPLStrdup(pszGCPProjection);
psPam->nGCPCount = nGCPCount;
psPam->pasGCPList = GDALDuplicateGCPs( nGCPCount, pasGCPList );
MarkPamDirty();
return CE_None;
}
else
{
return GDALDataset::SetGCPs( nGCPCount, pasGCPList, pszGCPProjection );
}
}
void GDALPamDataset::SetPhysicalFilename( const char *pszFilename )
{
PamInitialize();
if( psPam )
psPam->osPhysicalFilename = pszFilename;
}
void GDALPamDataset::SetSubdatasetName( const char *pszSubdataset )
{
PamInitialize();
if( psPam )
psPam->osSubdatasetName = pszSubdataset;
}
void GDALPamRasterBand::SetDescription( const char *pszDescription )
{
PamInitialize();
if( psPam && strcmp(pszDescription,GetDescription()) != 0 )
psPam->poParentDS->MarkPamDirty();
GDALRasterBand::SetDescription( pszDescription );
}
const GDALRasterAttributeTable *GDALPamRasterBand::GetDefaultRAT()
{
PamInitialize();
if( psPam == NULL )
return GDALRasterBand::GetDefaultRAT();
return psPam->poDefaultRAT;
}
CPLErr GDALPamDataset::SetMetadata( char **papszMetadata,
const char *pszDomain )
{
PamInitialize();
if( psPam )
MarkPamDirty();
return GDALDataset::SetMetadata( papszMetadata, pszDomain );
}
CPLErr GDALPamRasterBand::SetMetadata( char **papszMetadata,
const char *pszDomain )
{
PamInitialize();
if( psPam )
psPam->poParentDS->MarkPamDirty();
return GDALRasterBand::SetMetadata( papszMetadata, pszDomain );
}
CPLErr GDALPamRasterBand::SetMetadataItem( const char *pszName,
const char *pszValue,
const char *pszDomain )
{
PamInitialize();
if( psPam )
psPam->poParentDS->MarkPamDirty();
return GDALRasterBand::SetMetadataItem( pszName, pszValue, pszDomain );
}
CPLErr GDALPamDataset::SetMetadataItem( const char *pszName,
const char *pszValue,
const char *pszDomain )
{
PamInitialize();
if( psPam )
MarkPamDirty();
return GDALDataset::SetMetadataItem( pszName, pszValue, pszDomain );
}
CPLErr GDALPamRasterBand::DeleteNoDataValue()
{
PamInitialize();
if( !psPam )
return GDALRasterBand::DeleteNoDataValue();
psPam->bNoDataValueSet = FALSE;
psPam->dfNoDataValue = 0.0;
psPam->poParentDS->MarkPamDirty();
return CE_None;
}
CPLErr GDALPamRasterBand::SetNoDataValue( double dfNewValue )
{
PamInitialize();
if( !psPam )
return GDALRasterBand::SetNoDataValue( dfNewValue );
psPam->bNoDataValueSet = TRUE;
psPam->dfNoDataValue = dfNewValue;
psPam->poParentDS->MarkPamDirty();
return CE_None;
}
CPLErr GDALPamRasterBand::SetCategoryNames( char ** papszNewNames )
{
PamInitialize();
if( !psPam )
return GDALRasterBand::SetCategoryNames( papszNewNames );
CSLDestroy( psPam->papszCategoryNames );
psPam->papszCategoryNames = CSLDuplicate( papszNewNames );
psPam->poParentDS->MarkPamDirty();
return CE_None;
}
CPLErr GDALPamRasterBand::SetDefaultHistogram( double dfMin, double dfMax,
int nBuckets, int *panHistogram)
{
CPLXMLNode *psNode;
PamInitialize();
if( psPam == NULL )
return GDALRasterBand::SetDefaultHistogram( dfMin, dfMax,
nBuckets, panHistogram );
/* -------------------------------------------------------------------- */
/* Do we have a matching histogram we should replace? */
/* -------------------------------------------------------------------- */
psNode = PamFindMatchingHistogram( psPam->psSavedHistograms,
dfMin, dfMax, nBuckets,
TRUE, TRUE );
if( psNode != NULL )
{
/* blow this one away */
CPLRemoveXMLChild( psPam->psSavedHistograms, psNode );
CPLDestroyXMLNode( psNode );
}
/* -------------------------------------------------------------------- */
/* Translate into a histogram XML tree. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psHistItem;
psHistItem = PamHistogramToXMLTree( dfMin, dfMax, nBuckets,
panHistogram, TRUE, FALSE );
if( psHistItem == NULL )
return CE_Failure;
/* -------------------------------------------------------------------- */
/* Insert our new default histogram at the front of the */
/* histogram list so that it will be the default histogram. */
/* -------------------------------------------------------------------- */
psPam->poParentDS->MarkPamDirty();
if( psPam->psSavedHistograms == NULL )
psPam->psSavedHistograms = CPLCreateXMLNode( NULL, CXT_Element,
"Histograms" );
psHistItem->psNext = psPam->psSavedHistograms->psChild;
psPam->psSavedHistograms->psChild = psHistItem;
return CE_None;
}
CPLErr GDALPamRasterBand::SetScale( double dfNewScale )
{
PamInitialize();
if( psPam == nullptr )
return GDALRasterBand::SetScale( dfNewScale );
if( dfNewScale != psPam->dfScale )
{
psPam->dfScale = dfNewScale;
psPam->poParentDS->MarkPamDirty();
}
return CE_None;
}
CPLErr GDALPamDataset::SetProjection( const char *pszProjectionIn )
{
PamInitialize();
if( psPam == NULL )
return GDALDataset::SetProjection( pszProjectionIn );
else
{
CPLFree( psPam->pszProjection );
psPam->pszProjection = CPLStrdup( pszProjectionIn );
MarkPamDirty();
return CE_None;
}
}
CPLErr GDALPamRasterBand::SetOffset( double dfNewOffset )
{
PamInitialize();
if( psPam == nullptr )
return GDALRasterBand::SetOffset( dfNewOffset );
if( psPam->dfOffset != dfNewOffset )
{
psPam->dfOffset = dfNewOffset;
psPam->poParentDS->MarkPamDirty();
}
return CE_None;
}
CPLErr GDALPamRasterBand::SetColorInterpretation( GDALColorInterp eInterpIn )
{
PamInitialize();
if( psPam )
{
psPam->poParentDS->MarkPamDirty();
psPam->eColorInterp = eInterpIn;
return CE_None;
}
else
return GDALRasterBand::SetColorInterpretation( eInterpIn );
}
CPLErr GDALPamDataset::SetGeoTransform( double * padfTransform )
{
PamInitialize();
if( psPam )
{
MarkPamDirty();
psPam->bHaveGeoTransform = TRUE;
memcpy( psPam->adfGeoTransform, padfTransform, sizeof(double) * 6 );
return( CE_None );
}
else
{
return GDALDataset::SetGeoTransform( padfTransform );
}
}
CPLErr GDALPamRasterBand::SetDefaultRAT( const GDALRasterAttributeTable *poRAT)
{
PamInitialize();
if( psPam == NULL )
return GDALRasterBand::SetDefaultRAT( poRAT );
psPam->poParentDS->MarkPamDirty();
if( psPam->poDefaultRAT != NULL )
{
delete psPam->poDefaultRAT;
psPam->poDefaultRAT = NULL;
}
if( poRAT == NULL )
psPam->poDefaultRAT = NULL;
else
psPam->poDefaultRAT = poRAT->Clone();
return CE_None;
}
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;
}
CPLErr GDALPamRasterBand::CloneInfo( GDALRasterBand *poSrcBand,
int nCloneFlags )
{
int bOnlyIfMissing = nCloneFlags & GCIF_ONLY_IF_MISSING;
int bSuccess;
int nSavedMOFlags = GetMOFlags();
PamInitialize();
/* -------------------------------------------------------------------- */
/* Supress NotImplemented error messages - mainly needed if PAM */
/* disabled. */
/* -------------------------------------------------------------------- */
SetMOFlags( nSavedMOFlags | GMO_IGNORE_UNIMPLEMENTED );
/* -------------------------------------------------------------------- */
/* Metadata */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_BAND_METADATA )
{
if( poSrcBand->GetMetadata() != NULL )
{
if( !bOnlyIfMissing
|| CSLCount(GetMetadata()) != CSLCount(poSrcBand->GetMetadata()) )
{
SetMetadata( poSrcBand->GetMetadata() );
}
}
}
/* -------------------------------------------------------------------- */
/* Band description. */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_BAND_DESCRIPTION )
{
if( strlen(poSrcBand->GetDescription()) > 0 )
{
if( !bOnlyIfMissing || strlen(GetDescription()) == 0 )
GDALPamRasterBand::SetDescription( poSrcBand->GetDescription());
}
}
/* -------------------------------------------------------------------- */
/* NODATA */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_NODATA )
{
double dfNoData = poSrcBand->GetNoDataValue( &bSuccess );
if( bSuccess )
{
if( !bOnlyIfMissing
|| GetNoDataValue( &bSuccess ) != dfNoData
|| !bSuccess )
GDALPamRasterBand::SetNoDataValue( dfNoData );
}
}
/* -------------------------------------------------------------------- */
/* Offset/scale */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_SCALEOFFSET )
{
double dfOffset = poSrcBand->GetOffset( &bSuccess );
if( bSuccess )
{
if( !bOnlyIfMissing || GetOffset() != dfOffset )
GDALPamRasterBand::SetOffset( dfOffset );
}
double dfScale = poSrcBand->GetScale( &bSuccess );
if( bSuccess )
{
if( !bOnlyIfMissing || GetScale() != dfScale )
GDALPamRasterBand::SetScale( dfScale );
}
}
/* -------------------------------------------------------------------- */
/* Unittype. */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_UNITTYPE )
{
if( strlen(poSrcBand->GetUnitType()) > 0 )
{
if( !bOnlyIfMissing
|| !EQUAL(GetUnitType(),poSrcBand->GetUnitType()) )
{
GDALPamRasterBand::SetUnitType( poSrcBand->GetUnitType() );
}
}
}
/* -------------------------------------------------------------------- */
/* ColorInterp */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_COLORINTERP )
{
if( poSrcBand->GetColorInterpretation() != GCI_Undefined )
{
if( !bOnlyIfMissing
|| poSrcBand->GetColorInterpretation()
!= GetColorInterpretation() )
GDALPamRasterBand::SetColorInterpretation(
poSrcBand->GetColorInterpretation() );
}
}
/* -------------------------------------------------------------------- */
/* color table. */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_COLORTABLE )
{
if( poSrcBand->GetColorTable() != NULL )
{
if( !bOnlyIfMissing || GetColorTable() == NULL )
{
GDALPamRasterBand::SetColorTable(
poSrcBand->GetColorTable() );
}
}
}
/* -------------------------------------------------------------------- */
/* Raster Attribute Table. */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_RAT )
{
const GDALRasterAttributeTable *poRAT = poSrcBand->GetDefaultRAT();
if( poRAT != NULL )
{
if( !bOnlyIfMissing || GetDefaultRAT() == NULL )
{
GDALPamRasterBand::SetDefaultRAT( poRAT );
}
}
}
/* -------------------------------------------------------------------- */
/* Restore MO flags. */
/* -------------------------------------------------------------------- */
SetMOFlags( nSavedMOFlags );
return CE_None;
}
CPLErr GDALPamRasterBand::XMLInit( CPLXMLNode *psTree, const char *pszUnused )
{
PamInitialize();
/* -------------------------------------------------------------------- */
/* Apply any dataset level metadata. */
/* -------------------------------------------------------------------- */
oMDMD.XMLInit( psTree, TRUE );
/* -------------------------------------------------------------------- */
/* Collect various other items of metadata. */
/* -------------------------------------------------------------------- */
GDALMajorObject::SetDescription( CPLGetXMLValue( psTree, "Description", "" ) );
if( CPLGetXMLValue( psTree, "NoDataValue", NULL ) != NULL )
{
const char *pszLEHex =
CPLGetXMLValue( psTree, "NoDataValue.le_hex_equiv", NULL );
if( pszLEHex != NULL )
{
int nBytes;
GByte *pabyBin = CPLHexToBinary( pszLEHex, &nBytes );
if( nBytes == 8 )
{
CPL_LSBPTR64( pabyBin );
GDALPamRasterBand::SetNoDataValue( *((double *) pabyBin) );
}
else
{
GDALPamRasterBand::SetNoDataValue(
atof(CPLGetXMLValue( psTree, "NoDataValue", "0" )) );
}
CPLFree( pabyBin );
}
else
{
GDALPamRasterBand::SetNoDataValue(
atof(CPLGetXMLValue( psTree, "NoDataValue", "0" )) );
}
}
GDALPamRasterBand::SetOffset(
atof(CPLGetXMLValue( psTree, "Offset", "0.0" )) );
GDALPamRasterBand::SetScale(
atof(CPLGetXMLValue( psTree, "Scale", "1.0" )) );
GDALPamRasterBand::SetUnitType( CPLGetXMLValue( psTree, "UnitType", NULL));
if( CPLGetXMLValue( psTree, "ColorInterp", NULL ) != NULL )
{
const char *pszInterp = CPLGetXMLValue( psTree, "ColorInterp", NULL );
GDALPamRasterBand::SetColorInterpretation(
GDALGetColorInterpretationByName(pszInterp));
}
/* -------------------------------------------------------------------- */
/* Category names. */
/* -------------------------------------------------------------------- */
if( CPLGetXMLNode( psTree, "CategoryNames" ) != NULL )
{
CPLXMLNode *psEntry;
char **papszCategoryNames = NULL;
for( psEntry = CPLGetXMLNode( psTree, "CategoryNames" )->psChild;
psEntry != NULL; psEntry = psEntry->psNext )
{
/* Don't skeep <Category> tag with empty content */
if( psEntry->eType != CXT_Element
|| !EQUAL(psEntry->pszValue,"Category")
|| (psEntry->psChild != NULL && psEntry->psChild->eType != CXT_Text) )
continue;
papszCategoryNames = CSLAddString( papszCategoryNames,
(psEntry->psChild) ? psEntry->psChild->pszValue : "" );
}
GDALPamRasterBand::SetCategoryNames( papszCategoryNames );
}
/* -------------------------------------------------------------------- */
/* Collect a color table. */
/* -------------------------------------------------------------------- */
if( CPLGetXMLNode( psTree, "ColorTable" ) != NULL )
{
CPLXMLNode *psEntry;
GDALColorTable oTable;
int iEntry = 0;
for( psEntry = CPLGetXMLNode( psTree, "ColorTable" )->psChild;
psEntry != NULL; psEntry = psEntry->psNext )
{
GDALColorEntry sCEntry;
sCEntry.c1 = (short) atoi(CPLGetXMLValue( psEntry, "c1", "0" ));
sCEntry.c2 = (short) atoi(CPLGetXMLValue( psEntry, "c2", "0" ));
sCEntry.c3 = (short) atoi(CPLGetXMLValue( psEntry, "c3", "0" ));
sCEntry.c4 = (short) atoi(CPLGetXMLValue( psEntry, "c4", "255" ));
oTable.SetColorEntry( iEntry++, &sCEntry );
}
GDALPamRasterBand::SetColorTable( &oTable );
}
/* -------------------------------------------------------------------- */
/* Do we have a complete set of stats? */
/* -------------------------------------------------------------------- */
if( CPLGetXMLNode( psTree, "Minimum" ) != NULL
&& CPLGetXMLNode( psTree, "Maximum" ) != NULL )
{
psPam->bHaveMinMax = TRUE;
psPam->dfMin = atof(CPLGetXMLValue(psTree, "Minimum","0"));
psPam->dfMax = atof(CPLGetXMLValue(psTree, "Maximum","0"));
}
if( CPLGetXMLNode( psTree, "Mean" ) != NULL
&& CPLGetXMLNode( psTree, "StandardDeviation" ) != NULL )
{
psPam->bHaveStats = TRUE;
psPam->dfMean = atof(CPLGetXMLValue(psTree, "Mean","0"));
psPam->dfStdDev = atof(CPLGetXMLValue(psTree,"StandardDeviation","0"));
}
/* -------------------------------------------------------------------- */
/* Histograms */
/* -------------------------------------------------------------------- */
CPLXMLNode *psHist = CPLGetXMLNode( psTree, "Histograms" );
if( psHist != NULL )
{
CPLXMLNode *psNext = psHist->psNext;
psHist->psNext = NULL;
psPam->psSavedHistograms = CPLCloneXMLTree( psHist );
psHist->psNext = psNext;
}
/* -------------------------------------------------------------------- */
/* Raster Attribute Table */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRAT = CPLGetXMLNode( psTree, "GDALRasterAttributeTable" );
if( psRAT != NULL )
{
psPam->poDefaultRAT = new GDALRasterAttributeTable();
psPam->poDefaultRAT->XMLInit( psRAT, "" );
}
return CE_None;
}
CPLErr GDALPamDataset::CloneInfo( GDALDataset *poSrcDS, int nCloneFlags )
{
int bOnlyIfMissing = nCloneFlags & GCIF_ONLY_IF_MISSING;
int nSavedMOFlags = GetMOFlags();
PamInitialize();
/* -------------------------------------------------------------------- */
/* Supress NotImplemented error messages - mainly needed if PAM */
/* disabled. */
/* -------------------------------------------------------------------- */
SetMOFlags( nSavedMOFlags | GMO_IGNORE_UNIMPLEMENTED );
/* -------------------------------------------------------------------- */
/* GeoTransform */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_GEOTRANSFORM )
{
double adfGeoTransform[6];
if( poSrcDS->GetGeoTransform( adfGeoTransform ) == CE_None )
{
double adfOldGT[6];
if( !bOnlyIfMissing || GetGeoTransform( adfOldGT ) != CE_None )
SetGeoTransform( adfGeoTransform );
}
}
/* -------------------------------------------------------------------- */
/* Projection */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_PROJECTION )
{
const char *pszWKT = poSrcDS->GetProjectionRef();
if( pszWKT != NULL && strlen(pszWKT) > 0 )
{
if( !bOnlyIfMissing
|| GetProjectionRef() == NULL
|| strlen(GetProjectionRef()) == 0 )
SetProjection( pszWKT );
}
}
/* -------------------------------------------------------------------- */
/* GCPs */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_GCPS )
{
if( poSrcDS->GetGCPCount() > 0 )
{
if( !bOnlyIfMissing || GetGCPCount() == 0 )
{
SetGCPs( poSrcDS->GetGCPCount(),
poSrcDS->GetGCPs(),
poSrcDS->GetGCPProjection() );
}
}
}
/* -------------------------------------------------------------------- */
/* Metadata */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_METADATA )
{
if( poSrcDS->GetMetadata() != NULL )
{
if( !bOnlyIfMissing
|| CSLCount(GetMetadata()) != CSLCount(poSrcDS->GetMetadata()) )
{
SetMetadata( poSrcDS->GetMetadata() );
}
}
if( poSrcDS->GetMetadata("RPC") != NULL )
{
if( !bOnlyIfMissing
|| CSLCount(GetMetadata("RPC"))
!= CSLCount(poSrcDS->GetMetadata("RPC")) )
{
SetMetadata( poSrcDS->GetMetadata("RPC"), "RPC" );
}
}
}
/* -------------------------------------------------------------------- */
/* Process bands. */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_PROCESS_BANDS )
{
int iBand;
for( iBand = 0; iBand < GetRasterCount(); iBand++ )
{
GDALPamRasterBand *poBand = (GDALPamRasterBand *)
GetRasterBand(iBand+1);
if( poBand == NULL || !(poBand->GetMOFlags() & GMO_PAM_CLASS) )
continue;
if( poSrcDS->GetRasterCount() >= iBand+1 )
poBand->CloneInfo( poSrcDS->GetRasterBand(iBand+1),
nCloneFlags );
else
CPLDebug( "GDALPamDataset", "Skipping CloneInfo for band not in source, this is a bit unusual!" );
}
}
/* -------------------------------------------------------------------- */
/* Copy masks. These are really copied at a lower level using */
/* GDALDefaultOverviews, for formats with no native mask */
/* support but this is a convenient central point to put this */
/* for most drivers. */
/* -------------------------------------------------------------------- */
if( nCloneFlags & GCIF_MASK )
{
GDALDriver::DefaultCopyMasks( poSrcDS, this, FALSE );
}
/* -------------------------------------------------------------------- */
/* Restore MO flags. */
/* -------------------------------------------------------------------- */
SetMOFlags( nSavedMOFlags );
return CE_None;
}
CPLErr GDALPamRasterBand::GetHistogram( double dfMin, double dfMax,
int nBuckets, int * panHistogram,
int bIncludeOutOfRange, int bApproxOK,
GDALProgressFunc pfnProgress,
void *pProgressData )
{
PamInitialize();
if( psPam == NULL )
return GDALRasterBand::GetHistogram( dfMin, dfMax,
nBuckets, panHistogram,
bIncludeOutOfRange, bApproxOK,
pfnProgress, pProgressData );
/* -------------------------------------------------------------------- */
/* Check if we have a matching histogram. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psHistItem;
psHistItem = PamFindMatchingHistogram( psPam->psSavedHistograms,
dfMin, dfMax, nBuckets,
bIncludeOutOfRange, bApproxOK );
if( psHistItem != NULL )
{
int *panTempHist = NULL;
if( PamParseHistogram( psHistItem, &dfMin, &dfMax, &nBuckets,
&panTempHist,
&bIncludeOutOfRange, &bApproxOK ) )
{
memcpy( panHistogram, panTempHist, sizeof(int) * nBuckets );
CPLFree( panTempHist );
return CE_None;
}
}
/* -------------------------------------------------------------------- */
/* We don't have an existing histogram matching the request, so */
/* generate one manually. */
/* -------------------------------------------------------------------- */
CPLErr eErr;
eErr = GDALRasterBand::GetHistogram( dfMin, dfMax,
nBuckets, panHistogram,
bIncludeOutOfRange, bApproxOK,
pfnProgress, pProgressData );
/* -------------------------------------------------------------------- */
/* Save an XML description of this histogram. */
/* -------------------------------------------------------------------- */
if( eErr == CE_None )
{
CPLXMLNode *psXMLHist;
psXMLHist = PamHistogramToXMLTree( dfMin, dfMax, nBuckets,
panHistogram,
bIncludeOutOfRange, bApproxOK );
if( psXMLHist != NULL )
{
psPam->poParentDS->MarkPamDirty();
if( psPam->psSavedHistograms == NULL )
psPam->psSavedHistograms = CPLCreateXMLNode( NULL, CXT_Element,
"Histograms" );
CPLAddXMLChild( psPam->psSavedHistograms, psXMLHist );
}
}
return eErr;
}
CPLErr GDALPamDataset::TryLoadXML()
{
CPLXMLNode *psTree = NULL;
PamInitialize();
/* -------------------------------------------------------------------- */
/* Clear dirty flag. Generally when we get to this point is */
/* from a call at the end of the Open() method, and some calls */
/* may have already marked the PAM info as dirty (for instance */
/* setting metadata), but really everything to this point is */
/* reproducable, and so the PAM info shouldn't really be */
/* thought of as dirty. */
/* -------------------------------------------------------------------- */
nPamFlags &= ~GPF_DIRTY;
/* -------------------------------------------------------------------- */
/* Try reading the file. */
/* -------------------------------------------------------------------- */
if( !BuildPamFilename() )
return CE_None;
VSIStatBufL sStatBuf;
if( VSIStatL( psPam->pszPamFilename, &sStatBuf ) == 0
&& VSI_ISREG( sStatBuf.st_mode ) )
{
CPLErrorReset();
CPLPushErrorHandler( CPLQuietErrorHandler );
psTree = CPLParseXMLFile( psPam->pszPamFilename );
CPLPopErrorHandler();
}
/* -------------------------------------------------------------------- */
/* If we are looking for a subdataset, search for it's subtree */
/* now. */
/* -------------------------------------------------------------------- */
if( psTree && psPam->osSubdatasetName.size() )
{
CPLXMLNode *psSubTree;
for( psSubTree = psTree->psChild;
psSubTree != NULL;
psSubTree = psSubTree->psNext )
{
if( psSubTree->eType != CXT_Element
|| !EQUAL(psSubTree->pszValue,"Subdataset") )
continue;
if( !EQUAL(CPLGetXMLValue( psSubTree, "name", "" ),
psPam->osSubdatasetName) )
continue;
psSubTree = CPLGetXMLNode( psSubTree, "PAMDataset" );
break;
}
if( psSubTree != NULL )
psSubTree = CPLCloneXMLTree( psSubTree );
CPLDestroyXMLNode( psTree );
psTree = psSubTree;
}
/* -------------------------------------------------------------------- */
/* If we fail, try .aux. */
/* -------------------------------------------------------------------- */
if( psTree == NULL )
return TryLoadAux();
/* -------------------------------------------------------------------- */
/* Initialize ourselves from this XML tree. */
/* -------------------------------------------------------------------- */
CPLErr eErr;
CPLString osVRTPath(CPLGetPath(psPam->pszPamFilename));
eErr = XMLInit( psTree, osVRTPath );
CPLDestroyXMLNode( psTree );
if( eErr != CE_None )
PamClear();
return eErr;
}
