static void CorrectURLs( CPLXMLNode * psRoot, const char *pszURL )
{
if( psRoot == NULL || pszURL == NULL )
return;
if( pszURL[0] == '\0' )
return;
CPLXMLNode *psChild = psRoot->psChild;
// check for xlink:href attribute
while( psChild != NULL && !( ( psChild->eType == CXT_Attribute ) &&
( EQUAL(psChild->pszValue, "xlink:href") )) )
psChild = psChild->psNext;
if( psChild != NULL &&
!( strstr( psChild->psChild->pszValue, pszURL ) == psChild->psChild->pszValue
&& psChild->psChild->pszValue[strlen(pszURL)] == '#' ) )
{
// href has a different url.
if( psChild->psChild->pszValue[0] == '#' )
{
//empty URL: prepend the given URL
const size_t nLen =
CPLStrnlen( pszURL, 1024 ) +
CPLStrnlen( psChild->psChild->pszValue, 1024 ) + 1;
char *pszNew = (char *)CPLMalloc( nLen * sizeof(char));
CPLStrlcpy( pszNew, pszURL, nLen );
CPLStrlcat( pszNew, psChild->psChild->pszValue, nLen );
CPLSetXMLValue( psRoot, "#xlink:href", pszNew );
CPLFree( pszNew );
}
else
{
size_t nPathLen = strlen(pszURL); // Used after for.
for( ;
nPathLen > 0 &&
pszURL[nPathLen - 1] != '/' &&
pszURL[nPathLen - 1] != '\\';
nPathLen-- );
const char* pszDash = strchr( psChild->psChild->pszValue, '#' );
if( pszDash != NULL &&
strncmp( pszURL, psChild->psChild->pszValue, nPathLen ) != 0 )
{
//different path
int nURLLen = static_cast<int>(pszDash - psChild->psChild->pszValue);
char *pszURLWithoutID = (char *)CPLMalloc( (nURLLen+1) * sizeof(char));
strncpy( pszURLWithoutID, psChild->psChild->pszValue, nURLLen );
pszURLWithoutID[nURLLen] = '\0';
if( CPLIsFilenameRelative( pszURLWithoutID ) &&
strstr( pszURLWithoutID, ":" ) == NULL )
{
//relative URL: prepend the path of pszURL
const size_t nLen =
nPathLen +
CPLStrnlen( psChild->psChild->pszValue, 1024 ) + 1;
char *pszNew = (char *)CPLMalloc( nLen * sizeof(char));
for( size_t i = 0; i < nPathLen; i++ )
pszNew[i] = pszURL[i];
pszNew[nPathLen] = '\0';
CPLStrlcat( pszNew, psChild->psChild->pszValue, nLen );
CPLSetXMLValue( psRoot, "#xlink:href", pszNew );
CPLFree( pszNew );
}
CPLFree( pszURLWithoutID );
}
}
}
// search the child elements of psRoot
for( psChild = psRoot->psChild; psChild != NULL; psChild = psChild->psNext)
if( psChild->eType == CXT_Element )
CorrectURLs( psChild, pszURL );
}
CPLXMLNode *GDALMultiDomainMetadata::Serialize()
{
CPLXMLNode *psFirst = NULL;
for( int iDomain = 0;
papszDomainList != NULL && papszDomainList[iDomain] != NULL;
iDomain++)
{
char **papszMD = papoMetadataLists[iDomain]->List();
// Do not serialize empty domains
if( papszMD == NULL || papszMD[0] == NULL )
continue;
CPLXMLNode *psMD;
bool bFormatXML = false;
psMD = CPLCreateXMLNode( NULL, CXT_Element, "Metadata" );
if( strlen( papszDomainList[iDomain] ) > 0 )
CPLCreateXMLNode(
CPLCreateXMLNode( psMD, CXT_Attribute, "domain" ),
CXT_Text, papszDomainList[iDomain] );
if( EQUALN(papszDomainList[iDomain],"xml:",4)
&& CSLCount(papszMD) == 1 )
{
CPLXMLNode *psValueAsXML = CPLParseXMLString( papszMD[0] );
if( psValueAsXML != NULL )
{
bFormatXML = true;
CPLCreateXMLNode(
CPLCreateXMLNode( psMD, CXT_Attribute, "format" ),
CXT_Text, "xml" );
CPLAddXMLChild( psMD, psValueAsXML );
}
}
if( !bFormatXML )
{
CPLXMLNode* psLastChild = NULL;
// To go after domain attribute
if( psMD->psChild != NULL )
{
psLastChild = psMD->psChild;
while( psLastChild->psNext != NULL )
psLastChild = psLastChild->psNext;
}
for( int i = 0; papszMD != NULL && papszMD[i] != NULL; i++ )
{
const char *pszRawValue;
char *pszKey = NULL;
CPLXMLNode *psMDI;
pszRawValue = CPLParseNameValue( papszMD[i], &pszKey );
psMDI = CPLCreateXMLNode( NULL, CXT_Element, "MDI" );
if( psLastChild == NULL )
psMD->psChild = psMDI;
else
psLastChild->psNext = psMDI;
psLastChild = psMDI;
CPLSetXMLValue( psMDI, "#key", pszKey );
CPLCreateXMLNode( psMDI, CXT_Text, pszRawValue );
CPLFree( pszKey );
}
}
if( psFirst == NULL )
psFirst = psMD;
else
CPLAddXMLSibling( psFirst, psMD );
}
return psFirst;
}
void NASHandler::endElement( const XMLCh* const /* uri */ ,
const XMLCh* const localname,
const XMLCh* const /* qname */)
{
GMLReadState *poState = m_poReader->GetState();
transcode( localname, m_osElementName );
m_nDepth --;
if (m_bIgnoreFeature && m_nDepth >= m_nDepthFeature)
{
if (m_nDepth == m_nDepthFeature)
{
m_bIgnoreFeature = false;
m_nDepthFeature = 0;
}
return;
}
if ( m_osIgnoredElement != "" && m_nDepth >= m_nDepthElement )
{
if ( m_nDepth == m_nDepthElement )
{
m_osIgnoredElement = "";
m_nDepthElement = 0;
}
return;
}
#ifdef DEBUG_VERBOSE
CPLDebug("NAS",
"%*sendElement %s m_bIgnoreFeature:%d depth:%d depthFeature:%d featureClass:%s",
m_nDepth, "", m_osElementName.c_str(),
m_bIgnoreFeature, m_nDepth, m_nDepthFeature,
poState->m_poFeature ? poState->m_poFeature->GetClass()->GetElementName() : "(no feature)"
);
#endif
if( m_bInUpdateProperty )
{
if( m_osElementName == "Name" && m_nDepth == m_nNameOrValueDepth )
{
CPLAssert( m_osLastPropertyName == "" );
m_osLastPropertyName = m_pszCurField;
m_pszCurField = NULL;
m_nNameOrValueDepth = 0;
}
else if( m_osElementName == "Value" && m_nDepth == m_nNameOrValueDepth )
{
CPLAssert( m_osLastPropertyValue == "" );
m_osLastPropertyValue = m_pszCurField;
m_pszCurField = NULL;
m_nNameOrValueDepth = 0;
}
else if( m_nDepth == m_nUpdatePropertyDepth && m_osElementName == "Property" )
{
if( EQUAL( m_osLastPropertyName, "adv:lebenszeitintervall/adv:AA_Lebenszeitintervall/adv:endet" ) )
{
CPLAssert( m_osLastPropertyValue != "" );
m_osLastEnded = m_osLastPropertyValue;
}
else if( EQUAL( m_osLastPropertyName, "adv:anlass" ) )
{
CPLAssert( m_osLastPropertyValue != "" );
m_LastOccasions.push_back( m_osLastPropertyValue );
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"NAS: Expected property name or value instead of %s",
m_osLastPropertyName.c_str() );
}
m_osLastPropertyName = "";
m_osLastPropertyValue = "";
m_bInUpdateProperty = false;
m_nUpdatePropertyDepth = 0;
}
poState->PopPath();
return;
}
if( m_nUpdateOrDeleteDepth > 0 &&
(m_osElementName == "Delete" || m_osElementName == "Update") )
{
if ( m_bInUpdate && m_osElementName == "Update" )
{
m_bInUpdate = false;
}
m_nUpdateOrDeleteDepth = 0;
}
/* -------------------------------------------------------------------- */
/* Is this closing off an attribute value? We assume so if */
/* we are collecting an attribute value and got to this point. */
/* We don't bother validating that the closing tag matches the */
/* opening tag. */
/* -------------------------------------------------------------------- */
if( m_pszCurField != NULL )
{
CPLAssert( poState->m_poFeature != NULL );
m_poReader->SetFeaturePropertyDirectly( poState->osPath.c_str(), m_pszCurField );
m_pszCurField = NULL;
}
/* -------------------------------------------------------------------- */
/* If we are collecting Geometry than store it, and consider if */
/* this is the end of the geometry. */
/* -------------------------------------------------------------------- */
if( m_pszGeometry != NULL )
{
int nLNLen = static_cast<int>(m_osElementName.size());
/* should save attributes too! */
if( m_nGeomLen + nLNLen + 4 > m_nGeomAlloc )
{
m_nGeomAlloc = (int) (m_nGeomAlloc * 1.3 + nLNLen + 1000);
m_pszGeometry = (char *)
CPLRealloc( m_pszGeometry, m_nGeomAlloc);
}
strcat( m_pszGeometry+m_nGeomLen, "</" );
strcpy( m_pszGeometry+m_nGeomLen+2, m_osElementName );
strcat( m_pszGeometry+m_nGeomLen+nLNLen+2, ">" );
m_nGeomLen += static_cast<int>(strlen(m_pszGeometry+m_nGeomLen));
if( poState->m_nPathLength == m_nGeometryDepth+1 )
{
if( poState->m_poFeature != NULL )
{
CPLXMLNode* psNode = CPLParseXMLString(m_pszGeometry);
if (psNode)
{
/* workaround for common malformed gml:pos with just a
* elevation value instead of a full 3D coordinate:
*
* <gml:Point gml:id="BII2H">
* <gml:pos srsName="urn:adv:crs:ETRS89_h">41.394</gml:pos>
* </gml:Point>
*
*/
const char *pszPos =
CPLGetXMLValue( psNode, "=Point.pos", NULL );
if( pszPos != NULL && strstr(pszPos, " ") == NULL )
{
CPLSetXMLValue( psNode, "pos", CPLSPrintf("0 0 %s", pszPos) );
}
if ( poState->m_poFeature->GetGeometryList() &&
poState->m_poFeature->GetGeometryList()[0] )
{
int iId = poState->m_poFeature->GetClass()->GetPropertyIndex( "gml_id" );
const GMLProperty *poIdProp = poState->m_poFeature->GetProperty(iId);
#ifdef DEBUG_VERBOSE
char *pszOldGeom = CPLSerializeXMLTree( poState->m_poFeature->GetGeometryList()[0] );
CPLDebug("NAS", "Overwriting other geometry (%s; replace:%s; with:%s)",
poIdProp && poIdProp->nSubProperties>0 && poIdProp->papszSubProperties[0] ? poIdProp->papszSubProperties[0] : "(null)",
m_pszGeometry,
pszOldGeom
);
CPLFree( pszOldGeom );
#else
CPLError( CE_Warning, CPLE_AppDefined, "NAS: Overwriting other geometry (%s)",
poIdProp && poIdProp->nSubProperties>0 && poIdProp->papszSubProperties[0] ? poIdProp->papszSubProperties[0] : "(null)" );
#endif
}
poState->m_poFeature->SetGeometryDirectly( psNode );
}
else
CPLError( CE_Warning, CPLE_AppDefined, "NAS: Invalid geometry skipped" );
}
else
CPLError( CE_Warning, CPLE_AppDefined, "NAS: Skipping geometry without feature" );
CPLFree( m_pszGeometry );
m_pszGeometry = NULL;
m_nGeomAlloc = m_nGeomLen = 0;
}
}
/* -------------------------------------------------------------------- */
/* If we are collecting a feature, and this element tag matches */
/* element name for the class, then we have finished the */
/* feature, and we pop the feature read state. */
/* -------------------------------------------------------------------- */
const char *pszLast = NULL;
if( m_nDepth == m_nDepthFeature && poState->m_poFeature != NULL
&& m_osElementName ==
poState->m_poFeature->GetClass()->GetElementName() )
{
m_nDepthFeature = 0;
m_poReader->PopState();
}
/* -------------------------------------------------------------------- */
/* Ends of a wfs:Delete or wfs:Update should be triggered on the */
/* close of the <Filter> element. */
/* -------------------------------------------------------------------- */
else if( m_nDepth == m_nDepthFeature
&& poState->m_poFeature != NULL
&& m_osElementName == "Filter"
&& (pszLast=poState->m_poFeature->GetClass()->GetElementName())
!= NULL
&& ( EQUAL(pszLast, "Delete") || EQUAL(pszLast, "Update") ) )
{
m_nDepthFeature = 0;
m_poReader->PopState();
}
/* -------------------------------------------------------------------- */
/* Otherwise, we just pop the element off the local read states */
/* element stack. */
/* -------------------------------------------------------------------- */
else
{
if( m_osElementName == poState->GetLastComponent() )
poState->PopPath();
else
{
CPLAssert( false );
}
}
}
CPLXMLNode *GDALSerializeRPCTransformer( void *pTransformArg )
{
VALIDATE_POINTER1( pTransformArg, "GDALSerializeRPCTransformer", NULL );
CPLXMLNode *psTree;
GDALRPCTransformInfo *psInfo =
(GDALRPCTransformInfo *)(pTransformArg);
psTree = CPLCreateXMLNode( NULL, CXT_Element, "RPCTransformer" );
/* -------------------------------------------------------------------- */
/* Serialize bReversed. */
/* -------------------------------------------------------------------- */
CPLCreateXMLElementAndValue(
psTree, "Reversed",
CPLString().Printf( "%d", psInfo->bReversed ) );
/* -------------------------------------------------------------------- */
/* Serialize Height Offset. */
/* -------------------------------------------------------------------- */
CPLCreateXMLElementAndValue(
psTree, "HeightOffset",
CPLString().Printf( "%.15g", psInfo->dfHeightOffset ) );
/* -------------------------------------------------------------------- */
/* Serialize Height Scale. */
/* -------------------------------------------------------------------- */
if (psInfo->dfHeightScale != 1.0)
CPLCreateXMLElementAndValue(
psTree, "HeightScale",
CPLString().Printf( "%.15g", psInfo->dfHeightScale ) );
/* -------------------------------------------------------------------- */
/* Serialize DEM path. */
/* -------------------------------------------------------------------- */
if (psInfo->pszDEMPath != NULL)
CPLCreateXMLElementAndValue(
psTree, "DEMPath",
CPLString().Printf( "%s", psInfo->pszDEMPath ) );
/* -------------------------------------------------------------------- */
/* Serialize DEM interpolation */
/* -------------------------------------------------------------------- */
CPLString soDEMInterpolation;
switch(psInfo->eResampleAlg)
{
case DRA_NearestNeighbour:
soDEMInterpolation = "near";
break;
case DRA_Cubic:
soDEMInterpolation = "cubic";
break;
default:
case DRA_Bilinear:
soDEMInterpolation = "bilinear";
}
CPLCreateXMLElementAndValue(
psTree, "DEMInterpolation", soDEMInterpolation );
/* -------------------------------------------------------------------- */
/* Serialize pixel error threshold. */
/* -------------------------------------------------------------------- */
CPLCreateXMLElementAndValue(
psTree, "PixErrThreshold",
CPLString().Printf( "%.15g", psInfo->dfPixErrThreshold ) );
/* -------------------------------------------------------------------- */
/* RPC metadata. */
/* -------------------------------------------------------------------- */
char **papszMD = RPCInfoToMD( &(psInfo->sRPC) );
CPLXMLNode *psMD= CPLCreateXMLNode( psTree, CXT_Element,
"Metadata" );
for( int i = 0; papszMD != NULL && papszMD[i] != NULL; i++ )
{
const char *pszRawValue;
char *pszKey;
CPLXMLNode *psMDI;
pszRawValue = CPLParseNameValue( papszMD[i], &pszKey );
psMDI = CPLCreateXMLNode( psMD, CXT_Element, "MDI" );
CPLSetXMLValue( psMDI, "#key", pszKey );
CPLCreateXMLNode( psMDI, CXT_Text, pszRawValue );
CPLFree( pszKey );
}
CSLDestroy( papszMD );
return psTree;
}
CPLXMLNode *GDALPamRasterBand::SerializeToXML( const char *pszUnused )
{
if( psPam == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Setup root node and attributes. */
/* -------------------------------------------------------------------- */
CPLString oFmt;
CPLXMLNode *psTree;
psTree = CPLCreateXMLNode( NULL, CXT_Element, "PAMRasterBand" );
if( GetBand() > 0 )
CPLSetXMLValue( psTree, "#band", oFmt.Printf( "%d", GetBand() ) );
/* -------------------------------------------------------------------- */
/* Serialize information of interest. */
/* -------------------------------------------------------------------- */
if( strlen(GetDescription()) > 0 )
CPLSetXMLValue( psTree, "Description", GetDescription() );
if( psPam->bNoDataValueSet )
{
if (CPLIsNan(psPam->dfNoDataValue))
CPLSetXMLValue( psTree, "NoDataValue", "nan" );
else
CPLSetXMLValue( psTree, "NoDataValue",
oFmt.Printf( "%.14E", psPam->dfNoDataValue ) );
/* hex encode real floating point values */
if( psPam->dfNoDataValue != floor(psPam->dfNoDataValue)
|| psPam->dfNoDataValue != atof(oFmt) )
{
double dfNoDataLittleEndian;
dfNoDataLittleEndian = psPam->dfNoDataValue;
CPL_LSBPTR64( &dfNoDataLittleEndian );
char *pszHexEncoding =
CPLBinaryToHex( 8, (GByte *) &dfNoDataLittleEndian );
CPLSetXMLValue( psTree, "NoDataValue.#le_hex_equiv",pszHexEncoding);
CPLFree( pszHexEncoding );
}
}
if( psPam->pszUnitType != NULL )
CPLSetXMLValue( psTree, "UnitType", psPam->pszUnitType );
if( psPam->dfOffset != 0.0 )
CPLSetXMLValue( psTree, "Offset",
oFmt.Printf( "%.16g", psPam->dfOffset ) );
if( psPam->dfScale != 1.0 )
CPLSetXMLValue( psTree, "Scale",
oFmt.Printf( "%.16g", psPam->dfScale ) );
if( psPam->eColorInterp != GCI_Undefined )
CPLSetXMLValue( psTree, "ColorInterp",
GDALGetColorInterpretationName( psPam->eColorInterp ));
/* -------------------------------------------------------------------- */
/* Category names. */
/* -------------------------------------------------------------------- */
if( psPam->papszCategoryNames != NULL )
{
CPLXMLNode *psCT_XML = CPLCreateXMLNode( psTree, CXT_Element,
"CategoryNames" );
CPLXMLNode* psLastChild = NULL;
for( int iEntry=0; psPam->papszCategoryNames[iEntry] != NULL; iEntry++)
{
CPLXMLNode *psNode = CPLCreateXMLElementAndValue( NULL, "Category",
psPam->papszCategoryNames[iEntry] );
if( psLastChild == NULL )
psCT_XML->psChild = psNode;
else
psLastChild->psNext = psNode;
psLastChild = psNode;
}
}
/* -------------------------------------------------------------------- */
/* Color Table. */
/* -------------------------------------------------------------------- */
if( psPam->poColorTable != NULL )
{
CPLXMLNode *psCT_XML = CPLCreateXMLNode( psTree, CXT_Element,
"ColorTable" );
CPLXMLNode* psLastChild = NULL;
for( int iEntry=0; iEntry < psPam->poColorTable->GetColorEntryCount();
iEntry++ )
{
GDALColorEntry sEntry;
CPLXMLNode *psEntry_XML = CPLCreateXMLNode( NULL, CXT_Element,
"Entry" );
if( psLastChild == NULL )
psCT_XML->psChild = psEntry_XML;
else
psLastChild->psNext = psEntry_XML;
psLastChild = psEntry_XML;
psPam->poColorTable->GetColorEntryAsRGB( iEntry, &sEntry );
CPLSetXMLValue( psEntry_XML, "#c1", oFmt.Printf("%d",sEntry.c1) );
CPLSetXMLValue( psEntry_XML, "#c2", oFmt.Printf("%d",sEntry.c2) );
CPLSetXMLValue( psEntry_XML, "#c3", oFmt.Printf("%d",sEntry.c3) );
CPLSetXMLValue( psEntry_XML, "#c4", oFmt.Printf("%d",sEntry.c4) );
}
}
/* -------------------------------------------------------------------- */
/* Min/max. */
/* -------------------------------------------------------------------- */
if( psPam->bHaveMinMax )
{
CPLSetXMLValue( psTree, "Minimum",
oFmt.Printf( "%.16g", psPam->dfMin ) );
CPLSetXMLValue( psTree, "Maximum",
oFmt.Printf( "%.16g", psPam->dfMax ) );
}
/* -------------------------------------------------------------------- */
/* Statistics */
/* -------------------------------------------------------------------- */
if( psPam->bHaveStats )
{
CPLSetXMLValue( psTree, "Mean",
oFmt.Printf( "%.16g", psPam->dfMean ) );
CPLSetXMLValue( psTree, "StandardDeviation",
oFmt.Printf( "%.16g", psPam->dfStdDev ) );
}
/* -------------------------------------------------------------------- */
/* Histograms. */
/* -------------------------------------------------------------------- */
if( psPam->psSavedHistograms != NULL )
CPLAddXMLChild( psTree, CPLCloneXMLTree( psPam->psSavedHistograms ) );
/* -------------------------------------------------------------------- */
/* Raster Attribute Table */
/* -------------------------------------------------------------------- */
if( psPam->poDefaultRAT != NULL )
CPLAddXMLChild( psTree, psPam->poDefaultRAT->Serialize() );
/* -------------------------------------------------------------------- */
/* Metadata. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psMD;
psMD = oMDMD.Serialize();
if( psMD != NULL )
{
if( psMD->psChild == NULL )
CPLDestroyXMLNode( psMD );
else
CPLAddXMLChild( psTree, psMD );
}
/* -------------------------------------------------------------------- */
/* We don't want to return anything if we had no metadata to */
/* attach. */
/* -------------------------------------------------------------------- */
if( psTree->psChild == NULL || psTree->psChild->psNext == NULL )
{
CPLDestroyXMLNode( psTree );
psTree = NULL;
}
return psTree;
}
CPLErr VRTWarpedDataset::XMLInit( CPLXMLNode *psTree, const char *pszVRTPath )
{
CPLErr eErr;
/* -------------------------------------------------------------------- */
/* Initialize blocksize before calling sub-init so that the */
/* band initializers can get it from the dataset object when */
/* they are created. */
/* -------------------------------------------------------------------- */
nBlockXSize = atoi(CPLGetXMLValue(psTree,"BlockXSize","512"));
nBlockYSize = atoi(CPLGetXMLValue(psTree,"BlockYSize","128"));
/* -------------------------------------------------------------------- */
/* Initialize all the general VRT stuff. This will even */
/* create the VRTWarpedRasterBands and initialize them. */
/* -------------------------------------------------------------------- */
eErr = VRTDataset::XMLInit( psTree, pszVRTPath );
if( eErr != CE_None )
return eErr;
/* -------------------------------------------------------------------- */
/* Find the GDALWarpOptions XML tree. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psOptionsTree;
psOptionsTree = CPLGetXMLNode( psTree, "GDALWarpOptions" );
if( psOptionsTree == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Count not find required GDALWarpOptions in XML." );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Adjust the SourceDataset in the warp options to take into */
/* account that it is relative to the VRT if appropriate. */
/* -------------------------------------------------------------------- */
int bRelativeToVRT =
atoi(CPLGetXMLValue(psOptionsTree,
"SourceDataset.relativeToVRT", "0" ));
const char *pszRelativePath = CPLGetXMLValue(psOptionsTree,
"SourceDataset", "" );
char *pszAbsolutePath;
if( bRelativeToVRT )
pszAbsolutePath =
CPLStrdup(CPLProjectRelativeFilename( pszVRTPath,
pszRelativePath ) );
else
pszAbsolutePath = CPLStrdup(pszRelativePath);
CPLSetXMLValue( psOptionsTree, "SourceDataset", pszAbsolutePath );
CPLFree( pszAbsolutePath );
/* -------------------------------------------------------------------- */
/* And instantiate the warp options, and corresponding warp */
/* operation. */
/* -------------------------------------------------------------------- */
GDALWarpOptions *psWO;
psWO = GDALDeserializeWarpOptions( psOptionsTree );
if( psWO == NULL )
return CE_Failure;
this->eAccess = GA_Update;
psWO->hDstDS = this;
/* -------------------------------------------------------------------- */
/* Instantiate the warp operation. */
/* -------------------------------------------------------------------- */
poWarper = new GDALWarpOperation();
eErr = poWarper->Initialize( psWO );
if( eErr != CE_None)
{
/* -------------------------------------------------------------------- */
/* We are responsible for cleaning up the transformer outselves. */
/* -------------------------------------------------------------------- */
if( psWO->pTransformerArg != NULL )
GDALDestroyTransformer( psWO->pTransformerArg );
}
GDALDestroyWarpOptions( psWO );
if( eErr != CE_None )
{
delete poWarper;
poWarper = NULL;
}
/* -------------------------------------------------------------------- */
/* Generate overviews, if appropriate. */
/* -------------------------------------------------------------------- */
char **papszTokens = CSLTokenizeString(
CPLGetXMLValue( psTree, "OverviewList", "" ));
int iOverview;
for( iOverview = 0;
papszTokens != NULL && papszTokens[iOverview] != NULL;
iOverview++ )
{
int nOvFactor = atoi(papszTokens[iOverview]);
if (nOvFactor > 0)
BuildOverviews( "NEAREST", 1, &nOvFactor, 0, NULL, NULL, NULL );
else
CPLError(CE_Failure, CPLE_AppDefined,
"Bad value for overview factor : %s", papszTokens[iOverview]);
}
CSLDestroy( papszTokens );
return eErr;
}
CPLXMLNode *GDALPamDataset::SerializeToXML( const char *pszVRTPath )
{
CPLString oFmt;
if( psPam == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Setup root node and attributes. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psDSTree;
psDSTree = CPLCreateXMLNode( NULL, CXT_Element, "PAMDataset" );
/* -------------------------------------------------------------------- */
/* SRS */
/* -------------------------------------------------------------------- */
if( psPam->pszProjection != NULL && strlen(psPam->pszProjection) > 0 )
CPLSetXMLValue( psDSTree, "SRS", psPam->pszProjection );
/* -------------------------------------------------------------------- */
/* GeoTransform. */
/* -------------------------------------------------------------------- */
if( psPam->bHaveGeoTransform )
{
CPLSetXMLValue( psDSTree, "GeoTransform",
oFmt.Printf( "%24.16e,%24.16e,%24.16e,%24.16e,%24.16e,%24.16e",
psPam->adfGeoTransform[0],
psPam->adfGeoTransform[1],
psPam->adfGeoTransform[2],
psPam->adfGeoTransform[3],
psPam->adfGeoTransform[4],
psPam->adfGeoTransform[5] ) );
}
/* -------------------------------------------------------------------- */
/* Metadata. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psMD;
psMD = oMDMD.Serialize();
if( psMD != NULL )
{
if( psMD->psChild == NULL )
CPLDestroyXMLNode( psMD );
else
CPLAddXMLChild( psDSTree, psMD );
}
/* -------------------------------------------------------------------- */
/* GCPs */
/* -------------------------------------------------------------------- */
if( psPam->nGCPCount > 0 )
{
CPLXMLNode *psPamGCPList = CPLCreateXMLNode( psDSTree, CXT_Element,
"GCPList" );
if( psPam->pszGCPProjection != NULL
&& strlen(psPam->pszGCPProjection) > 0 )
CPLSetXMLValue( psPamGCPList, "#Projection",
psPam->pszGCPProjection );
for( int iGCP = 0; iGCP < psPam->nGCPCount; iGCP++ )
{
CPLXMLNode *psXMLGCP;
GDAL_GCP *psGCP = psPam->pasGCPList + iGCP;
psXMLGCP = CPLCreateXMLNode( psPamGCPList, CXT_Element, "GCP" );
CPLSetXMLValue( psXMLGCP, "#Id", psGCP->pszId );
if( psGCP->pszInfo != NULL && strlen(psGCP->pszInfo) > 0 )
CPLSetXMLValue( psXMLGCP, "Info", psGCP->pszInfo );
CPLSetXMLValue( psXMLGCP, "#Pixel",
oFmt.Printf( "%.4f", psGCP->dfGCPPixel ) );
CPLSetXMLValue( psXMLGCP, "#Line",
oFmt.Printf( "%.4f", psGCP->dfGCPLine ) );
CPLSetXMLValue( psXMLGCP, "#X",
oFmt.Printf( "%.12E", psGCP->dfGCPX ) );
CPLSetXMLValue( psXMLGCP, "#Y",
oFmt.Printf( "%.12E", psGCP->dfGCPY ) );
if( psGCP->dfGCPZ != 0.0 )
CPLSetXMLValue( psXMLGCP, "#GCPZ",
oFmt.Printf( "%.12E", psGCP->dfGCPZ ) );
}
}
/* -------------------------------------------------------------------- */
/* Process bands. */
/* -------------------------------------------------------------------- */
int iBand;
for( iBand = 0; iBand < GetRasterCount(); iBand++ )
{
CPLXMLNode *psBandTree;
GDALPamRasterBand *poBand = (GDALPamRasterBand *)
GetRasterBand(iBand+1);
if( poBand == NULL || !(poBand->GetMOFlags() & GMO_PAM_CLASS) )
continue;
psBandTree = poBand->SerializeToXML( pszVRTPath );
if( psBandTree != NULL )
CPLAddXMLChild( psDSTree, psBandTree );
}
/* -------------------------------------------------------------------- */
/* We don't want to return anything if we had no metadata to */
/* attach. */
/* -------------------------------------------------------------------- */
if( psDSTree->psChild == NULL )
{
CPLDestroyXMLNode( psDSTree );
psDSTree = NULL;
}
return psDSTree;
}
CPLXMLNode *VRTRasterBand::SerializeToXML( const char *pszVRTPath )
{
CPLXMLNode *psTree = CPLCreateXMLNode( NULL, CXT_Element, "VRTRasterBand" );
/* -------------------------------------------------------------------- */
/* Various kinds of metadata. */
/* -------------------------------------------------------------------- */
CPLSetXMLValue( psTree, "#dataType",
GDALGetDataTypeName( GetRasterDataType() ) );
if( nBand > 0 )
CPLSetXMLValue( psTree, "#band", CPLSPrintf( "%d", GetBand() ) );
CPLXMLNode *psMD = oMDMD.Serialize();
if( psMD != NULL )
{
CPLAddXMLChild( psTree, psMD );
}
if( strlen(GetDescription()) > 0 )
CPLSetXMLValue( psTree, "Description", GetDescription() );
if( m_bNoDataValueSet )
{
if (CPLIsNan(m_dfNoDataValue))
CPLSetXMLValue( psTree, "NoDataValue", "nan");
else
CPLSetXMLValue( psTree, "NoDataValue",
CPLSPrintf( "%.16g", m_dfNoDataValue ) );
}
if( m_bHideNoDataValue )
CPLSetXMLValue( psTree, "HideNoDataValue",
CPLSPrintf( "%d", m_bHideNoDataValue ) );
if( m_pszUnitType != NULL )
CPLSetXMLValue( psTree, "UnitType", m_pszUnitType );
if( m_dfOffset != 0.0 )
CPLSetXMLValue( psTree, "Offset",
CPLSPrintf( "%.16g", m_dfOffset ) );
if( m_dfScale != 1.0 )
CPLSetXMLValue( psTree, "Scale",
CPLSPrintf( "%.16g", m_dfScale ) );
if( m_eColorInterp != GCI_Undefined )
CPLSetXMLValue( psTree, "ColorInterp",
GDALGetColorInterpretationName( m_eColorInterp ) );
/* -------------------------------------------------------------------- */
/* Category names. */
/* -------------------------------------------------------------------- */
if( m_papszCategoryNames != NULL )
{
CPLXMLNode *psCT_XML = CPLCreateXMLNode( psTree, CXT_Element,
"CategoryNames" );
CPLXMLNode* psLastChild = NULL;
for( int iEntry=0; m_papszCategoryNames[iEntry] != NULL; iEntry++ )
{
CPLXMLNode *psNode = CPLCreateXMLElementAndValue( NULL, "Category",
m_papszCategoryNames[iEntry] );
if( psLastChild == NULL )
psCT_XML->psChild = psNode;
else
psLastChild->psNext = psNode;
psLastChild = psNode;
}
}
/* -------------------------------------------------------------------- */
/* Histograms. */
/* -------------------------------------------------------------------- */
if( m_psSavedHistograms != NULL )
CPLAddXMLChild( psTree, CPLCloneXMLTree( m_psSavedHistograms ) );
/* -------------------------------------------------------------------- */
/* Color Table. */
/* -------------------------------------------------------------------- */
if( m_poColorTable != NULL )
{
CPLXMLNode *psCT_XML = CPLCreateXMLNode( psTree, CXT_Element,
"ColorTable" );
CPLXMLNode* psLastChild = NULL;
for( int iEntry=0; iEntry < m_poColorTable->GetColorEntryCount();
iEntry++ )
{
CPLXMLNode *psEntry_XML = CPLCreateXMLNode( NULL, CXT_Element,
"Entry" );
if( psLastChild == NULL )
psCT_XML->psChild = psEntry_XML;
else
psLastChild->psNext = psEntry_XML;
psLastChild = psEntry_XML;
GDALColorEntry sEntry;
m_poColorTable->GetColorEntryAsRGB( iEntry, &sEntry );
CPLSetXMLValue( psEntry_XML, "#c1", CPLSPrintf("%d",sEntry.c1) );
CPLSetXMLValue( psEntry_XML, "#c2", CPLSPrintf("%d",sEntry.c2) );
CPLSetXMLValue( psEntry_XML, "#c3", CPLSPrintf("%d",sEntry.c3) );
CPLSetXMLValue( psEntry_XML, "#c4", CPLSPrintf("%d",sEntry.c4) );
}
}
/* ==================================================================== */
/* Overviews */
/* ==================================================================== */
for( int iOvr = 0; iOvr < static_cast<int>( m_apoOverviews.size() ); iOvr ++ )
{
CPLXMLNode *psOVR_XML = CPLCreateXMLNode( psTree, CXT_Element,
"Overview" );
int bRelativeToVRT = FALSE;
const char *pszRelativePath = NULL;
VSIStatBufL sStat;
if( VSIStatExL( m_apoOverviews[iOvr].osFilename, &sStat, VSI_STAT_EXISTS_FLAG ) != 0 )
{
pszRelativePath = m_apoOverviews[iOvr].osFilename;
bRelativeToVRT = FALSE;
}
else
{
pszRelativePath =
CPLExtractRelativePath( pszVRTPath, m_apoOverviews[iOvr].osFilename,
&bRelativeToVRT );
}
CPLSetXMLValue( psOVR_XML, "SourceFilename", pszRelativePath );
CPLCreateXMLNode(
CPLCreateXMLNode( CPLGetXMLNode( psOVR_XML, "SourceFilename" ),
CXT_Attribute, "relativeToVRT" ),
CXT_Text, bRelativeToVRT ? "1" : "0" );
CPLSetXMLValue( psOVR_XML, "SourceBand",
CPLSPrintf("%d",m_apoOverviews[iOvr].nBand) );
}
/* ==================================================================== */
/* Mask band (specific to that raster band) */
/* ==================================================================== */
if( m_poMaskBand != NULL )
{
CPLXMLNode *psBandTree =
m_poMaskBand->SerializeToXML(pszVRTPath);
if( psBandTree != NULL )
{
CPLXMLNode *psMaskBandElement = CPLCreateXMLNode( psTree, CXT_Element,
"MaskBand" );
CPLAddXMLChild( psMaskBandElement, psBandTree );
}
}
return psTree;
}
CPLXMLNode *VRTDataset::SerializeToXML( const char *pszVRTPath )
{
/* -------------------------------------------------------------------- */
/* Setup root node and attributes. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psDSTree = NULL;
CPLXMLNode *psMD = NULL;
char szNumber[128];
psDSTree = CPLCreateXMLNode( NULL, CXT_Element, "VRTDataset" );
sprintf( szNumber, "%d", GetRasterXSize() );
CPLSetXMLValue( psDSTree, "#rasterXSize", szNumber );
sprintf( szNumber, "%d", GetRasterYSize() );
CPLSetXMLValue( psDSTree, "#rasterYSize", szNumber );
/* -------------------------------------------------------------------- */
/* SRS */
/* -------------------------------------------------------------------- */
if( pszProjection != NULL && strlen(pszProjection) > 0 )
CPLSetXMLValue( psDSTree, "SRS", pszProjection );
/* -------------------------------------------------------------------- */
/* Geotransform. */
/* -------------------------------------------------------------------- */
if( bGeoTransformSet )
{
CPLSetXMLValue( psDSTree, "GeoTransform",
CPLSPrintf( "%24.16e,%24.16e,%24.16e,%24.16e,%24.16e,%24.16e",
adfGeoTransform[0],
adfGeoTransform[1],
adfGeoTransform[2],
adfGeoTransform[3],
adfGeoTransform[4],
adfGeoTransform[5] ) );
}
/* -------------------------------------------------------------------- */
/* Metadata */
/* -------------------------------------------------------------------- */
psMD = oMDMD.Serialize();
if( psMD != NULL )
CPLAddXMLChild( psDSTree, psMD );
/* -------------------------------------------------------------------- */
/* GCPs */
/* -------------------------------------------------------------------- */
if( nGCPCount > 0 )
{
CPLXMLNode *psGCPList = CPLCreateXMLNode( psDSTree, CXT_Element,
"GCPList" );
if( pszGCPProjection != NULL && strlen(pszGCPProjection) > 0 )
CPLSetXMLValue( psGCPList, "#Projection", pszGCPProjection );
for( int iGCP = 0; iGCP < nGCPCount; iGCP++ )
{
CPLXMLNode *psXMLGCP;
GDAL_GCP *psGCP = pasGCPList + iGCP;
psXMLGCP = CPLCreateXMLNode( psGCPList, CXT_Element, "GCP" );
CPLSetXMLValue( psXMLGCP, "#Id", psGCP->pszId );
if( psGCP->pszInfo != NULL && strlen(psGCP->pszInfo) > 0 )
CPLSetXMLValue( psXMLGCP, "Info", psGCP->pszInfo );
CPLSetXMLValue( psXMLGCP, "#Pixel",
CPLSPrintf( "%.4f", psGCP->dfGCPPixel ) );
CPLSetXMLValue( psXMLGCP, "#Line",
CPLSPrintf( "%.4f", psGCP->dfGCPLine ) );
CPLSetXMLValue( psXMLGCP, "#X",
CPLSPrintf( "%.12E", psGCP->dfGCPX ) );
CPLSetXMLValue( psXMLGCP, "#Y",
CPLSPrintf( "%.12E", psGCP->dfGCPY ) );
if( psGCP->dfGCPZ != 0.0 )
CPLSetXMLValue( psXMLGCP, "#GCPZ",
CPLSPrintf( "%.12E", psGCP->dfGCPZ ) );
}
}
/* -------------------------------------------------------------------- */
/* Serialize bands. */
/* -------------------------------------------------------------------- */
for( int iBand = 0; iBand < nBands; iBand++ )
{
CPLXMLNode *psBandTree =
((VRTRasterBand *) papoBands[iBand])->SerializeToXML(pszVRTPath);
if( psBandTree != NULL )
CPLAddXMLChild( psDSTree, psBandTree );
}
/* -------------------------------------------------------------------- */
/* Serialize dataset mask band. */
/* -------------------------------------------------------------------- */
if (poMaskBand)
{
CPLXMLNode *psBandTree =
poMaskBand->SerializeToXML(pszVRTPath);
if( psBandTree != NULL )
{
CPLXMLNode *psMaskBandElement = CPLCreateXMLNode( psDSTree, CXT_Element,
"MaskBand" );
CPLAddXMLChild( psMaskBandElement, psBandTree );
}
}
return psDSTree;
}
