CPLXMLNode *WCTSAuthId2crsId( char **papszParms, const char *pszName )
{
const char *pszAuthId = CSLFetchNameValue( papszParms, pszName );
CPLXMLNode *psCRSId;
char **papszTokens;
if( pszAuthId == NULL )
WCTSEmitServiceException(
CPLSPrintf( "%s keyword missing", pszName ) );
papszTokens = CSLTokenizeString2( pszAuthId, ":", 0 );
if( CSLCount(papszTokens) != 2 )
WCTSEmitServiceException(
CPLSPrintf( "%.500s value corrupt, use 'authority:code'.",
pszName ));
psCRSId = CPLCreateXMLNode( NULL, CXT_Element, "crsID" );
CPLCreateXMLElementAndValue( psCRSId, "gml:codeSpace", papszTokens[0]);
CPLCreateXMLElementAndValue( psCRSId, "gml:code", papszTokens[1] );
CSLDestroy( papszTokens );
return psCRSId;
}
OGRErr OGRMILayerAttrIndex::SaveConfigToXML()
{
if( nIndexCount == 0 )
return OGRERR_NONE;
/* -------------------------------------------------------------------- */
/* Create the XML tree corresponding to this layer. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRoot;
psRoot = CPLCreateXMLNode( NULL, CXT_Element, "OGRMILayerAttrIndex" );
CPLCreateXMLElementAndValue( psRoot, "MIIDFilename",
CPLGetFilename( pszMIINDFilename ) );
for( int i = 0; i < nIndexCount; i++ )
{
OGRMIAttrIndex *poAI = papoIndexList[i];
CPLXMLNode *psIndex;
psIndex = CPLCreateXMLNode( psRoot, CXT_Element, "OGRMIAttrIndex" );
CPLCreateXMLElementAndValue( psIndex, "FieldIndex",
CPLSPrintf( "%d", poAI->iField ) );
CPLCreateXMLElementAndValue( psIndex, "FieldName",
poLayer->GetLayerDefn()->GetFieldDefn(poAI->iField)->GetNameRef() );
CPLCreateXMLElementAndValue( psIndex, "IndexIndex",
CPLSPrintf( "%d", poAI->iIndex ) );
}
/* -------------------------------------------------------------------- */
/* Save it. */
/* -------------------------------------------------------------------- */
char *pszRawXML = CPLSerializeXMLTree( psRoot );
FILE *fp;
CPLDestroyXMLNode( psRoot );
fp = VSIFOpen( pszMetadataFilename, "wb" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to pen `%s' for write.",
pszMetadataFilename );
CPLFree( pszRawXML );
return OGRERR_FAILURE;
}
VSIFWrite( pszRawXML, 1, strlen(pszRawXML), fp );
VSIFClose( fp );
CPLFree( pszRawXML );
return OGRERR_NONE;
}
CPLXMLNode *GDALSerializeGCPTransformer( void *pTransformArg )
{
CPLXMLNode *psTree = NULL;
GCPTransformInfo *psInfo = (GCPTransformInfo *) pTransformArg;
VALIDATE_POINTER1( pTransformArg, "GDALSerializeGCPTransformer", NULL );
psTree = CPLCreateXMLNode( NULL, CXT_Element, "GCPTransformer" );
/* -------------------------------------------------------------------- */
/* Serialize Order and bReversed. */
/* -------------------------------------------------------------------- */
CPLCreateXMLElementAndValue(
psTree, "Order",
CPLSPrintf( "%d", psInfo->nOrder ) );
CPLCreateXMLElementAndValue(
psTree, "Reversed",
CPLSPrintf( "%d", psInfo->bReversed ) );
if( psInfo->bRefine )
{
CPLCreateXMLElementAndValue(
psTree, "Refine",
CPLSPrintf( "%d", psInfo->bRefine ) );
CPLCreateXMLElementAndValue(
psTree, "MinimumGcps",
CPLSPrintf( "%d", psInfo->nMinimumGcps ) );
CPLCreateXMLElementAndValue(
psTree, "Tolerance",
CPLSPrintf( "%f", psInfo->dfTolerance ) );
}
/* -------------------------------------------------------------------- */
/* Attach GCP List. */
/* -------------------------------------------------------------------- */
if( psInfo->nGCPCount > 0 )
{
if(psInfo->bRefine)
{
remove_outliers(psInfo);
}
GDALSerializeGCPListToXML( psTree,
psInfo->pasGCPList,
psInfo->nGCPCount,
NULL );
}
return psTree;
}
CPLXMLNode* OGR_G_ExportEnvelopeToKMLTree( OGRGeometryH hGeometry )
{
VALIDATE_POINTER1( hGeometry, "OGR_G_ExportEnvelopeToKMLTree", NULL );
CPLXMLNode* psBox = NULL;
CPLXMLNode* psCoord = NULL;
OGREnvelope sEnvelope;
char szCoordinate[256] = { 0 };
char* pszY = NULL;
memset( &sEnvelope, 0, sizeof(sEnvelope) );
((OGRGeometry*)(hGeometry))->getEnvelope( &sEnvelope );
if( sEnvelope.MinX == 0 && sEnvelope.MaxX == 0
&& sEnvelope.MaxX == 0 && sEnvelope.MaxY == 0 )
{
/* there is apparently a special way of representing a null box
geometry ... we should use it here eventually. */
return NULL;
}
psBox = CPLCreateXMLNode( NULL, CXT_Element, "Box" );
/* -------------------------------------------------------------------- */
/* Add minxy coordinate. */
/* -------------------------------------------------------------------- */
psCoord = CPLCreateXMLNode( psBox, CXT_Element, "coord" );
MakeKMLCoordinate( szCoordinate, sEnvelope.MinX, sEnvelope.MinY, 0.0,
FALSE );
pszY = strstr(szCoordinate,",") + 1;
pszY[-1] = '\0';
CPLCreateXMLElementAndValue( psCoord, "X", szCoordinate );
CPLCreateXMLElementAndValue( psCoord, "Y", pszY );
/* -------------------------------------------------------------------- */
/* Add maxxy coordinate. */
/* -------------------------------------------------------------------- */
psCoord = CPLCreateXMLNode( psBox, CXT_Element, "coord" );
MakeKMLCoordinate( szCoordinate, sEnvelope.MaxX, sEnvelope.MaxY, 0.0,
FALSE );
pszY = strstr(szCoordinate,",") + 1;
pszY[-1] = '\0';
CPLCreateXMLElementAndValue( psCoord, "X", szCoordinate );
CPLCreateXMLElementAndValue( psCoord, "Y", pszY );
return psBox;
}
CPLXMLNode *GDALSerializeTPSTransformer( void *pTransformArg )
{
VALIDATE_POINTER1( pTransformArg, "GDALSerializeTPSTransformer", NULL );
CPLXMLNode *psTree;
TPSTransformInfo *psInfo = static_cast<TPSTransformInfo *>(pTransformArg);
psTree = CPLCreateXMLNode( NULL, CXT_Element, "TPSTransformer" );
/* -------------------------------------------------------------------- */
/* Serialize bReversed. */
/* -------------------------------------------------------------------- */
CPLCreateXMLElementAndValue(
psTree, "Reversed",
CPLString().Printf( "%d", psInfo->bReversed ) );
/* -------------------------------------------------------------------- */
/* Attach GCP List. */
/* -------------------------------------------------------------------- */
if( psInfo->nGCPCount > 0 )
{
GDALSerializeGCPListToXML( psTree,
psInfo->pasGCPList,
psInfo->nGCPCount,
NULL );
}
return psTree;
}
CPLXMLNode *GDALSerializeTPSTransformer( void *pTransformArg )
{
VALIDATE_POINTER1( pTransformArg, "GDALSerializeTPSTransformer", NULL );
CPLXMLNode *psTree;
TPSTransformInfo *psInfo = static_cast<TPSTransformInfo *>(pTransformArg);
psTree = CPLCreateXMLNode( NULL, CXT_Element, "TPSTransformer" );
/* -------------------------------------------------------------------- */
/* Serialize bReversed. */
/* -------------------------------------------------------------------- */
CPLCreateXMLElementAndValue(
psTree, "Reversed",
CPLString().Printf( "%d", psInfo->bReversed ) );
/* -------------------------------------------------------------------- */
/* Attach GCP List. */
/* -------------------------------------------------------------------- */
if( psInfo->nGCPCount > 0 )
{
int iGCP;
CPLXMLNode *psGCPList = CPLCreateXMLNode( psTree, CXT_Element,
"GCPList" );
for( iGCP = 0; iGCP < psInfo->nGCPCount; iGCP++ )
{
CPLXMLNode *psXMLGCP;
GDAL_GCP *psGCP = psInfo->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",
CPLString().Printf( "%.4f", psGCP->dfGCPPixel ) );
CPLSetXMLValue( psXMLGCP, "#Line",
CPLString().Printf( "%.4f", psGCP->dfGCPLine ) );
CPLSetXMLValue( psXMLGCP, "#X",
CPLString().Printf( "%.12E", psGCP->dfGCPX ) );
CPLSetXMLValue( psXMLGCP, "#Y",
CPLString().Printf( "%.12E", psGCP->dfGCPY ) );
if( psGCP->dfGCPZ != 0.0 )
CPLSetXMLValue( psXMLGCP, "#GCPZ",
CPLString().Printf( "%.12E", psGCP->dfGCPZ ) );
}
}
return psTree;
}
CPLXMLNode *GMLFeatureClass::SerializeToXML()
{
CPLXMLNode *psRoot;
int iProperty;
/* -------------------------------------------------------------------- */
/* Set feature class and core information. */
/* -------------------------------------------------------------------- */
psRoot = CPLCreateXMLNode( NULL, CXT_Element, "GMLFeatureClass" );
CPLCreateXMLElementAndValue( psRoot, "Name", GetName() );
CPLCreateXMLElementAndValue( psRoot, "ElementPath", GetElementName() );
if( m_nGeometryPropertyCount > 1 )
{
for(int i=0; i < m_nGeometryPropertyCount; i++)
{
GMLGeometryPropertyDefn* poGeomFDefn = m_papoGeometryProperty[i];
CPLXMLNode *psPDefnNode;
psPDefnNode = CPLCreateXMLNode( psRoot, CXT_Element, "GeomPropertyDefn" );
if( strlen(poGeomFDefn->GetName()) > 0 )
CPLCreateXMLElementAndValue( psPDefnNode, "Name",
poGeomFDefn->GetName() );
if( poGeomFDefn->GetSrcElement() != NULL && strlen(poGeomFDefn->GetSrcElement()) > 0 )
CPLCreateXMLElementAndValue( psPDefnNode, "ElementPath",
poGeomFDefn->GetSrcElement() );
if( poGeomFDefn->GetType() != 0 /* wkbUnknown */ )
{
char szValue[128];
OGRwkbGeometryType eType = (OGRwkbGeometryType)poGeomFDefn->GetType();
CPLString osStr(OGRToOGCGeomType(eType));
if( wkbHasZ(eType) ) osStr += "Z";
CPLCreateXMLNode( psPDefnNode, CXT_Comment, osStr.c_str() );
sprintf( szValue, "%d", eType );
CPLCreateXMLElementAndValue( psPDefnNode, "Type", szValue );
}
}
}
else if( m_nGeometryPropertyCount == 1 )
{
GMLGeometryPropertyDefn* poGeomFDefn = m_papoGeometryProperty[0];
if( strlen(poGeomFDefn->GetName()) > 0 )
CPLCreateXMLElementAndValue( psRoot, "GeometryName",
poGeomFDefn->GetName() );
if( poGeomFDefn->GetSrcElement() != NULL && strlen(poGeomFDefn->GetSrcElement()) > 0 )
CPLCreateXMLElementAndValue( psRoot, "GeometryElementPath",
poGeomFDefn->GetSrcElement() );
if( poGeomFDefn->GetType() != 0 /* wkbUnknown */ )
{
char szValue[128];
OGRwkbGeometryType eType = (OGRwkbGeometryType)poGeomFDefn->GetType();
CPLString osStr(OGRToOGCGeomType(eType));
if( wkbHasZ(eType) ) osStr += "Z";
CPLCreateXMLNode( psRoot, CXT_Comment, osStr.c_str() );
sprintf( szValue, "%d", eType );
CPLCreateXMLElementAndValue( psRoot, "GeometryType", szValue );
}
}
else
{
CPLCreateXMLElementAndValue( psRoot, "GeometryType", "100" );
}
const char* pszSRSName = GetSRSName();
if( pszSRSName )
{
CPLCreateXMLElementAndValue( psRoot, "SRSName", pszSRSName );
}
/* -------------------------------------------------------------------- */
/* Write out dataset specific information. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psDSI;
if( m_bHaveExtents || m_nFeatureCount != -1 || m_pszExtraInfo != NULL )
{
psDSI = CPLCreateXMLNode( psRoot, CXT_Element, "DatasetSpecificInfo" );
if( m_nFeatureCount != -1 )
{
char szValue[128];
sprintf( szValue, CPL_FRMT_GIB, m_nFeatureCount );
CPLCreateXMLElementAndValue( psDSI, "FeatureCount", szValue );
}
if( m_bHaveExtents &&
fabs(m_dfXMin) < 1e100 &&
fabs(m_dfXMax) < 1e100 &&
fabs(m_dfYMin) < 1e100 &&
fabs(m_dfYMax) < 1e100 )
{
char szValue[128];
CPLsnprintf( szValue, sizeof(szValue), "%.5f", m_dfXMin );
CPLCreateXMLElementAndValue( psDSI, "ExtentXMin", szValue );
CPLsnprintf( szValue, sizeof(szValue), "%.5f", m_dfXMax );
CPLCreateXMLElementAndValue( psDSI, "ExtentXMax", szValue );
CPLsnprintf( szValue, sizeof(szValue), "%.5f", m_dfYMin );
CPLCreateXMLElementAndValue( psDSI, "ExtentYMin", szValue );
CPLsnprintf( szValue, sizeof(szValue), "%.5f", m_dfYMax );
CPLCreateXMLElementAndValue( psDSI, "ExtentYMax", szValue );
}
if( m_pszExtraInfo )
CPLCreateXMLElementAndValue( psDSI, "ExtraInfo", m_pszExtraInfo );
}
/* -------------------------------------------------------------------- */
/* emit property information. */
/* -------------------------------------------------------------------- */
for( iProperty = 0; iProperty < GetPropertyCount(); iProperty++ )
{
GMLPropertyDefn *poPDefn = GetProperty( iProperty );
CPLXMLNode *psPDefnNode;
const char *pszTypeName = "Unknown";
psPDefnNode = CPLCreateXMLNode( psRoot, CXT_Element, "PropertyDefn" );
CPLCreateXMLElementAndValue( psPDefnNode, "Name",
poPDefn->GetName() );
CPLCreateXMLElementAndValue( psPDefnNode, "ElementPath",
poPDefn->GetSrcElement() );
switch( poPDefn->GetType() )
{
case GMLPT_Untyped:
pszTypeName = "Untyped";
break;
case GMLPT_String:
case GMLPT_Boolean:
pszTypeName = "String";
break;
case GMLPT_Integer:
case GMLPT_Short:
case GMLPT_Integer64:
pszTypeName = "Integer";
break;
case GMLPT_Real:
case GMLPT_Float:
pszTypeName = "Real";
break;
case GMLPT_Complex:
pszTypeName = "Complex";
break;
case GMLPT_IntegerList:
case GMLPT_Integer64List:
pszTypeName = "IntegerList";
break;
case GMLPT_RealList:
pszTypeName = "RealList";
break;
case GMLPT_StringList:
case GMLPT_BooleanList:
pszTypeName = "StringList";
break;
/* should not happen in practise for now because this is not */
/* autodetected */
case GMLPT_FeatureProperty:
pszTypeName = "FeatureProperty";
break;
/* should not happen in practise for now because this is not */
/* autodetected */
case GMLPT_FeaturePropertyList:
pszTypeName = "FeaturePropertyList";
break;
}
CPLCreateXMLElementAndValue( psPDefnNode, "Type", pszTypeName );
if( poPDefn->GetType() == GMLPT_Boolean || poPDefn->GetType() == GMLPT_BooleanList )
CPLCreateXMLElementAndValue( psPDefnNode, "Subtype", "Boolean" );
else if( poPDefn->GetType() == GMLPT_Short )
CPLCreateXMLElementAndValue( psPDefnNode, "Subtype", "Short" );
else if( poPDefn->GetType() == GMLPT_Float )
CPLCreateXMLElementAndValue( psPDefnNode, "Subtype", "Float" );
else if( poPDefn->GetType() == GMLPT_Integer64 ||
poPDefn->GetType() == GMLPT_Integer64List )
CPLCreateXMLElementAndValue( psPDefnNode, "Subtype", "Integer64" );
if( EQUAL(pszTypeName,"String") )
{
char szMaxLength[48];
sprintf(szMaxLength, "%d", poPDefn->GetWidth());
CPLCreateXMLElementAndValue ( psPDefnNode, "Width", szMaxLength );
}
if( poPDefn->GetWidth() > 0 && EQUAL(pszTypeName,"Integer") )
{
char szLength[48];
sprintf(szLength, "%d", poPDefn->GetWidth());
CPLCreateXMLElementAndValue ( psPDefnNode, "Width", szLength );
}
if( poPDefn->GetWidth() > 0 && EQUAL(pszTypeName,"Real") )
{
char szLength[48];
sprintf(szLength, "%d", poPDefn->GetWidth());
CPLCreateXMLElementAndValue ( psPDefnNode, "Width", szLength );
char szPrecision[48];
sprintf(szPrecision, "%d", poPDefn->GetPrecision());
CPLCreateXMLElementAndValue ( psPDefnNode, "Precision", szPrecision );
}
}
return psRoot;
}
CPLXMLNode *VRTRasterBand::SerializeToXML( const char *pszVRTPath )
{
CPLXMLNode *psTree;
psTree = CPLCreateXMLNode( NULL, CXT_Element, "VRTRasterBand" );
/* -------------------------------------------------------------------- */
/* Various kinds of metadata. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psMD;
CPLSetXMLValue( psTree, "#dataType",
GDALGetDataTypeName( GetRasterDataType() ) );
if( nBand > 0 )
CPLSetXMLValue( psTree, "#band", CPLSPrintf( "%d", GetBand() ) );
psMD = oMDMD.Serialize();
if( psMD != NULL )
CPLAddXMLChild( psTree, psMD );
if( strlen(GetDescription()) > 0 )
CPLSetXMLValue( psTree, "Description", GetDescription() );
if( bNoDataValueSet )
{
if (CPLIsNan(dfNoDataValue))
CPLSetXMLValue( psTree, "NoDataValue", "nan");
else
CPLSetXMLValue( psTree, "NoDataValue",
CPLSPrintf( "%.14E", dfNoDataValue ) );
}
if( bHideNoDataValue )
CPLSetXMLValue( psTree, "HideNoDataValue",
CPLSPrintf( "%d", bHideNoDataValue ) );
if( pszUnitType != NULL )
CPLSetXMLValue( psTree, "UnitType", pszUnitType );
if( dfOffset != 0.0 )
CPLSetXMLValue( psTree, "Offset",
CPLSPrintf( "%.16g", dfOffset ) );
if( dfScale != 1.0 )
CPLSetXMLValue( psTree, "Scale",
CPLSPrintf( "%.16g", dfScale ) );
if( eColorInterp != GCI_Undefined )
CPLSetXMLValue( psTree, "ColorInterp",
GDALGetColorInterpretationName( eColorInterp ) );
/* -------------------------------------------------------------------- */
/* Category names. */
/* -------------------------------------------------------------------- */
if( papszCategoryNames != NULL )
{
CPLXMLNode *psCT_XML = CPLCreateXMLNode( psTree, CXT_Element,
"CategoryNames" );
CPLXMLNode* psLastChild = NULL;
for( int iEntry=0; papszCategoryNames[iEntry] != NULL; iEntry++ )
{
CPLXMLNode *psNode = CPLCreateXMLElementAndValue( NULL, "Category",
papszCategoryNames[iEntry] );
if( psLastChild == NULL )
psCT_XML->psChild = psNode;
else
psLastChild->psNext = psNode;
psLastChild = psNode;
}
}
/* -------------------------------------------------------------------- */
/* Histograms. */
/* -------------------------------------------------------------------- */
if( psSavedHistograms != NULL )
CPLAddXMLChild( psTree, CPLCloneXMLTree( psSavedHistograms ) );
/* -------------------------------------------------------------------- */
/* Color Table. */
/* -------------------------------------------------------------------- */
if( poColorTable != NULL )
{
CPLXMLNode *psCT_XML = CPLCreateXMLNode( psTree, CXT_Element,
"ColorTable" );
CPLXMLNode* psLastChild = NULL;
for( int iEntry=0; iEntry < 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;
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 < (int)apoOverviews.size(); iOvr ++ )
{
CPLXMLNode *psOVR_XML = CPLCreateXMLNode( psTree, CXT_Element,
"Overview" );
int bRelativeToVRT;
const char *pszRelativePath;
VSIStatBufL sStat;
if( VSIStatExL( apoOverviews[iOvr].osFilename, &sStat, VSI_STAT_EXISTS_FLAG ) != 0 )
{
pszRelativePath = apoOverviews[iOvr].osFilename;
bRelativeToVRT = FALSE;
}
else
{
pszRelativePath =
CPLExtractRelativePath( pszVRTPath, 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",apoOverviews[iOvr].nBand) );
}
/* ==================================================================== */
/* Mask band (specific to that raster band) */
/* ==================================================================== */
if( poMaskBand != NULL )
{
CPLXMLNode *psBandTree =
poMaskBand->SerializeToXML(pszVRTPath);
if( psBandTree != NULL )
{
CPLXMLNode *psMaskBandElement = CPLCreateXMLNode( psTree, CXT_Element,
"MaskBand" );
CPLAddXMLChild( psMaskBandElement, psBandTree );
}
}
return psTree;
}
CPLXMLNode *VRTWarpedDataset::SerializeToXML( const char *pszVRTPath )
{
CPLXMLNode *psTree;
psTree = VRTDataset::SerializeToXML( pszVRTPath );
if( psTree == NULL )
return psTree;
/* -------------------------------------------------------------------- */
/* Set subclass. */
/* -------------------------------------------------------------------- */
CPLCreateXMLNode(
CPLCreateXMLNode( psTree, CXT_Attribute, "subClass" ),
CXT_Text, "VRTWarpedDataset" );
/* -------------------------------------------------------------------- */
/* Serialize the block size. */
/* -------------------------------------------------------------------- */
CPLCreateXMLElementAndValue( psTree, "BlockXSize",
CPLSPrintf( "%d", nBlockXSize ) );
CPLCreateXMLElementAndValue( psTree, "BlockYSize",
CPLSPrintf( "%d", nBlockYSize ) );
/* -------------------------------------------------------------------- */
/* Serialize the overview list. */
/* -------------------------------------------------------------------- */
if( nOverviewCount > 0 )
{
char *pszOverviewList;
int iOverview;
pszOverviewList = (char *) CPLMalloc(nOverviewCount*8 + 10);
pszOverviewList[0] = '\0';
for( iOverview = 0; iOverview < nOverviewCount; iOverview++ )
{
int nOvFactor;
nOvFactor = (int)
(0.5+GetRasterXSize()
/ (double) papoOverviews[iOverview]->GetRasterXSize());
sprintf( pszOverviewList + strlen(pszOverviewList),
"%d ", nOvFactor );
}
CPLCreateXMLElementAndValue( psTree, "OverviewList", pszOverviewList );
CPLFree( pszOverviewList );
}
/* ==================================================================== */
/* Serialize the warp options. */
/* ==================================================================== */
CPLXMLNode *psWOTree;
if( poWarper != NULL )
{
/* -------------------------------------------------------------------- */
/* We reset the destination dataset name so it doesn't get */
/* written out in the serialize warp options. */
/* -------------------------------------------------------------------- */
char *pszSavedName = CPLStrdup(GetDescription());
SetDescription("");
psWOTree = GDALSerializeWarpOptions( poWarper->GetOptions() );
CPLAddXMLChild( psTree, psWOTree );
SetDescription( pszSavedName );
CPLFree( pszSavedName );
/* -------------------------------------------------------------------- */
/* We need to consider making the source dataset relative to */
/* the VRT file if possible. Adjust accordingly. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psSDS = CPLGetXMLNode( psWOTree, "SourceDataset" );
int bRelativeToVRT;
char *pszRelativePath;
pszRelativePath =
CPLStrdup(
CPLExtractRelativePath( pszVRTPath, psSDS->psChild->pszValue,
&bRelativeToVRT ) );
CPLFree( psSDS->psChild->pszValue );
psSDS->psChild->pszValue = pszRelativePath;
CPLCreateXMLNode(
CPLCreateXMLNode( psSDS, CXT_Attribute, "relativeToVRT" ),
CXT_Text, bRelativeToVRT ? "1" : "0" );
}
return psTree;
}
GDALDataset *ISCEDataset::Create( const char *pszFilename,
int nXSize, int nYSize, int nBands,
GDALDataType eType,
char **papszOptions )
{
const char *sType = GDALGetDataTypeName( eType );
const char *sScheme = CSLFetchNameValueDef( papszOptions,
"SCHEME",
"BIP" );
/* -------------------------------------------------------------------- */
/* Try to create the file. */
/* -------------------------------------------------------------------- */
VSILFILE *fp = VSIFOpenL( pszFilename, "wb" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create file `%s' failed.\n",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Just write out a couple of bytes to establish the binary */
/* file, and then close it. */
/* -------------------------------------------------------------------- */
CPL_IGNORE_RET_VAL(VSIFWriteL( (void *) "\0\0", 2, 1, fp ));
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
/* -------------------------------------------------------------------- */
/* Create a minimal XML document. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psDocNode = CPLCreateXMLNode( NULL, CXT_Element, "imageFile" );
CPLXMLNode *psTmpNode
= CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "WIDTH" );
char sBuf[64];
snprintf(sBuf, sizeof(sBuf), "%d", nXSize);
CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "LENGTH" );
snprintf(sBuf, sizeof(sBuf), "%d", nYSize);
CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "NUMBER_BANDS" );
snprintf(sBuf, sizeof(sBuf), "%d", nBands);
CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "DATA_TYPE" );
CPLCreateXMLElementAndValue( psTmpNode, "value",
CSLFetchNameValue(
(char **)apszGDAL2ISCEDatatypes,
sType ));
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "SCHEME" );
CPLCreateXMLElementAndValue( psTmpNode, "value", sScheme );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "BYTE_ORDER" );
#ifdef CPL_LSB
CPLCreateXMLElementAndValue( psTmpNode, "value", "l" );
#else
CPLCreateXMLElementAndValue( psTmpNode, "value", "b" );
#endif
/* -------------------------------------------------------------------- */
/* Write the XML file. */
/* -------------------------------------------------------------------- */
const char *pszXMLFilename = CPLFormFilename( NULL, pszFilename, "xml" );
CPLSerializeXMLTreeToFile( psDocNode, pszXMLFilename );
/* -------------------------------------------------------------------- */
/* Free the XML Doc. */
/* -------------------------------------------------------------------- */
CPLDestroyXMLNode( psDocNode );
return (GDALDataset *) GDALOpen( pszFilename, GA_Update );
}
CPLXMLNode *GMLFeatureClass::SerializeToXML()
{
CPLXMLNode *psRoot;
int iProperty;
/* -------------------------------------------------------------------- */
/* Set feature class and core information. */
/* -------------------------------------------------------------------- */
psRoot = CPLCreateXMLNode( NULL, CXT_Element, "GMLFeatureClass" );
CPLCreateXMLElementAndValue( psRoot, "Name", GetName() );
CPLCreateXMLElementAndValue( psRoot, "ElementPath", GetElementName() );
if( GetGeometryElement() != NULL && strlen(GetGeometryElement()) > 0 )
CPLCreateXMLElementAndValue( psRoot, "GeometryElementPath",
GetGeometryElement() );
if( GetGeometryType() != 0 /* wkbUnknown */ )
{
char szValue[128];
sprintf( szValue, "%d", GetGeometryType() );
CPLCreateXMLElementAndValue( psRoot, "GeometryType", szValue );
}
/* -------------------------------------------------------------------- */
/* Write out dataset specific information. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psDSI;
if( m_bHaveExtents || m_nFeatureCount != -1 || m_pszExtraInfo != NULL )
{
psDSI = CPLCreateXMLNode( psRoot, CXT_Element, "DatasetSpecificInfo" );
if( m_nFeatureCount != -1 )
{
char szValue[128];
sprintf( szValue, "%d", m_nFeatureCount );
CPLCreateXMLElementAndValue( psDSI, "FeatureCount", szValue );
}
if( m_bHaveExtents )
{
char szValue[128];
sprintf( szValue, "%.5f", m_dfXMin );
CPLCreateXMLElementAndValue( psDSI, "ExtentXMin", szValue );
sprintf( szValue, "%.5f", m_dfXMax );
CPLCreateXMLElementAndValue( psDSI, "ExtentXMax", szValue );
sprintf( szValue, "%.5f", m_dfYMin );
CPLCreateXMLElementAndValue( psDSI, "ExtentYMin", szValue );
sprintf( szValue, "%.5f", m_dfYMax );
CPLCreateXMLElementAndValue( psDSI, "ExtentYMax", szValue );
}
if( m_pszExtraInfo )
CPLCreateXMLElementAndValue( psDSI, "ExtraInfo", m_pszExtraInfo );
}
/* -------------------------------------------------------------------- */
/* emit property information. */
/* -------------------------------------------------------------------- */
for( iProperty = 0; iProperty < GetPropertyCount(); iProperty++ )
{
GMLPropertyDefn *poPDefn = GetProperty( iProperty );
CPLXMLNode *psPDefnNode;
const char *pszTypeName = "Unknown";
psPDefnNode = CPLCreateXMLNode( psRoot, CXT_Element, "PropertyDefn" );
CPLCreateXMLElementAndValue( psPDefnNode, "Name",
poPDefn->GetName() );
CPLCreateXMLElementAndValue( psPDefnNode, "ElementPath",
poPDefn->GetSrcElement() );
switch( poPDefn->GetType() )
{
case GMLPT_Untyped:
pszTypeName = "Untyped";
break;
case GMLPT_String:
pszTypeName = "String";
break;
case GMLPT_Integer:
pszTypeName = "Integer";
break;
case GMLPT_Real:
pszTypeName = "Real";
break;
case GMLPT_Complex:
pszTypeName = "Complex";
break;
case GMLPT_IntegerList:
pszTypeName = "IntegerList";
break;
case GMLPT_RealList:
pszTypeName = "RealList";
break;
case GMLPT_StringList:
pszTypeName = "StringList";
break;
}
CPLCreateXMLElementAndValue( psPDefnNode, "Type", pszTypeName );
if( EQUAL(pszTypeName,"String") )
{
char szMaxLength[48];
sprintf(szMaxLength, "%d", poPDefn->GetWidth());
CPLCreateXMLElementAndValue ( psPDefnNode, "Width", szMaxLength );
}
if( poPDefn->GetWidth() > 0 && EQUAL(pszTypeName,"Integer") )
{
char szLength[48];
sprintf(szLength, "%d", poPDefn->GetWidth());
CPLCreateXMLElementAndValue ( psPDefnNode, "Width", szLength );
}
if( poPDefn->GetWidth() > 0 && EQUAL(pszTypeName,"Real") )
{
char szLength[48];
sprintf(szLength, "%d", poPDefn->GetWidth());
CPLCreateXMLElementAndValue ( psPDefnNode, "Width", szLength );
char szPrecision[48];
sprintf(szPrecision, "%d", poPDefn->GetPrecision());
CPLCreateXMLElementAndValue ( psPDefnNode, "Precision", szPrecision );
}
}
return psRoot;
}
CPLXMLNode *OGRFMELayerCached::SerializeToXML()
{
CPLXMLNode *psLayer;
char szGeomType[64];
psLayer = CPLCreateXMLNode( NULL, CXT_Element, "OGRLayer" );
/* -------------------------------------------------------------------- */
/* Handle various layer values. */
/* -------------------------------------------------------------------- */
CPLCreateXMLElementAndValue( psLayer, "Name", poFeatureDefn->GetName());
sprintf( szGeomType, "%d", (int) poFeatureDefn->GetGeomType() );
CPLCreateXMLElementAndValue( psLayer, "GeomType", szGeomType );
CPLCreateXMLElementAndValue( psLayer, "SpatialCacheName",
pszIndexBase );
/* -------------------------------------------------------------------- */
/* Handle spatial reference if available. */
/* -------------------------------------------------------------------- */
if( GetSpatialRef() != NULL )
{
char *pszWKT = NULL;
OGRSpatialReference *poSRS = GetSpatialRef();
poSRS->exportToWkt( &pszWKT );
if( pszWKT != NULL )
{
CPLCreateXMLElementAndValue( psLayer, "SRS", pszWKT );
CPLFree( pszWKT );
}
}
/* -------------------------------------------------------------------- */
/* Handle extents if available. */
/* -------------------------------------------------------------------- */
OGREnvelope sEnvelope;
if( GetExtent( &sEnvelope, FALSE ) == OGRERR_NONE )
{
char szExtent[512];
sprintf( szExtent, "%24.15E,%24.15E,%24.15E,%24.15E",
sEnvelope.MinX, sEnvelope.MinY,
sEnvelope.MaxX, sEnvelope.MaxY );
CPLCreateXMLElementAndValue( psLayer, "Extent", szExtent );
}
/* -------------------------------------------------------------------- */
/* Emit the field schemas. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psSchema = CPLCreateXMLNode( psLayer, CXT_Element, "Schema" );
for( int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
OGRFieldDefn *poFieldDef = poFeatureDefn->GetFieldDefn( iField );
const char *pszType;
char szWidth[32], szPrecision[32];
CPLXMLNode *psXMLFD;
sprintf( szWidth, "%d", poFieldDef->GetWidth() );
sprintf( szPrecision, "%d", poFieldDef->GetPrecision() );
if( poFieldDef->GetType() == OFTInteger )
pszType = "Integer";
else if( poFieldDef->GetType() == OFTIntegerList )
pszType = "IntegerList";
else if( poFieldDef->GetType() == OFTReal )
pszType = "Real";
else if( poFieldDef->GetType() == OFTRealList )
pszType = "RealList";
else if( poFieldDef->GetType() == OFTString )
pszType = "String";
else if( poFieldDef->GetType() == OFTStringList )
pszType = "StringList";
else if( poFieldDef->GetType() == OFTBinary )
pszType = "Binary";
else
pszType = "Unsupported";
psXMLFD = CPLCreateXMLNode( psSchema, CXT_Element, "OGRFieldDefn" );
CPLCreateXMLElementAndValue( psXMLFD, "Name",poFieldDef->GetNameRef());
CPLCreateXMLElementAndValue( psXMLFD, "Type", pszType );
CPLCreateXMLElementAndValue( psXMLFD, "Width", szWidth );
CPLCreateXMLElementAndValue( psXMLFD, "Precision", szPrecision );
}
return psLayer;
}
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;
}
void ISCEDataset::FlushCache( void )
{
RawDataset::FlushCache();
GDALRasterBand *band = (GetRasterCount() > 0) ? GetRasterBand(1) : NULL;
if ( eAccess == GA_ReadOnly || band == NULL )
return;
/* -------------------------------------------------------------------- */
/* Recreate a XML doc with the dataset information. */
/* -------------------------------------------------------------------- */
char sBuf[64];
CPLXMLNode *psDocNode = CPLCreateXMLNode( NULL, CXT_Element, "imageFile" );
CPLXMLNode *psTmpNode
= CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "WIDTH" );
snprintf(sBuf, sizeof(sBuf), "%d", nRasterXSize);
CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "LENGTH" );
snprintf(sBuf, sizeof(sBuf), "%d", nRasterYSize);
CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "NUMBER_BANDS" );
snprintf(sBuf, sizeof(sBuf), "%d", nBands);
CPLCreateXMLElementAndValue( psTmpNode, "value", sBuf );
const char *sType = GDALGetDataTypeName( band->GetRasterDataType() );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "DATA_TYPE" );
CPLCreateXMLElementAndValue( psTmpNode, "value",
CSLFetchNameValue(
(char **)apszGDAL2ISCEDatatypes,
sType ) );
const char *sScheme = apszSchemeNames[eScheme];
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "SCHEME" );
CPLCreateXMLElementAndValue( psTmpNode, "value", sScheme );
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", "BYTE_ORDER" );
#ifdef CPL_LSB
CPLCreateXMLElementAndValue( psTmpNode, "value", "l" );
#else
CPLCreateXMLElementAndValue( psTmpNode, "value", "b" );
#endif
/* -------------------------------------------------------------------- */
/* Then, add the ISCE domain metadata. */
/* -------------------------------------------------------------------- */
char **papszISCEMetadata = GetMetadata( "ISCE" );
for (int i = 0; i < CSLCount( papszISCEMetadata ); i++)
{
/* Get the tokens from the metadata item */
char **papszTokens = CSLTokenizeString2( papszISCEMetadata[i],
"=",
CSLT_STRIPLEADSPACES
| CSLT_STRIPENDSPACES);
if ( CSLCount( papszTokens ) != 2 )
{
CPLDebug( "ISCE",
"Line of header file could not be split at = into two"
" elements: %s",
papszISCEMetadata[i] );
CSLDestroy( papszTokens );
continue;
}
/* Don't write it out if it is one of the bits of metadata that is
* written out elsewhere in this routine */
if ( strcmp( papszTokens[0], "WIDTH" ) == 0
|| strcmp( papszTokens[0], "LENGTH" ) == 0
|| strcmp( papszTokens[0], "NUMBER_BANDS" ) == 0
|| strcmp( papszTokens[0], "DATA_TYPE" ) == 0
|| strcmp( papszTokens[0], "SCHEME" ) == 0
|| strcmp( papszTokens[0], "BYTE_ORDER" ) == 0 )
{
CSLDestroy( papszTokens );
continue;
}
psTmpNode = CPLCreateXMLNode( psDocNode, CXT_Element, "property" );
CPLAddXMLAttributeAndValue( psTmpNode, "name", papszTokens[0] );
CPLCreateXMLElementAndValue( psTmpNode, "value", papszTokens[1] );
CSLDestroy( papszTokens );
}
/* -------------------------------------------------------------------- */
/* Write the XML file. */
/* -------------------------------------------------------------------- */
CPLSerializeXMLTreeToFile( psDocNode, pszXMLFilename );
/* -------------------------------------------------------------------- */
/* Free the XML Doc. */
/* -------------------------------------------------------------------- */
CPLDestroyXMLNode( psDocNode );
}
CPLXMLNode *GDALSerializeGCPTransformer( void *pTransformArg )
{
CPLXMLNode *psTree;
GCPTransformInfo *psInfo = (GCPTransformInfo *) pTransformArg;
VALIDATE_POINTER1( pTransformArg, "GDALSerializeGCPTransformer", NULL );
psTree = CPLCreateXMLNode( NULL, CXT_Element, "GCPTransformer" );
/* -------------------------------------------------------------------- */
/* Serialize Order and bReversed. */
/* -------------------------------------------------------------------- */
CPLCreateXMLElementAndValue(
psTree, "Order",
CPLSPrintf( "%d", psInfo->nOrder ) );
CPLCreateXMLElementAndValue(
psTree, "Reversed",
CPLSPrintf( "%d", psInfo->bReversed ) );
if( psInfo->bRefine )
{
CPLCreateXMLElementAndValue(
psTree, "Refine",
CPLSPrintf( "%d", psInfo->bRefine ) );
CPLCreateXMLElementAndValue(
psTree, "MinimumGcps",
CPLSPrintf( "%d", psInfo->nMinimumGcps ) );
CPLCreateXMLElementAndValue(
psTree, "Tolerance",
CPLSPrintf( "%f", psInfo->dfTolerance ) );
}
/* -------------------------------------------------------------------- */
/* Attach GCP List. */
/* -------------------------------------------------------------------- */
if( psInfo->nGCPCount > 0 )
{
int iGCP;
CPLXMLNode *psGCPList = CPLCreateXMLNode( psTree, CXT_Element,
"GCPList" );
if(psInfo->bRefine)
{
remove_outliers(psInfo);
}
for( iGCP = 0; iGCP < psInfo->nGCPCount; iGCP++ )
{
CPLXMLNode *psXMLGCP;
GDAL_GCP *psGCP = psInfo->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 ) );
}
}
return psTree;
}
static CPLXMLNode* exportProjCSToXML(const OGRSpatialReference *poSRS)
{
const OGR_SRSNode *poProjCS = poSRS->GetAttrNode("PROJCS");
if (poProjCS == NULL)
return NULL;
/* -------------------------------------------------------------------- */
/* Establish initial infrastructure. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psCRS_XML;
psCRS_XML = CPLCreateXMLNode(NULL, CXT_Element, "gml:ProjectedCRS");
addGMLId(psCRS_XML);
/* -------------------------------------------------------------------- */
/* Attach symbolic name (a name in a nameset). */
/* -------------------------------------------------------------------- */
CPLCreateXMLElementAndValue(psCRS_XML, "gml:srsName",
poProjCS->GetChild(0)->GetValue());
/* -------------------------------------------------------------------- */
/* Add authority info if we have it. */
/* -------------------------------------------------------------------- */
exportAuthorityToXML(poProjCS, "gml:srsID", psCRS_XML, "crs");
/* -------------------------------------------------------------------- */
/* Use the GEOGCS as a <baseCRS> */
/* -------------------------------------------------------------------- */
CPLXMLNode *psBaseCRSXML =
CPLCreateXMLNode(psCRS_XML, CXT_Element, "gml:baseCRS");
CPLAddXMLChild(psBaseCRSXML, exportGeogCSToXML(poSRS));
/* -------------------------------------------------------------------- */
/* Our projected coordinate system is "defined by Conversion". */
/* -------------------------------------------------------------------- */
CPLXMLNode *psDefinedBy;
psDefinedBy = CPLCreateXMLNode(psCRS_XML, CXT_Element,
"gml:definedByConversion");
/* -------------------------------------------------------------------- */
/* Projections are handled as ParameterizedTransformations. */
/* -------------------------------------------------------------------- */
const char *pszProjection = poSRS->GetAttrValue("PROJECTION");
CPLXMLNode *psConv;
psConv = CPLCreateXMLNode(psDefinedBy, CXT_Element, "gml:Conversion");
addGMLId(psConv);
/* -------------------------------------------------------------------- */
/* Transverse Mercator */
/* -------------------------------------------------------------------- */
if (EQUAL(pszProjection, SRS_PT_TRANSVERSE_MERCATOR))
{
AddValueIDWithURN(psConv, "gml:usesMethod", "EPSG", "method",
9807);
addProjArg(poSRS, psConv, "Angular", 0.0,
8801, SRS_PP_LATITUDE_OF_ORIGIN);
addProjArg(poSRS, psConv, "Angular", 0.0,
8802, SRS_PP_CENTRAL_MERIDIAN);
addProjArg(poSRS, psConv, "Unitless", 1.0,
8805, SRS_PP_SCALE_FACTOR);
addProjArg(poSRS, psConv, "Linear", 0.0,
8806, SRS_PP_FALSE_EASTING);
addProjArg(poSRS, psConv, "Linear", 0.0,
8807, SRS_PP_FALSE_NORTHING);
}
/* -------------------------------------------------------------------- */
/* Lambert Conformal Conic */
/* -------------------------------------------------------------------- */
else if (EQUAL(pszProjection, SRS_PT_LAMBERT_CONFORMAL_CONIC_1SP))
{
AddValueIDWithURN(psConv, "gml:usesMethod", "EPSG", "method",
9801);
addProjArg(poSRS, psConv, "Angular", 0.0,
8801, SRS_PP_LATITUDE_OF_ORIGIN);
addProjArg(poSRS, psConv, "Angular", 0.0,
8802, SRS_PP_CENTRAL_MERIDIAN);
addProjArg(poSRS, psConv, "Unitless", 1.0,
8805, SRS_PP_SCALE_FACTOR);
addProjArg(poSRS, psConv, "Linear", 0.0,
8806, SRS_PP_FALSE_EASTING);
addProjArg(poSRS, psConv, "Linear", 0.0,
8807, SRS_PP_FALSE_NORTHING);
}
/* -------------------------------------------------------------------- */
/* Define the cartesian coordinate system. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psCCS;
psCCS =
CPLCreateXMLNode(
CPLCreateXMLNode(psCRS_XML, CXT_Element, "gml:usesCartesianCS"),
CXT_Element, "gml:CartesianCS");
addGMLId(psCCS);
CPLCreateXMLElementAndValue(psCCS, "gml:csName", "Cartesian");
addAuthorityIDBlock(psCCS, "gml:csID", "EPSG", "cs", 4400);
addAxis(psCCS, "E", NULL);
addAxis(psCCS, "N", NULL);
return psCRS_XML;
}
static CPLXMLNode* exportGeogCSToXML(const OGRSpatialReference *poSRS)
{
CPLXMLNode *psGCS_XML;
const OGR_SRSNode *poGeogCS = poSRS->GetAttrNode("GEOGCS");
if (poGeogCS == NULL)
return NULL;
/* -------------------------------------------------------------------- */
/* Establish initial infrastructure. */
/* -------------------------------------------------------------------- */
psGCS_XML = CPLCreateXMLNode(NULL, CXT_Element, "gml:GeographicCRS");
addGMLId(psGCS_XML);
/* -------------------------------------------------------------------- */
/* Attach symbolic name (srsName). */
/* -------------------------------------------------------------------- */
CPLCreateXMLElementAndValue(psGCS_XML, "gml:srsName",
poGeogCS->GetChild(0)->GetValue());
/* -------------------------------------------------------------------- */
/* Does the overall coordinate system have an authority? If so */
/* attach as an identification section. */
/* -------------------------------------------------------------------- */
exportAuthorityToXML(poGeogCS, "gml:srsID", psGCS_XML, "crs");
/* -------------------------------------------------------------------- */
/* Insert a big whack of fixed stuff defining the */
/* ellipsoidalCS. Basically this defines the axes and their */
/* units. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psECS;
psECS = CPLCreateXMLNode(
CPLCreateXMLNode(psGCS_XML, CXT_Element, "gml:usesEllipsoidalCS"),
CXT_Element, "gml:EllipsoidalCS");
addGMLId(psECS);
CPLCreateXMLElementAndValue(psECS, "gml:csName", "ellipsoidal");
addAuthorityIDBlock(psECS, "gml:csID", "EPSG", "cs", 6402);
addAxis(psECS, "Lat", NULL);
addAxis(psECS, "Long", NULL);
/* -------------------------------------------------------------------- */
/* Start with the datum. */
/* -------------------------------------------------------------------- */
const OGR_SRSNode *poDatum = poGeogCS->GetNode("DATUM");
CPLXMLNode *psDatumXML;
if (poDatum == NULL)
{
CPLDestroyXMLNode(psGCS_XML);
return NULL;
}
psDatumXML = CPLCreateXMLNode(
CPLCreateXMLNode(psGCS_XML, CXT_Element, "gml:usesGeodeticDatum"),
CXT_Element, "gml:GeodeticDatum");
addGMLId(psDatumXML);
/* -------------------------------------------------------------------- */
/* Set the datumName. */
/* -------------------------------------------------------------------- */
CPLCreateXMLElementAndValue(psDatumXML, "gml:datumName",
poDatum->GetChild(0)->GetValue());
/* -------------------------------------------------------------------- */
/* Set authority id info if available. */
/* -------------------------------------------------------------------- */
exportAuthorityToXML(poDatum, "gml:datumID", psDatumXML, "datum");
/* -------------------------------------------------------------------- */
/* Setup prime meridian information. */
/* -------------------------------------------------------------------- */
const OGR_SRSNode *poPMNode = poGeogCS->GetNode("PRIMEM");
CPLXMLNode *psPM;
char *pszPMName = (char* ) "Greenwich";
double dfPMOffset = poSRS->GetPrimeMeridian(&pszPMName);
psPM = CPLCreateXMLNode(
CPLCreateXMLNode(psDatumXML, CXT_Element, "gml:usesPrimeMeridian"),
CXT_Element, "gml:PrimeMeridian");
addGMLId(psPM);
CPLCreateXMLElementAndValue(psPM, "gml:meridianName", pszPMName);
if (poPMNode)
exportAuthorityToXML(poPMNode, "gml:meridianID", psPM, "meridian");
CPLXMLNode *psAngle;
psAngle =
CPLCreateXMLNode(
CPLCreateXMLNode(psPM, CXT_Element, "gml:greenwichLongitude"),
CXT_Element, "gml:angle");
CPLCreateXMLNode(CPLCreateXMLNode(psAngle, CXT_Attribute, "gml:uom"),
CXT_Text, "urn:ogc:def:uom:EPSG::9102");
CPLCreateXMLNode(psAngle, CXT_Text,
CPLString().Printf("%.16g", dfPMOffset));
/* -------------------------------------------------------------------- */
/* Translate the ellipsoid. */
/* -------------------------------------------------------------------- */
const OGR_SRSNode *poEllipsoid = poDatum->GetNode("SPHEROID");
if (poEllipsoid != NULL)
{
CPLXMLNode *psEllipseXML;
psEllipseXML =
CPLCreateXMLNode(
CPLCreateXMLNode(psDatumXML, CXT_Element, "gml:usesEllipsoid"),
CXT_Element, "gml:Ellipsoid");
addGMLId(psEllipseXML);
CPLCreateXMLElementAndValue(psEllipseXML, "gml:ellipsoidName",
poEllipsoid->GetChild(0)->GetValue());
exportAuthorityToXML(poEllipsoid, "gml:ellipsoidID", psEllipseXML,
"ellipsoid");
CPLXMLNode *psParmXML;
psParmXML = CPLCreateXMLNode(psEllipseXML, CXT_Element,
"gml:semiMajorAxis");
CPLCreateXMLNode(CPLCreateXMLNode(psParmXML, CXT_Attribute, "gml:uom"),
CXT_Text, "urn:ogc:def:uom:EPSG::9001");
CPLCreateXMLNode(psParmXML, CXT_Text,
poEllipsoid->GetChild(1)->GetValue());
psParmXML =
CPLCreateXMLNode(
CPLCreateXMLNode(psEllipseXML, CXT_Element,
"gml:secondDefiningParameter"),
CXT_Element, "gml:inverseFlattening");
CPLCreateXMLNode(CPLCreateXMLNode(psParmXML, CXT_Attribute, "gml:uom"),
CXT_Text, "urn:ogc:def:uom:EPSG::9201");
CPLCreateXMLNode(psParmXML, CXT_Text,
poEllipsoid->GetChild(2)->GetValue());
}
return psGCS_XML;
}
static CPLXMLNode* addAxis(CPLXMLNode *psXMLParent,
const char *pszAxis, // "Lat", "Long", "E" or "N"
const OGR_SRSNode* /* poUnitsSrc */)
{
CPLXMLNode *psAxisXML;
psAxisXML =
CPLCreateXMLNode(
CPLCreateXMLNode(psXMLParent, CXT_Element, "gml:usesAxis"),
CXT_Element, "gml:CoordinateSystemAxis");
addGMLId(psAxisXML);
if (EQUAL(pszAxis, "Lat"))
{
CPLCreateXMLNode(
CPLCreateXMLNode(psAxisXML, CXT_Attribute, "gml:uom"),
CXT_Text, "urn:ogc:def:uom:EPSG::9102");
CPLCreateXMLElementAndValue(psAxisXML, "gml:name",
"Geodetic latitude");
addAuthorityIDBlock(psAxisXML, "gml:axisID", "EPSG", "axis", 9901);
CPLCreateXMLElementAndValue(psAxisXML, "gml:axisAbbrev", "Lat");
CPLCreateXMLElementAndValue(psAxisXML, "gml:axisDirection", "north");
}
else if (EQUAL(pszAxis, "Long"))
{
CPLCreateXMLNode(
CPLCreateXMLNode(psAxisXML, CXT_Attribute, "gml:uom"),
CXT_Text, "urn:ogc:def:uom:EPSG::9102");
CPLCreateXMLElementAndValue(psAxisXML, "gml:name",
"Geodetic longitude");
addAuthorityIDBlock(psAxisXML, "gml:axisID", "EPSG", "axis", 9902);
CPLCreateXMLElementAndValue(psAxisXML, "gml:axisAbbrev", "Lon");
CPLCreateXMLElementAndValue(psAxisXML, "gml:axisDirection", "east");
}
else if (EQUAL(pszAxis, "E"))
{
CPLCreateXMLNode(
CPLCreateXMLNode(psAxisXML, CXT_Attribute, "gml:uom"),
CXT_Text, "urn:ogc:def:uom:EPSG::9001");
CPLCreateXMLElementAndValue(psAxisXML, "gml:name", "Easting");
addAuthorityIDBlock(psAxisXML, "gml:axisID", "EPSG", "axis", 9906);
CPLCreateXMLElementAndValue(psAxisXML, "gml:axisAbbrev", "E");
CPLCreateXMLElementAndValue(psAxisXML, "gml:axisDirection", "east");
}
else if (EQUAL(pszAxis, "N"))
{
CPLCreateXMLNode(
CPLCreateXMLNode(psAxisXML, CXT_Attribute, "gml:uom"),
CXT_Text, "urn:ogc:def:uom:EPSG::9001");
CPLCreateXMLElementAndValue(psAxisXML, "gml:name", "Northing");
addAuthorityIDBlock(psAxisXML, "gml:axisID", "EPSG", "axis", 9907);
CPLCreateXMLElementAndValue(psAxisXML, "gml:axisAbbrev", "N");
CPLCreateXMLElementAndValue(psAxisXML, "gml:axisDirection", "north");
}
else
{
CPLAssert(FALSE);
}
return psAxisXML;
}
CPLXMLNode *WCTSCollectKVPRequest()
{
char **papszParmList;
/* -------------------------------------------------------------------- */
/* Parse the query string. */
/* -------------------------------------------------------------------- */
if( getenv("QUERY_STRING") == NULL )
WCTSEmitServiceException( "QUERY_STRING not set." );
papszParmList = CSLTokenizeString2( getenv("QUERY_STRING"), "&",
CSLT_PRESERVEESCAPES );
/* -------------------------------------------------------------------- */
/* Un-url-encode the items. */
/* -------------------------------------------------------------------- */
int i;
for( i = 0; papszParmList != NULL && papszParmList[i] != NULL; i++ )
{
char *pszNewValue = CPLUnescapeString( papszParmList[i],
NULL, CPLES_URL );
CPLFree( papszParmList[i] );
papszParmList[i] = pszNewValue;
}
/* -------------------------------------------------------------------- */
/* Check for REQUEST */
/* -------------------------------------------------------------------- */
const char *pszVersion = CSLFetchNameValue(papszParmList,"VERSION");
const char *pszRequest = CSLFetchNameValue(papszParmList,"REQUEST");
if( pszRequest == NULL )
WCTSEmitServiceException( "REQUEST not provided in KVP URL." );
/* -------------------------------------------------------------------- */
/* Handle GetCapabilities */
/* -------------------------------------------------------------------- */
else if( EQUAL(pszRequest,"GetCapabilities") )
{
CPLXMLNode *psRequest = CPLCreateXMLNode( NULL, CXT_Element,
"GetCapabilities" );
if( pszVersion != NULL )
{
CPLCreateXMLNode(
CPLCreateXMLNode( psRequest, CXT_Attribute, "version" ),
CXT_Text, pszVersion );
}
if( CSLFetchNameValue(papszParmList,"SERVICE") != NULL )
{
CPLCreateXMLNode(
CPLCreateXMLNode( psRequest, CXT_Attribute, "service" ),
CXT_Text, CSLFetchNameValue(papszParmList,"SERVICE") );
}
return psRequest;
}
/* ==================================================================== */
/* Handle IsTransformable */
/* ==================================================================== */
else if( EQUAL(pszRequest,"IsTransformable") )
{
CPLXMLNode *psRequest = CPLCreateXMLNode( NULL, CXT_Element,
"IsTransformable" );
/* -------------------------------------------------------------------- */
/* Translate the source crs. */
/* -------------------------------------------------------------------- */
CPLAddXMLChild(
CPLCreateXMLNode( psRequest, CXT_Element, "SourceCRS" ),
WCTSAuthId2crsId( papszParmList, "SOURCECRS" ) );
/* -------------------------------------------------------------------- */
/* Translate the destination crs. */
/* -------------------------------------------------------------------- */
CPLAddXMLChild(
CPLCreateXMLNode( psRequest, CXT_Element, "TargetCRS" ),
WCTSAuthId2crsId( papszParmList, "TARGETCRS" ) );
/* -------------------------------------------------------------------- */
/* Handle version. */
/* -------------------------------------------------------------------- */
if( pszVersion != NULL )
{
CPLCreateXMLNode(
CPLCreateXMLNode( psRequest, CXT_Attribute, "version" ),
CXT_Text, pszVersion );
}
/* -------------------------------------------------------------------- */
/* geometric primitive. */
/* -------------------------------------------------------------------- */
if( CSLFetchNameValue(papszParmList,"GEOMETRICPRIMITIVE") != NULL )
{
CPLCreateXMLElementAndValue(
psRequest, "GeometricPrimitive",
CSLFetchNameValue(papszParmList,"GEOMETRICPRIMITIVE") );
}
/* Add COVERAGETYPE and COVERAGEINTERPOLATIONMETHOD layer? */
return psRequest;
}
/* -------------------------------------------------------------------- */
/* Unrecognised. */
/* -------------------------------------------------------------------- */
else
WCTSEmitServiceException(
CPLSPrintf( "Unrecognised REQUEST value (%.500s).", pszRequest) );
return NULL;
}
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" );
for( int iEntry=0; psPam->papszCategoryNames[iEntry] != NULL; iEntry++)
{
CPLCreateXMLElementAndValue( psCT_XML, "Category",
psPam->papszCategoryNames[iEntry] );
}
}
/* -------------------------------------------------------------------- */
/* Color Table. */
/* -------------------------------------------------------------------- */
if( psPam->poColorTable != NULL )
{
CPLXMLNode *psCT_XML = CPLCreateXMLNode( psTree, CXT_Element,
"ColorTable" );
for( int iEntry=0; iEntry < psPam->poColorTable->GetColorEntryCount();
iEntry++ )
{
GDALColorEntry sEntry;
CPLXMLNode *psEntry_XML = CPLCreateXMLNode( psCT_XML, CXT_Element,
"Entry" );
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;
}
CPLXMLNode *VRTRawRasterBand::SerializeToXML( const char *pszVRTPath )
{
/* -------------------------------------------------------------------- */
/* We can't set the layout if there is no open rawband. */
/* -------------------------------------------------------------------- */
if( m_poRawRaster == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"VRTRawRasterBand::SerializeToXML() fails because "
"m_poRawRaster is NULL." );
return NULL;
}
CPLXMLNode *psTree = VRTRasterBand::SerializeToXML( pszVRTPath );
/* -------------------------------------------------------------------- */
/* Set subclass. */
/* -------------------------------------------------------------------- */
CPLCreateXMLNode(
CPLCreateXMLNode( psTree, CXT_Attribute, "subClass" ),
CXT_Text, "VRTRawRasterBand" );
/* -------------------------------------------------------------------- */
/* Setup the filename with relative flag. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psNode
= CPLCreateXMLElementAndValue( psTree, "SourceFilename",
m_pszSourceFilename );
CPLCreateXMLNode(
CPLCreateXMLNode( psNode, CXT_Attribute, "relativeToVRT" ),
CXT_Text, m_bRelativeToVRT ? "1" : "0" );
/* -------------------------------------------------------------------- */
/* Set other layout information. */
/* -------------------------------------------------------------------- */
char szOffset[22] = { '\0' };
CPLPrintUIntBig( szOffset, m_poRawRaster->GetImgOffset(),
sizeof(szOffset) - 1 );
szOffset[sizeof(szOffset)-1] = '\0';
CPLCreateXMLElementAndValue( psTree, "ImageOffset",
VRTRawStripSpace(szOffset) );
CPLPrintUIntBig( szOffset, m_poRawRaster->GetPixelOffset(),
sizeof(szOffset) - 1 );
szOffset[sizeof(szOffset)-1] = '\0';
CPLCreateXMLElementAndValue( psTree, "PixelOffset",
VRTRawStripSpace(szOffset) );
CPLPrintUIntBig( szOffset, m_poRawRaster->GetLineOffset(),
sizeof(szOffset) - 1 );
szOffset[sizeof(szOffset)-1] = '\0';
CPLCreateXMLElementAndValue( psTree, "LineOffset",
VRTRawStripSpace(szOffset) );
#if CPL_IS_LSB == 1
if( m_poRawRaster->GetNativeOrder() )
#else
if( !m_poRawRaster->GetNativeOrder() )
#endif
CPLCreateXMLElementAndValue( psTree, "ByteOrder", "LSB" );
else
CPLCreateXMLElementAndValue( psTree, "ByteOrder", "MSB" );
return psTree;
}
