CPLXMLNode* GMLXercesHandler::AddAttributes(CPLXMLNode* psNode, void* attr)
{
const Attributes* attrs = (const Attributes*) attr;
CPLXMLNode* psLastChild = NULL;
for(unsigned int i=0; i < attrs->getLength(); i++)
{
char* pszName = tr_strdup(attrs->getQName(i));
char* pszValue = tr_strdup(attrs->getValue(i));
CPLXMLNode* psChild = CPLCreateXMLNode(NULL, CXT_Attribute, pszName);
CPLCreateXMLNode(psChild, CXT_Text, pszValue);
CPLFree(pszName);
CPLFree(pszValue);
if (psLastChild == NULL)
psNode->psChild = psChild;
else
psLastChild->psNext = psChild;
psLastChild = psChild;
}
return psLastChild;
}
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 *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;
}
static CPLXMLNode* CPLExtractSubSchema(CPLXMLNode* psSubXML, CPLXMLNode* psMainSchema)
{
if (psSubXML->eType == CXT_Element && strcmp(psSubXML->pszValue, "?xml") == 0)
{
CPLXMLNode* psNext = psSubXML->psNext;
psSubXML->psNext = NULL;
CPLDestroyXMLNode(psSubXML);
psSubXML = psNext;
}
if (psSubXML != NULL && psSubXML->eType == CXT_Comment)
{
CPLXMLNode* psNext = psSubXML->psNext;
psSubXML->psNext = NULL;
CPLDestroyXMLNode(psSubXML);
psSubXML = psNext;
}
if (psSubXML != NULL && psSubXML->eType == CXT_Element &&
(strcmp(psSubXML->pszValue, "schema") == 0 ||
strcmp(psSubXML->pszValue, "xs:schema") == 0 ||
strcmp(psSubXML->pszValue, "xsd:schema") == 0) &&
psSubXML->psNext == NULL)
{
CPLXMLNode* psNext = psSubXML->psChild;
while(psNext != NULL && psNext->eType != CXT_Element &&
psNext->psNext != NULL && psNext->psNext->eType != CXT_Element)
{
/* Add xmlns: from subschema to main schema if missing */
if (psNext->eType == CXT_Attribute &&
STARTS_WITH(psNext->pszValue, "xmlns:") &&
CPLGetXMLValue(psMainSchema, psNext->pszValue, NULL) == NULL)
{
CPLXMLNode* psAttr = CPLCreateXMLNode(NULL, CXT_Attribute, psNext->pszValue);
CPLCreateXMLNode(psAttr, CXT_Text, psNext->psChild->pszValue);
psAttr->psNext = psMainSchema->psChild;
psMainSchema->psChild = psAttr;
}
psNext = psNext->psNext;
}
if (psNext != NULL && psNext->eType != CXT_Element &&
psNext->psNext != NULL && psNext->psNext->eType == CXT_Element)
{
CPLXMLNode* psNext2 = psNext->psNext;
psNext->psNext = NULL;
CPLDestroyXMLNode(psSubXML);
psSubXML = psNext2;
}
}
return psSubXML;
}
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;
}
static CPLXMLNode* addAuthorityIDBlock(CPLXMLNode *psTarget,
const char *pszElement,
const char *pszAuthority,
const char *pszObjectType,
int nCode,
const char *pszVersion = "")
{
char szURN[200];
/* -------------------------------------------------------------------- */
/* Prepare partial URN without the actual code. */
/* -------------------------------------------------------------------- */
if (pszVersion == NULL)
pszVersion = "";
CPLAssert(strlen(pszAuthority) + strlen(pszObjectType) < sizeof(szURN) - 30);
sprintf(szURN, "urn:ogc:def:%s:%s:%s:",
pszObjectType, pszAuthority, pszVersion);
/* -------------------------------------------------------------------- */
/* Prepare the base name, eg. <srsID>. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psElement =
CPLCreateXMLNode(psTarget, CXT_Element, pszElement);
/* -------------------------------------------------------------------- */
/* Prepare the name element. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psName =
CPLCreateXMLNode(psElement, CXT_Element, "gml:name");
/* -------------------------------------------------------------------- */
/* Prepare the codespace attribute. */
/* -------------------------------------------------------------------- */
CPLCreateXMLNode(
CPLCreateXMLNode(psName, CXT_Attribute, "gml:codeSpace"),
CXT_Text, szURN);
/* -------------------------------------------------------------------- */
/* Attach code value to name node. */
/* -------------------------------------------------------------------- */
char szCode[32];
sprintf(szCode, "%d", nCode);
CPLCreateXMLNode(psName, CXT_Text, szCode);
return psElement;
}
CPLXMLNode *VRTWarpedRasterBand::SerializeToXML( const char *pszVRTPath )
{
CPLXMLNode *psTree = VRTRasterBand::SerializeToXML( pszVRTPath );
/* -------------------------------------------------------------------- */
/* Set subclass. */
/* -------------------------------------------------------------------- */
CPLCreateXMLNode(
CPLCreateXMLNode( psTree, CXT_Attribute, "subClass" ),
CXT_Text, "VRTWarpedRasterBand" );
return psTree;
}
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;
}
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;
}
CPLErr VRTRasterBand::GetHistogram( double dfMin, double dfMax,
int nBuckets, GUIntBig * panHistogram,
int bIncludeOutOfRange, int bApproxOK,
GDALProgressFunc pfnProgress,
void *pProgressData )
{
/* -------------------------------------------------------------------- */
/* Check if we have a matching histogram. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psHistItem = PamFindMatchingHistogram( m_psSavedHistograms,
dfMin, dfMax, nBuckets,
bIncludeOutOfRange, bApproxOK );
if( psHistItem != NULL )
{
GUIntBig *panTempHist = NULL;
if( PamParseHistogram( psHistItem, &dfMin, &dfMax, &nBuckets,
&panTempHist,
&bIncludeOutOfRange, &bApproxOK ) )
{
memcpy( panHistogram, panTempHist, sizeof(GUIntBig) * nBuckets );
CPLFree( panTempHist );
return CE_None;
}
}
/* -------------------------------------------------------------------- */
/* We don't have an existing histogram matching the request, so */
/* generate one manually. */
/* -------------------------------------------------------------------- */
CPLErr eErr = GDALRasterBand::GetHistogram( dfMin, dfMax,
nBuckets, panHistogram,
bIncludeOutOfRange, bApproxOK,
pfnProgress, pProgressData );
/* -------------------------------------------------------------------- */
/* Save an XML description of this histogram. */
/* -------------------------------------------------------------------- */
if( eErr == CE_None )
{
CPLXMLNode *psXMLHist = PamHistogramToXMLTree( dfMin, dfMax, nBuckets,
panHistogram,
bIncludeOutOfRange, bApproxOK );
if( psXMLHist != NULL )
{
reinterpret_cast<VRTDataset *>( poDS )->SetNeedsFlush();
if( m_psSavedHistograms == NULL )
m_psSavedHistograms = CPLCreateXMLNode( NULL, CXT_Element,
"Histograms" );
CPLAddXMLChild( m_psSavedHistograms, psXMLHist );
}
}
return eErr;
}
static void addGMLId(CPLXMLNode *psParent)
{
static void *hGMLIdMutex = NULL;
CPLMutexHolderD(&hGMLIdMutex);
CPLXMLNode *psId;
static int nNextGMLId = 1;
char szIdText[40];
sprintf(szIdText, "ogrcrs%d", nNextGMLId++);
psId =
CPLCreateXMLNode(
CPLCreateXMLNode(psParent, CXT_Attribute, "gml:id"),
CXT_Text, szIdText);
}
int OGRFMECacheIndex::Load()
{
/* -------------------------------------------------------------------- */
/* Lock the cache index file if not already locked. */
/* -------------------------------------------------------------------- */
if( hLock == NULL && !Lock() )
return FALSE;
if( psTree != NULL )
{
CPLDestroyXMLNode( psTree );
psTree = NULL;
}
/* -------------------------------------------------------------------- */
/* Open the index file. If we don't get it, we assume it is */
/* because it doesn't exist, and we create a "stub" tree in */
/* memory. */
/* -------------------------------------------------------------------- */
FILE *fpIndex;
int nLength;
char *pszIndexBuffer;
fpIndex = VSIFOpen( GetPath(), "rb" );
if( fpIndex == NULL )
{
psTree = CPLCreateXMLNode( NULL, CXT_Element, "OGRFMECacheIndex" );
return TRUE;
}
/* -------------------------------------------------------------------- */
/* Load the data from the file. */
/* -------------------------------------------------------------------- */
VSIFSeek( fpIndex, 0, SEEK_END );
nLength = VSIFTell( fpIndex );
VSIFSeek( fpIndex, 0, SEEK_SET );
pszIndexBuffer = (char *) CPLMalloc(nLength+1);
if( (int) VSIFRead( pszIndexBuffer, 1, nLength, fpIndex ) != nLength )
{
CPLError( CE_Failure, CPLE_FileIO,
"Read of %d byte index file failed.", nLength );
return FALSE;
}
VSIFClose( fpIndex );
/* -------------------------------------------------------------------- */
/* Parse the result into an inmemory XML tree. */
/* -------------------------------------------------------------------- */
pszIndexBuffer[nLength] = '\0';
psTree = CPLParseXMLString( pszIndexBuffer );
CPLFree( pszIndexBuffer );
return psTree != NULL;
}
CPLXMLNode *VRTKernelFilteredSource::SerializeToXML( const char *pszVRTPath )
{
CPLXMLNode *psSrc = VRTFilteredSource::SerializeToXML( pszVRTPath );
if( psSrc == nullptr )
return nullptr;
CPLFree( psSrc->pszValue );
psSrc->pszValue = CPLStrdup("KernelFilteredSource" );
if( m_nKernelSize == 0 )
return psSrc;
CPLXMLNode *psKernel = CPLCreateXMLNode( psSrc, CXT_Element, "Kernel" );
if( m_bNormalized )
CPLCreateXMLNode(
CPLCreateXMLNode( psKernel, CXT_Attribute, "normalized" ),
CXT_Text, "1" );
else
CPLCreateXMLNode(
CPLCreateXMLNode( psKernel, CXT_Attribute, "normalized" ),
CXT_Text, "0" );
const int nCoefCount = m_nKernelSize * m_nKernelSize;
const size_t nBufLen = nCoefCount * 32;
char *pszKernelCoefs = static_cast<char *>( CPLMalloc(nBufLen) );
strcpy( pszKernelCoefs, "" );
for( int iCoef = 0; iCoef < nCoefCount; iCoef++ )
CPLsnprintf( pszKernelCoefs + strlen(pszKernelCoefs),
nBufLen - strlen(pszKernelCoefs),
"%.8g ", m_padfKernelCoefs[iCoef] );
CPLSetXMLValue( psKernel, "Size", CPLSPrintf( "%d", m_nKernelSize ) );
CPLSetXMLValue( psKernel, "Coefs", pszKernelCoefs );
CPLFree( pszKernelCoefs );
return psSrc;
}
CPLXMLNode *VRTKernelFilteredSource::SerializeToXML( const char *pszVRTPath )
{
CPLXMLNode *psSrc = VRTFilteredSource::SerializeToXML( pszVRTPath );
CPLXMLNode *psKernel;
char *pszKernelCoefs;
int iCoef, nCoefCount = nKernelSize * nKernelSize;
if( psSrc == NULL )
return NULL;
CPLFree( psSrc->pszValue );
psSrc->pszValue = CPLStrdup("KernelFilteredSource" );
if( nKernelSize == 0 )
return psSrc;
psKernel = CPLCreateXMLNode( psSrc, CXT_Element, "Kernel" );
if( bNormalized )
CPLCreateXMLNode(
CPLCreateXMLNode( psKernel, CXT_Attribute, "normalized" ),
CXT_Text, "1" );
else
CPLCreateXMLNode(
CPLCreateXMLNode( psKernel, CXT_Attribute, "normalized" ),
CXT_Text, "0" );
pszKernelCoefs = (char *) CPLMalloc(nCoefCount * 32);
strcpy( pszKernelCoefs, "" );
for( iCoef = 0; iCoef < nCoefCount; iCoef++ )
CPLsprintf( pszKernelCoefs + strlen(pszKernelCoefs),
"%.8g ", padfKernelCoefs[iCoef] );
CPLSetXMLValue( psKernel, "Size", CPLSPrintf( "%d", nKernelSize ) );
CPLSetXMLValue( psKernel, "Coefs", pszKernelCoefs );
CPLFree( pszKernelCoefs );
return psSrc;
}
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;
}
static void addProjArg(const OGRSpatialReference *poSRS, CPLXMLNode *psBase,
const char *pszMeasureType, double dfDefault,
int nParameterID, const char *pszWKTName)
{
CPLXMLNode *psNode, *psValue;
psNode = CPLCreateXMLNode(psBase, CXT_Element, "gml:usesParameterValue");
/* -------------------------------------------------------------------- */
/* Handle the UOM. */
/* -------------------------------------------------------------------- */
const char *pszUOMValue;
if (EQUAL(pszMeasureType, "Angular"))
pszUOMValue = "urn:ogc:def:uom:EPSG::9102";
else
pszUOMValue = "urn:ogc:def:uom:EPSG::9001";
psValue = CPLCreateXMLNode(psNode, CXT_Element, "gml:value");
CPLCreateXMLNode(
CPLCreateXMLNode(psValue, CXT_Attribute, "gml:uom"),
CXT_Text, pszUOMValue);
/* -------------------------------------------------------------------- */
/* Add the parameter value itself. */
/* -------------------------------------------------------------------- */
double dfParmValue
= poSRS->GetNormProjParm(pszWKTName, dfDefault, NULL);
CPLCreateXMLNode(psValue, CXT_Text,
CPLString().Printf("%.16g", dfParmValue));
/* -------------------------------------------------------------------- */
/* Add the valueOfParameter. */
/* -------------------------------------------------------------------- */
AddValueIDWithURN(psNode, "gml:valueOfParameter", "EPSG", "parameter",
nParameterID);
}
CPLXMLNode* GMLExpatHandler::AddAttributes(CPLXMLNode* psNode, void* attr)
{
const char** papszIter = (const char** )attr;
CPLXMLNode* psLastChild = NULL;
while(*papszIter)
{
CPLXMLNode* psChild = CPLCreateXMLNode(NULL, CXT_Attribute, papszIter[0]);
CPLCreateXMLNode(psChild, CXT_Text, papszIter[1]);
if (psLastChild == NULL)
psNode->psChild = psChild;
else
psLastChild->psNext = psChild;
psLastChild = psChild;
papszIter += 2;
}
return psLastChild;
}
CPLXMLNode *VRTDerivedRasterBand::SerializeToXML(const char *pszVRTPath)
{
CPLXMLNode *psTree;
psTree = VRTSourcedRasterBand::SerializeToXML( pszVRTPath );
/* -------------------------------------------------------------------- */
/* Set subclass. */
/* -------------------------------------------------------------------- */
CPLCreateXMLNode(
CPLCreateXMLNode( psTree, CXT_Attribute, "subClass" ),
CXT_Text, "VRTDerivedRasterBand" );
/* ---- Encode DerivedBand-specific fields ---- */
if( pszFuncName != NULL && strlen(pszFuncName) > 0 )
CPLSetXMLValue(psTree, "PixelFunctionType", this->pszFuncName);
if( this->eSourceTransferType != GDT_Unknown)
CPLSetXMLValue(psTree, "SourceTransferType",
GDALGetDataTypeName(this->eSourceTransferType));
return psTree;
}
CPLXMLNode *
PamHistogramToXMLTree( double dfMin, double dfMax,
int nBuckets, GUIntBig * panHistogram,
int bIncludeOutOfRange, int bApprox )
{
char *pszHistCounts;
int iBucket;
size_t iHistOffset;
CPLXMLNode *psXMLHist;
CPLString oFmt;
if( nBuckets > (INT_MAX - 10) / 12 )
return NULL;
const size_t nLen = 22 * static_cast<size_t>(nBuckets) + 10;
pszHistCounts = (char *) VSIMalloc(nLen);
if( pszHistCounts == NULL )
return NULL;
psXMLHist = CPLCreateXMLNode( NULL, CXT_Element, "HistItem" );
CPLSetXMLValue( psXMLHist, "HistMin",
oFmt.Printf( "%.16g", dfMin ));
CPLSetXMLValue( psXMLHist, "HistMax",
oFmt.Printf( "%.16g", dfMax ));
CPLSetXMLValue( psXMLHist, "BucketCount",
oFmt.Printf( "%d", nBuckets ));
CPLSetXMLValue( psXMLHist, "IncludeOutOfRange",
oFmt.Printf( "%d", bIncludeOutOfRange ));
CPLSetXMLValue( psXMLHist, "Approximate",
oFmt.Printf( "%d", bApprox ));
iHistOffset = 0;
pszHistCounts[0] = '\0';
for( iBucket = 0; iBucket < nBuckets; iBucket++ )
{
snprintf( pszHistCounts + iHistOffset,
nLen - iHistOffset,
CPL_FRMT_GUIB, panHistogram[iBucket] );
if( iBucket < nBuckets-1 )
strcat( pszHistCounts + iHistOffset, "|" );
iHistOffset += strlen(pszHistCounts+iHistOffset);
}
CPLSetXMLValue( psXMLHist, "HistCounts", pszHistCounts );
CPLFree( pszHistCounts );
return psXMLHist;
}
CPLErr GDALPamRasterBand::SetDefaultHistogram( double dfMin, double dfMax,
int nBuckets, int *panHistogram)
{
CPLXMLNode *psNode;
PamInitialize();
if( psPam == NULL )
return GDALRasterBand::SetDefaultHistogram( dfMin, dfMax,
nBuckets, panHistogram );
/* -------------------------------------------------------------------- */
/* Do we have a matching histogram we should replace? */
/* -------------------------------------------------------------------- */
psNode = PamFindMatchingHistogram( psPam->psSavedHistograms,
dfMin, dfMax, nBuckets,
TRUE, TRUE );
if( psNode != NULL )
{
/* blow this one away */
CPLRemoveXMLChild( psPam->psSavedHistograms, psNode );
CPLDestroyXMLNode( psNode );
}
/* -------------------------------------------------------------------- */
/* Translate into a histogram XML tree. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psHistItem;
psHistItem = PamHistogramToXMLTree( dfMin, dfMax, nBuckets,
panHistogram, TRUE, FALSE );
if( psHistItem == NULL )
return CE_Failure;
/* -------------------------------------------------------------------- */
/* Insert our new default histogram at the front of the */
/* histogram list so that it will be the default histogram. */
/* -------------------------------------------------------------------- */
psPam->poParentDS->MarkPamDirty();
if( psPam->psSavedHistograms == NULL )
psPam->psSavedHistograms = CPLCreateXMLNode( NULL, CXT_Element,
"Histograms" );
psHistItem->psNext = psPam->psSavedHistograms->psChild;
psPam->psSavedHistograms->psChild = psHistItem;
return CE_None;
}
static void addURN(CPLXMLNode *psTarget,
const char *pszAuthority,
const char *pszObjectType,
int nCode,
const char *pszVersion = "")
{
char szURN[200];
if (pszVersion == NULL)
pszVersion = "";
CPLAssert(strlen(pszAuthority) + strlen(pszObjectType) < sizeof(szURN) - 30);
sprintf(szURN, "urn:ogc:def:%s:%s:%s:",
pszObjectType, pszAuthority, pszVersion);
if (nCode != 0)
sprintf(szURN + strlen(szURN), "%d", nCode);
CPLCreateXMLNode(
CPLCreateXMLNode(psTarget, CXT_Attribute, "xlink:href"),
CXT_Text, szURN);
}
static CPLXMLNode*
AddValueIDWithURN(CPLXMLNode *psTarget,
const char *pszElement,
const char *pszAuthority,
const char *pszObjectType,
int nCode,
const char *pszVersion = "")
{
CPLXMLNode *psElement;
psElement = CPLCreateXMLNode(psTarget, CXT_Element, pszElement);
addURN(psElement, pszAuthority, pszObjectType, nCode, pszVersion);
return psElement;
}
CPLErr VRTRasterBand::SetDefaultHistogram( double dfMin, double dfMax,
int nBuckets, GUIntBig *panHistogram)
{
CPLXMLNode *psNode;
/* -------------------------------------------------------------------- */
/* Do we have a matching histogram we should replace? */
/* -------------------------------------------------------------------- */
psNode = PamFindMatchingHistogram( psSavedHistograms,
dfMin, dfMax, nBuckets,
TRUE, TRUE );
if( psNode != NULL )
{
/* blow this one away */
CPLRemoveXMLChild( psSavedHistograms, psNode );
CPLDestroyXMLNode( psNode );
}
/* -------------------------------------------------------------------- */
/* Translate into a histogram XML tree. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psHistItem;
psHistItem = PamHistogramToXMLTree( dfMin, dfMax, nBuckets,
panHistogram, TRUE, FALSE );
if( psHistItem == NULL )
return CE_Failure;
/* -------------------------------------------------------------------- */
/* Insert our new default histogram at the front of the */
/* histogram list so that it will be the default histogram. */
/* -------------------------------------------------------------------- */
((VRTDataset *) poDS)->SetNeedsFlush();
if( psSavedHistograms == NULL )
psSavedHistograms = CPLCreateXMLNode( NULL, CXT_Element,
"Histograms" );
psHistItem->psNext = psSavedHistograms->psChild;
psSavedHistograms->psChild = psHistItem;
return CE_None;
}
int GMLReader::SaveClasses( const char *pszFile )
{
// Add logic later to determine reasonable default schema file.
if( pszFile == NULL )
return FALSE;
/* -------------------------------------------------------------------- */
/* Create in memory schema tree. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRoot;
psRoot = CPLCreateXMLNode( NULL, CXT_Element, "GMLFeatureClassList" );
for( int iClass = 0; iClass < GetClassCount(); iClass++ )
{
GMLFeatureClass *poClass = GetClass( iClass );
CPLAddXMLChild( psRoot, poClass->SerializeToXML() );
}
/* -------------------------------------------------------------------- */
/* Serialize to disk. */
/* -------------------------------------------------------------------- */
FILE *fp;
int bSuccess = TRUE;
char *pszWholeText = CPLSerializeXMLTree( psRoot );
CPLDestroyXMLNode( psRoot );
fp = VSIFOpen( pszFile, "wb" );
if( fp == NULL )
bSuccess = FALSE;
else if( VSIFWrite( pszWholeText, strlen(pszWholeText), 1, fp ) != 1 )
bSuccess = FALSE;
else
VSIFClose( fp );
CPLFree( pszWholeText );
return bSuccess;
}
CPLXMLNode *
PamHistogramToXMLTree( double dfMin, double dfMax,
int nBuckets, int * panHistogram,
int bIncludeOutOfRange, int bApprox )
{
char *pszHistCounts = (char *) CPLMalloc(12 * nBuckets + 10);
int iBucket, iHistOffset;
CPLXMLNode *psXMLHist;
CPLString oFmt;
psXMLHist = CPLCreateXMLNode( NULL, CXT_Element, "HistItem" );
CPLSetXMLValue( psXMLHist, "HistMin",
oFmt.Printf( "%.16g", dfMin ));
CPLSetXMLValue( psXMLHist, "HistMax",
oFmt.Printf( "%.16g", dfMax ));
CPLSetXMLValue( psXMLHist, "BucketCount",
oFmt.Printf( "%d", nBuckets ));
CPLSetXMLValue( psXMLHist, "IncludeOutOfRange",
oFmt.Printf( "%d", bIncludeOutOfRange ));
CPLSetXMLValue( psXMLHist, "Approximate",
oFmt.Printf( "%d", bApprox ));
iHistOffset = 0;
pszHistCounts[0] = '\0';
for( iBucket = 0; iBucket < nBuckets; iBucket++ )
{
sprintf( pszHistCounts + iHistOffset, "%d", panHistogram[iBucket] );
if( iBucket < nBuckets-1 )
strcat( pszHistCounts + iHistOffset, "|" );
iHistOffset += strlen(pszHistCounts+iHistOffset);
}
CPLSetXMLValue( psXMLHist, "HistCounts", pszHistCounts );
CPLFree( pszHistCounts );
return psXMLHist;
}
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;
}
CPLErr GDALPamRasterBand::GetHistogram( double dfMin, double dfMax,
int nBuckets, int * panHistogram,
int bIncludeOutOfRange, int bApproxOK,
GDALProgressFunc pfnProgress,
void *pProgressData )
{
PamInitialize();
if( psPam == NULL )
return GDALRasterBand::GetHistogram( dfMin, dfMax,
nBuckets, panHistogram,
bIncludeOutOfRange, bApproxOK,
pfnProgress, pProgressData );
/* -------------------------------------------------------------------- */
/* Check if we have a matching histogram. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psHistItem;
psHistItem = PamFindMatchingHistogram( psPam->psSavedHistograms,
dfMin, dfMax, nBuckets,
bIncludeOutOfRange, bApproxOK );
if( psHistItem != NULL )
{
int *panTempHist = NULL;
if( PamParseHistogram( psHistItem, &dfMin, &dfMax, &nBuckets,
&panTempHist,
&bIncludeOutOfRange, &bApproxOK ) )
{
memcpy( panHistogram, panTempHist, sizeof(int) * nBuckets );
CPLFree( panTempHist );
return CE_None;
}
}
/* -------------------------------------------------------------------- */
/* We don't have an existing histogram matching the request, so */
/* generate one manually. */
/* -------------------------------------------------------------------- */
CPLErr eErr;
eErr = GDALRasterBand::GetHistogram( dfMin, dfMax,
nBuckets, panHistogram,
bIncludeOutOfRange, bApproxOK,
pfnProgress, pProgressData );
/* -------------------------------------------------------------------- */
/* Save an XML description of this histogram. */
/* -------------------------------------------------------------------- */
if( eErr == CE_None )
{
CPLXMLNode *psXMLHist;
psXMLHist = PamHistogramToXMLTree( dfMin, dfMax, nBuckets,
panHistogram,
bIncludeOutOfRange, bApproxOK );
if( psXMLHist != NULL )
{
psPam->poParentDS->MarkPamDirty();
if( psPam->psSavedHistograms == NULL )
psPam->psSavedHistograms = CPLCreateXMLNode( NULL, CXT_Element,
"Histograms" );
CPLAddXMLChild( psPam->psSavedHistograms, psXMLHist );
}
}
return eErr;
}
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" );
CPLXMLNode* psLastChild = NULL;
if( pszGCPProjection != NULL && strlen(pszGCPProjection) > 0 )
{
CPLSetXMLValue( psGCPList, "#Projection", pszGCPProjection );
psLastChild = psGCPList->psChild;
}
for( int iGCP = 0; iGCP < nGCPCount; iGCP++ )
{
CPLXMLNode *psXMLGCP;
GDAL_GCP *psGCP = pasGCPList + iGCP;
psXMLGCP = CPLCreateXMLNode( NULL, CXT_Element, "GCP" );
if( psLastChild == NULL )
psGCPList->psChild = psXMLGCP;
else
psLastChild->psNext = psXMLGCP;
psLastChild = psXMLGCP;
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;
}
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;
}
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;
}
