/**
* LoadMetadata()
*/
void GDALMDReaderResursDK1::LoadMetadata()
{
if(m_bIsMetadataLoad)
return;
if (!m_osXMLSourceFilename.empty())
{
CPLXMLNode* psNode = CPLParseXMLFile(m_osXMLSourceFilename);
if(psNode != NULL)
{
CPLXMLNode* pMSPRootNode = CPLSearchXMLNode(psNode, "=MSP_ROOT");
if(pMSPRootNode != NULL)
{
m_papszIMDMD = ReadXMLToList(pMSPRootNode, m_papszIMDMD, "MSP_ROOT");
}
CPLDestroyXMLNode(psNode);
}
}
m_papszDEFAULTMD = CSLAddNameValue(m_papszDEFAULTMD, MD_NAME_MDTYPE, "MSP");
m_bIsMetadataLoad = true;
if(NULL == m_papszIMDMD)
{
return;
}
//extract imagery metadata
const char* pszSatId = CSLFetchNameValue(m_papszIMDMD, "MSP_ROOT.cCodeKA");
if(NULL != pszSatId)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_SATELLITE,
CPLStripQuotes(pszSatId));
}
const char* pszDate = CSLFetchNameValue(m_papszIMDMD,
"MSP_ROOT.Normal.dSceneDate");
if(NULL != pszDate)
{
const char* pszTime = CSLFetchNameValue(m_papszIMDMD,
"MSP_ROOT.Normal.tSceneTime");
if(NULL == pszTime)
pszTime = "00:00:00.000000";
char buffer[80];
time_t timeMid = GetAcquisitionTimeFromString(CPLSPrintf( "%s %s",
pszDate, pszTime));
strftime (buffer, 80, MD_DATETIMEFORMAT, localtime(&timeMid));
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_ACQDATETIME, buffer);
}
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_CLOUDCOVER,
MD_CLOUDCOVER_NA);
}
/**
* LoadMetadata()
*/
void GDALMDReaderRapidEye::LoadMetadata()
{
if(m_bIsMetadataLoad)
return;
CPLXMLNode* psNode = CPLParseXMLFile(m_osXMLSourceFilename);
if(psNode != NULL)
{
CPLXMLNode* pRootNode = CPLSearchXMLNode(psNode, "=re:EarthObservation");
if(pRootNode != NULL)
{
m_papszIMDMD = ReadXMLToList(pRootNode->psChild, m_papszIMDMD);
}
CPLDestroyXMLNode(psNode);
}
m_papszDEFAULTMD = CSLAddNameValue(m_papszDEFAULTMD, MD_NAME_MDTYPE, "RE");
m_bIsMetadataLoad = true;
if(NULL == m_papszIMDMD)
{
return;
}
//extract imagery metadata
const char* pszSatId = CSLFetchNameValue(m_papszIMDMD,
"gml:using.eop:EarthObservationEquipment.eop:platform.eop:Platform.eop:serialIdentifier");
if(NULL != pszSatId)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_SATELLITE, CPLStripQuotes(pszSatId));
}
const char* pszDateTime = CSLFetchNameValue(m_papszIMDMD,
"gml:using.eop:EarthObservationEquipment.eop:acquisitionParameters.re:Acquisition.re:acquisitionDateTime");
if(NULL != pszDateTime)
{
char buffer[80];
time_t timeMid = GetAcquisitionTimeFromString(pszDateTime);
strftime (buffer, 80, MD_DATETIMEFORMAT, localtime(&timeMid));
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_ACQDATETIME, buffer);
}
const char* pszCC = CSLFetchNameValue(m_papszIMDMD,
"gml:resultOf.re:EarthObservationResult.opt:cloudCoverPercentage");
if(NULL != pszSatId)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_CLOUDCOVER, pszCC);
}
}
void BAGDataset::LoadMetadata()
{
/* -------------------------------------------------------------------- */
/* Load the metadata from the file. */
/* -------------------------------------------------------------------- */
hid_t hMDDS = H5Dopen( hHDF5, "/BAG_root/metadata" );
hid_t datatype = H5Dget_type( hMDDS );
hid_t dataspace = H5Dget_space( hMDDS );
hid_t native = H5Tget_native_type( datatype, H5T_DIR_ASCEND );
hsize_t dims[3], maxdims[3];
H5Sget_simple_extent_dims( dataspace, dims, maxdims );
pszXMLMetadata = (char *) CPLCalloc(dims[0]+1,1);
H5Dread( hMDDS, native, H5S_ALL, dataspace, H5P_DEFAULT, pszXMLMetadata );
H5Sclose( dataspace );
H5Tclose( datatype );
H5Dclose( hMDDS );
if( strlen(pszXMLMetadata) == 0 )
return;
/* -------------------------------------------------------------------- */
/* Try to get the geotransform. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRoot = CPLParseXMLString( pszXMLMetadata );
if( psRoot == NULL )
return;
CPLStripXMLNamespace( psRoot, NULL, TRUE );
CPLXMLNode *psGeo = CPLSearchXMLNode( psRoot, "=MD_Georectified" );
if( psGeo != NULL )
{
char **papszCornerTokens =
CSLTokenizeStringComplex(
CPLGetXMLValue( psGeo, "cornerPoints.Point.coordinates", "" ),
" ,", FALSE, FALSE );
if( CSLCount(papszCornerTokens ) == 4 )
{
double dfLLX = atof( papszCornerTokens[0] );
double dfLLY = atof( papszCornerTokens[1] );
double dfURX = atof( papszCornerTokens[2] );
double dfURY = atof( papszCornerTokens[3] );
adfGeoTransform[0] = dfLLX;
adfGeoTransform[1] = (dfURX - dfLLX) / (GetRasterXSize()-1);
adfGeoTransform[3] = dfURY;
adfGeoTransform[5] = (dfLLY - dfURY) / (GetRasterYSize()-1);
adfGeoTransform[0] -= adfGeoTransform[1] * 0.5;
adfGeoTransform[3] -= adfGeoTransform[5] * 0.5;
}
CSLDestroy( papszCornerTokens );
}
CPLDestroyXMLNode( psRoot );
/* -------------------------------------------------------------------- */
/* Try to get the coordinate system. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS;
if( OGR_SRS_ImportFromISO19115( &oSRS, pszXMLMetadata )
== OGRERR_NONE )
{
oSRS.exportToWkt( &pszProjection );
}
}
OGRErr BAGDataset::ParseWKTFromXML( const char *pszISOXML )
{
OGRSpatialReference oSRS;
CPLXMLNode *psRoot = CPLParseXMLString( pszISOXML );
OGRErr eOGRErr = OGRERR_FAILURE;
if( psRoot == NULL )
return eOGRErr;
CPLStripXMLNamespace( psRoot, NULL, TRUE );
CPLXMLNode *psRSI = CPLSearchXMLNode( psRoot, "=referenceSystemInfo" );
if( psRSI == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to find <referenceSystemInfo> in metadata." );
CPLDestroyXMLNode( psRoot );
return eOGRErr;
}
oSRS.Clear();
const char *pszSRCodeString =
CPLGetXMLValue( psRSI, "MD_ReferenceSystem.referenceSystemIdentifier.RS_Identifier.code.CharacterString", NULL );
if( pszSRCodeString == NULL )
{
CPLDebug("BAG",
"Unable to find /MI_Metadata/referenceSystemInfo[1]/MD_ReferenceSystem[1]/referenceSystemIdentifier[1]/RS_Identifier[1]/code[1]/CharacterString[1] in metadata." );
CPLDestroyXMLNode( psRoot );
return eOGRErr;
}
const char *pszSRCodeSpace =
CPLGetXMLValue( psRSI, "MD_ReferenceSystem.referenceSystemIdentifier.RS_Identifier.codeSpace.CharacterString", "" );
if( !EQUAL( pszSRCodeSpace, "WKT" ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Spatial reference string is not in WKT." );
CPLDestroyXMLNode( psRoot );
return eOGRErr;
}
char* pszWKT = const_cast< char* >( pszSRCodeString );
if( oSRS.importFromWkt( &pszWKT ) != OGRERR_NONE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed parsing WKT string \"%s\".", pszSRCodeString );
CPLDestroyXMLNode( psRoot );
return eOGRErr;
}
oSRS.exportToWkt( &pszProjection );
eOGRErr = OGRERR_NONE;
psRSI = CPLSearchXMLNode( psRSI->psNext, "=referenceSystemInfo" );
if( psRSI == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to find second instance of <referenceSystemInfo> in metadata." );
CPLDestroyXMLNode( psRoot );
return eOGRErr;
}
pszSRCodeString =
CPLGetXMLValue( psRSI, "MD_ReferenceSystem.referenceSystemIdentifier.RS_Identifier.code.CharacterString", NULL );
if( pszSRCodeString == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to find /MI_Metadata/referenceSystemInfo[2]/MD_ReferenceSystem[1]/referenceSystemIdentifier[1]/RS_Identifier[1]/code[1]/CharacterString[1] in metadata." );
CPLDestroyXMLNode( psRoot );
return eOGRErr;
}
pszSRCodeSpace =
CPLGetXMLValue( psRSI, "MD_ReferenceSystem.referenceSystemIdentifier.RS_Identifier.codeSpace.CharacterString", "" );
if( !EQUAL( pszSRCodeSpace, "WKT" ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Spatial reference string is not in WKT." );
CPLDestroyXMLNode( psRoot );
return eOGRErr;
}
if( EQUALN(pszSRCodeString, "VERTCS", 6 ) )
{
CPLString oString( pszProjection );
oString += ",";
oString += pszSRCodeString;
if ( pszProjection )
CPLFree( pszProjection );
pszProjection = CPLStrdup( oString );
}
CPLDestroyXMLNode( psRoot );
return eOGRErr;
}
int GDALJP2Metadata::ParseGMLCoverageDesc()
{
/* -------------------------------------------------------------------- */
/* Do we have an XML doc that is apparently a coverage */
/* description? */
/* -------------------------------------------------------------------- */
const char *pszCoverage = CSLFetchNameValue( papszGMLMetadata,
"gml.root-instance" );
if( pszCoverage == NULL )
return FALSE;
CPLDebug( "GDALJP2Metadata", "Found GML Box:\n%s", pszCoverage );
/* -------------------------------------------------------------------- */
/* Try parsing the XML. Wipe any namespace prefixes. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psXML = CPLParseXMLString( pszCoverage );
if( psXML == NULL )
return FALSE;
CPLStripXMLNamespace( psXML, NULL, TRUE );
/* -------------------------------------------------------------------- */
/* Isolate RectifiedGrid. Eventually we will need to support */
/* other georeferencing objects. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRG = CPLSearchXMLNode( psXML, "=RectifiedGrid" );
CPLXMLNode *psOriginPoint = NULL;
const char *pszOffset1=NULL, *pszOffset2=NULL;
if( psRG != NULL )
{
psOriginPoint = CPLGetXMLNode( psRG, "origin.Point" );
CPLXMLNode *psOffset1 = CPLGetXMLNode( psRG, "offsetVector" );
if( psOffset1 != NULL )
{
pszOffset1 = CPLGetXMLValue( psOffset1, "", NULL );
pszOffset2 = CPLGetXMLValue( psOffset1->psNext, "=offsetVector",
NULL );
}
}
/* -------------------------------------------------------------------- */
/* If we are missing any of the origin or 2 offsets then give up. */
/* -------------------------------------------------------------------- */
if( psOriginPoint == NULL || pszOffset1 == NULL || pszOffset2 == NULL )
{
CPLDestroyXMLNode( psXML );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Extract origin location. */
/* -------------------------------------------------------------------- */
OGRPoint *poOriginGeometry = NULL;
const char *pszSRSName = NULL;
if( psOriginPoint != NULL )
{
poOriginGeometry = (OGRPoint *)
OGR_G_CreateFromGMLTree( psOriginPoint );
if( poOriginGeometry != NULL
&& wkbFlatten(poOriginGeometry->getGeometryType()) != wkbPoint )
{
delete poOriginGeometry;
poOriginGeometry = NULL;
}
// SRS?
pszSRSName = CPLGetXMLValue( psOriginPoint, "srsName", NULL );
}
/* -------------------------------------------------------------------- */
/* Extract offset(s) */
/* -------------------------------------------------------------------- */
char **papszOffset1Tokens = NULL;
char **papszOffset2Tokens = NULL;
int bSuccess = FALSE;
papszOffset1Tokens =
CSLTokenizeStringComplex( pszOffset1, " ,", FALSE, FALSE );
papszOffset2Tokens =
CSLTokenizeStringComplex( pszOffset2, " ,", FALSE, FALSE );
if( CSLCount(papszOffset1Tokens) >= 2
&& CSLCount(papszOffset2Tokens) >= 2
&& poOriginGeometry != NULL )
{
adfGeoTransform[0] = poOriginGeometry->getX();
adfGeoTransform[1] = atof(papszOffset1Tokens[0]);
adfGeoTransform[2] = atof(papszOffset2Tokens[0]);
adfGeoTransform[3] = poOriginGeometry->getY();
adfGeoTransform[4] = atof(papszOffset1Tokens[1]);
adfGeoTransform[5] = atof(papszOffset2Tokens[1]);
// offset from center of pixel.
adfGeoTransform[0] -= adfGeoTransform[1]*0.5;
adfGeoTransform[0] -= adfGeoTransform[2]*0.5;
adfGeoTransform[3] -= adfGeoTransform[4]*0.5;
adfGeoTransform[3] -= adfGeoTransform[5]*0.5;
bSuccess = TRUE;
bHaveGeoTransform = TRUE;
}
CSLDestroy( papszOffset1Tokens );
CSLDestroy( papszOffset2Tokens );
if( poOriginGeometry != NULL )
delete poOriginGeometry;
/* -------------------------------------------------------------------- */
/* If we still don't have an srsName, check for it on the */
/* boundedBy Envelope. Some products */
/* (ie. EuropeRasterTile23.jpx) use this as the only srsName */
/* delivery vehicle. */
/* -------------------------------------------------------------------- */
if( pszSRSName == NULL )
{
pszSRSName =
CPLGetXMLValue( psXML,
"=FeatureCollection.boundedBy.Envelope.srsName",
NULL );
}
/* -------------------------------------------------------------------- */
/* If we have gotten a geotransform, then try to interprete the */
/* srsName. */
/* -------------------------------------------------------------------- */
int bNeedAxisFlip = FALSE;
if( bSuccess && pszSRSName != NULL
&& (pszProjection == NULL || strlen(pszProjection) == 0) )
{
OGRSpatialReference oSRS;
if( EQUALN(pszSRSName,"epsg:",5) )
{
if( oSRS.SetFromUserInput( pszSRSName ) == OGRERR_NONE )
oSRS.exportToWkt( &pszProjection );
}
else if( EQUALN(pszSRSName,"urn:",4)
&& strstr(pszSRSName,":def:") != NULL
&& oSRS.importFromURN(pszSRSName) == OGRERR_NONE )
{
const char *pszCode = strrchr(pszSRSName,':') + 1;
oSRS.exportToWkt( &pszProjection );
// Per #2131
if( atoi(pszCode) >= 4000 && atoi(pszCode) <= 4999 )
{
CPLDebug( "GMLJP2", "Request axis flip for SRS=%s",
pszSRSName );
bNeedAxisFlip = TRUE;
}
}
else if( !GMLSRSLookup( pszSRSName ) )
{
CPLDebug( "GDALJP2Metadata",
"Unable to evaluate SRSName=%s",
pszSRSName );
}
}
if( pszProjection )
CPLDebug( "GDALJP2Metadata",
"Got projection from GML box: %s",
pszProjection );
CPLDestroyXMLNode( psXML );
psXML = NULL;
/* -------------------------------------------------------------------- */
/* Do we need to flip the axes? */
/* -------------------------------------------------------------------- */
if( bNeedAxisFlip
&& CSLTestBoolean( CPLGetConfigOption( "GDAL_IGNORE_AXIS_ORIENTATION",
"FALSE" ) ) )
{
bNeedAxisFlip = FALSE;
CPLDebug( "GMLJP2", "Supressed axis flipping based on GDAL_IGNORE_AXIS_ORIENTATION." );
}
if( bNeedAxisFlip )
{
double dfTemp;
CPLDebug( "GMLJP2",
"Flipping axis orientation in GMLJP2 coverage description." );
dfTemp = adfGeoTransform[0];
adfGeoTransform[0] = adfGeoTransform[3];
adfGeoTransform[3] = dfTemp;
dfTemp = adfGeoTransform[1];
adfGeoTransform[1] = adfGeoTransform[4];
adfGeoTransform[4] = dfTemp;
dfTemp = adfGeoTransform[2];
adfGeoTransform[2] = adfGeoTransform[5];
adfGeoTransform[5] = dfTemp;
}
return pszProjection != NULL && bSuccess;
}
static CPLXMLNode *
GetDictionaryItem( char **papszGMLMetadata, const char *pszURN )
{
char *pszLabel;
const char *pszFragmentId = NULL;
int i;
if( EQUALN(pszURN,"urn:jp2k:xml:", 13) )
pszLabel = CPLStrdup( pszURN + 13 );
else if( EQUALN(pszURN,"urn:ogc:tc:gmljp2:xml:", 22) )
pszLabel = CPLStrdup( pszURN + 22 );
else if( EQUALN(pszURN,"gmljp2://xml/",13) )
pszLabel = CPLStrdup( pszURN + 13 );
else
pszLabel = CPLStrdup( pszURN );
/* -------------------------------------------------------------------- */
/* Split out label and fragment id. */
/* -------------------------------------------------------------------- */
for( i = 0; pszLabel[i] != '#'; i++ )
{
if( pszLabel[i] == '\0' )
return NULL;
}
pszFragmentId = pszLabel + i + 1;
pszLabel[i] = '\0';
/* -------------------------------------------------------------------- */
/* Can we find an XML box with the desired label? */
/* -------------------------------------------------------------------- */
const char *pszDictionary =
CSLFetchNameValue( papszGMLMetadata, pszLabel );
if( pszDictionary == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Try and parse the dictionary. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psDictTree = CPLParseXMLString( pszDictionary );
if( psDictTree == NULL )
{
CPLDestroyXMLNode( psDictTree );
return NULL;
}
CPLStripXMLNamespace( psDictTree, NULL, TRUE );
CPLXMLNode *psDictRoot = CPLSearchXMLNode( psDictTree, "=Dictionary" );
if( psDictRoot == NULL )
{
CPLDestroyXMLNode( psDictTree );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Search for matching id. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psEntry, *psHit = NULL;
for( psEntry = psDictRoot->psChild;
psEntry != NULL && psHit == NULL;
psEntry = psEntry->psNext )
{
const char *pszId;
if( psEntry->eType != CXT_Element )
continue;
if( !EQUAL(psEntry->pszValue,"dictionaryEntry") )
continue;
if( psEntry->psChild == NULL )
continue;
pszId = CPLGetXMLValue( psEntry->psChild, "id", "" );
if( EQUAL(pszId, pszFragmentId) )
psHit = CPLCloneXMLTree( psEntry->psChild );
}
/* -------------------------------------------------------------------- */
/* Cleanup */
/* -------------------------------------------------------------------- */
CPLFree( pszLabel );
CPLDestroyXMLNode( psDictTree );
return psHit;
}
/**
* LoadMetadata()
*/
void GDALMDReaderSpot::LoadMetadata()
{
if(m_bIsMetadataLoad)
return;
if (!m_osIMDSourceFilename.empty())
{
CPLXMLNode* psNode = CPLParseXMLFile(m_osIMDSourceFilename);
if(psNode != NULL)
{
CPLXMLNode* psisdNode = CPLSearchXMLNode(psNode, "=Dimap_Document");
if(psisdNode != NULL)
{
m_papszIMDMD = ReadXMLToList(psisdNode->psChild, m_papszIMDMD);
}
CPLDestroyXMLNode(psNode);
}
}
m_papszDEFAULTMD = CSLAddNameValue(m_papszDEFAULTMD, MD_NAME_MDTYPE, "DIMAP");
m_bIsMetadataLoad = true;
if(NULL == m_papszIMDMD)
{
return;
}
//extract imagery metadata
int nCounter = -1;
const char* pszSatId1 = CSLFetchNameValue(m_papszIMDMD,
"Dataset_Sources.Source_Information.Scene_Source.MISSION");
if(NULL == pszSatId1)
{
nCounter = 1;
for(int i = 0; i < 5; i++)
{
pszSatId1 = CSLFetchNameValue(m_papszIMDMD,
CPLSPrintf("Dataset_Sources.Source_Information_%d.Scene_Source.MISSION",
nCounter));
if(NULL != pszSatId1)
break;
nCounter++;
}
}
const char* pszSatId2;
if(nCounter == -1)
pszSatId2 = CSLFetchNameValue(m_papszIMDMD,
"Dataset_Sources.Source_Information.Scene_Source.MISSION_INDEX");
else
pszSatId2 = CSLFetchNameValue(m_papszIMDMD, CPLSPrintf(
"Dataset_Sources.Source_Information_%d.Scene_Source.MISSION_INDEX",
nCounter));
if(NULL != pszSatId1 && NULL != pszSatId2)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_SATELLITE, CPLSPrintf( "%s %s",
CPLStripQuotes(pszSatId1).c_str(),
CPLStripQuotes(pszSatId2).c_str()));
}
else if(NULL != pszSatId1 && NULL == pszSatId2)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_SATELLITE, CPLStripQuotes(pszSatId1));
}
else if(NULL == pszSatId1 && NULL != pszSatId2)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_SATELLITE, CPLStripQuotes(pszSatId2));
}
const char* pszDate;
if(nCounter == -1)
pszDate = CSLFetchNameValue(m_papszIMDMD,
"Dataset_Sources.Source_Information.Scene_Source.IMAGING_DATE");
else
pszDate = CSLFetchNameValue(m_papszIMDMD, CPLSPrintf(
"Dataset_Sources.Source_Information_%d.Scene_Source.IMAGING_DATE",
nCounter));
if(NULL != pszDate)
{
const char* pszTime;
if(nCounter == -1)
pszTime = CSLFetchNameValue(m_papszIMDMD,
"Dataset_Sources.Source_Information.Scene_Source.IMAGING_TIME");
else
pszTime = CSLFetchNameValue(m_papszIMDMD, CPLSPrintf(
"Dataset_Sources.Source_Information_%d.Scene_Source.IMAGING_TIME",
nCounter));
if(NULL == pszTime)
pszTime = "00:00:00.0Z";
char buffer[80];
time_t timeMid = GetAcquisitionTimeFromString(CPLSPrintf( "%sT%s",
pszDate, pszTime));
strftime (buffer, 80, MD_DATETIMEFORMAT, localtime(&timeMid));
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_ACQDATETIME, buffer);
}
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_CLOUDCOVER,
MD_CLOUDCOVER_NA);
}
OGRErr OGR_SRS_ImportFromISO19115( OGRSpatialReference *poThis,
const char *pszISOXML )
{
/* -------------------------------------------------------------------- */
/* Parse the XML into tree form. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRoot = CPLParseXMLString( pszISOXML );
if( psRoot == NULL )
return OGRERR_FAILURE;
CPLStripXMLNamespace( psRoot, NULL, TRUE );
/* -------------------------------------------------------------------- */
/* For now we look for projection codes recognised in the BAG */
/* format (see ons_fsd.pdf: Metadata Dataset Character String */
/* Constants). */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRSI = CPLSearchXMLNode( psRoot, "=referenceSystemInfo" );
if( psRSI == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to find <referenceSystemInfo> in metadata." );
CPLDestroyXMLNode( psRoot );
return OGRERR_FAILURE;
}
poThis->Clear();
/* -------------------------------------------------------------------- */
/* First, set the datum. */
/* -------------------------------------------------------------------- */
const char *pszDatum =
CPLGetXMLValue( psRSI, "MD_CRS.datum.RS_Identifier.code", "" );
if( strlen(pszDatum) > 0
&& poThis->SetWellKnownGeogCS( pszDatum ) != OGRERR_NONE )
{
CPLDestroyXMLNode( psRoot );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Then try to extract the projection. */
/* -------------------------------------------------------------------- */
const char *pszProjection =
CPLGetXMLValue( psRSI, "MD_CRS.projection.RS_Identifier.code", "" );
if( EQUAL(pszProjection,"UTM") )
{
int nZone = atoi(CPLGetXMLValue( psRSI, "MD_CRS.projectionParameters.MD_ProjectionParameters.zone", "0" ));
poThis->SetUTM( ABS(nZone), nZone > 0 );
}
else if( EQUAL(pszProjection,"Geodetic") )
{
const char *pszEllipsoid =
CPLGetXMLValue( psRSI, "MD_CRS.ellipsoid.RS_Identifier.code", "" );
if( !EQUAL(pszDatum, "WGS84") ||
!EQUAL(pszEllipsoid, "WGS84") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"ISO 19115 parser does not support custom GCS." );
CPLDestroyXMLNode( psRoot );
return OGRERR_FAILURE;
}
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"projection = %s not recognised by ISO 19115 parser.",
pszProjection );
CPLDestroyXMLNode( psRoot );
return OGRERR_FAILURE;
}
CPLDestroyXMLNode( psRoot );
return OGRERR_NONE;
}
void BAGDataset::LoadMetadata()
{
// Load the metadata from the file.
const hid_t hMDDS = H5Dopen(hHDF5, "/BAG_root/metadata");
const hid_t datatype = H5Dget_type(hMDDS);
const hid_t dataspace = H5Dget_space(hMDDS);
const hid_t native = H5Tget_native_type(datatype, H5T_DIR_ASCEND);
hsize_t dims[3] = {
static_cast<hsize_t>(0),
static_cast<hsize_t>(0),
static_cast<hsize_t>(0)
};
hsize_t maxdims[3] = {
static_cast<hsize_t>(0),
static_cast<hsize_t>(0),
static_cast<hsize_t>(0)
};
H5Sget_simple_extent_dims(dataspace, dims, maxdims);
pszXMLMetadata =
static_cast<char *>(CPLCalloc(static_cast<int>(dims[0] + 1), 1));
H5Dread(hMDDS, native, H5S_ALL, dataspace, H5P_DEFAULT, pszXMLMetadata);
H5Tclose(native);
H5Sclose(dataspace);
H5Tclose(datatype);
H5Dclose(hMDDS);
if( strlen(pszXMLMetadata) == 0 )
return;
// Try to get the geotransform.
CPLXMLNode *psRoot = CPLParseXMLString(pszXMLMetadata);
if( psRoot == nullptr )
return;
CPLStripXMLNamespace(psRoot, nullptr, TRUE);
CPLXMLNode *const psGeo = CPLSearchXMLNode(psRoot, "=MD_Georectified");
if( psGeo != nullptr )
{
char **papszCornerTokens = CSLTokenizeStringComplex(
CPLGetXMLValue(psGeo, "cornerPoints.Point.coordinates", ""), " ,",
FALSE, FALSE);
if( CSLCount(papszCornerTokens) == 4 )
{
const double dfLLX = CPLAtof(papszCornerTokens[0]);
const double dfLLY = CPLAtof(papszCornerTokens[1]);
const double dfURX = CPLAtof(papszCornerTokens[2]);
const double dfURY = CPLAtof(papszCornerTokens[3]);
adfGeoTransform[0] = dfLLX;
adfGeoTransform[1] = (dfURX - dfLLX) / (GetRasterXSize() - 1);
adfGeoTransform[3] = dfURY;
adfGeoTransform[5] = (dfLLY - dfURY) / (GetRasterYSize() - 1);
adfGeoTransform[0] -= adfGeoTransform[1] * 0.5;
adfGeoTransform[3] -= adfGeoTransform[5] * 0.5;
}
CSLDestroy(papszCornerTokens);
}
// Try to get the coordinate system.
OGRSpatialReference oSRS;
if( OGR_SRS_ImportFromISO19115(&oSRS, pszXMLMetadata) == OGRERR_NONE )
{
oSRS.exportToWkt(&pszProjection);
}
else
{
ParseWKTFromXML(pszXMLMetadata);
}
// Fetch acquisition date.
CPLXMLNode *const psDateTime = CPLSearchXMLNode(psRoot, "=dateTime");
if( psDateTime != nullptr )
{
const char *pszDateTimeValue = CPLGetXMLValue(psDateTime, nullptr, "");
if( pszDateTimeValue )
SetMetadataItem("BAG_DATETIME", pszDateTimeValue);
}
CPLDestroyXMLNode(psRoot);
}
CPLErr GDALParseGMLCoverage( CPLXMLNode *psXML,
int *pnXSize, int *pnYSize,
double *padfGeoTransform,
char **ppszProjection )
{
CPLStripXMLNamespace( psXML, NULL, TRUE );
/* -------------------------------------------------------------------- */
/* Isolate RectifiedGrid. Eventually we will need to support */
/* other georeferencing objects. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psRG = CPLSearchXMLNode( psXML, "=RectifiedGrid" );
CPLXMLNode *psOriginPoint = NULL;
const char *pszOffset1=NULL, *pszOffset2=NULL;
if( psRG != NULL )
{
psOriginPoint = CPLGetXMLNode( psRG, "origin.Point" );
if( psOriginPoint == NULL )
psOriginPoint = CPLGetXMLNode( psRG, "origin" );
CPLXMLNode *psOffset1 = CPLGetXMLNode( psRG, "offsetVector" );
if( psOffset1 != NULL )
{
pszOffset1 = CPLGetXMLValue( psOffset1, "", NULL );
pszOffset2 = CPLGetXMLValue( psOffset1->psNext, "=offsetVector",
NULL );
}
}
/* -------------------------------------------------------------------- */
/* If we are missing any of the origin or 2 offsets then give up. */
/* -------------------------------------------------------------------- */
if( psRG == NULL || psOriginPoint == NULL
|| pszOffset1 == NULL || pszOffset2 == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to find GML RectifiedGrid, origin or offset vectors");
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Search for the GridEnvelope and derive the raster size. */
/* -------------------------------------------------------------------- */
char **papszLow = CSLTokenizeString(
CPLGetXMLValue( psRG, "limits.GridEnvelope.low", ""));
char **papszHigh = CSLTokenizeString(
CPLGetXMLValue( psRG, "limits.GridEnvelope.high",""));
if( CSLCount(papszLow) < 2 || CSLCount(papszHigh) < 2 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to find or parse GridEnvelope.low/high." );
return CE_Failure;
}
if( pnXSize != NULL )
*pnXSize = atoi(papszHigh[0]) - atoi(papszLow[0]) + 1;
if( pnYSize != NULL )
*pnYSize = atoi(papszHigh[1]) - atoi(papszLow[1]) + 1;
CSLDestroy( papszLow );
CSLDestroy( papszHigh );
/* -------------------------------------------------------------------- */
/* Extract origin location. */
/* -------------------------------------------------------------------- */
OGRPoint *poOriginGeometry = NULL;
const char *pszSRSName = NULL;
if( psOriginPoint != NULL )
{
int bOldWrap = FALSE;
// old coverages (ie. WCS) just have <pos> under <origin> so we
// may need to temporarily force <origin> to <Point>
if( psOriginPoint->eType == CXT_Element
&& EQUAL(psOriginPoint->pszValue,"origin") )
{
strcpy( psOriginPoint->pszValue, "Point");
bOldWrap = TRUE;
}
poOriginGeometry = (OGRPoint *)
OGR_G_CreateFromGMLTree( psOriginPoint );
if( poOriginGeometry != NULL
&& wkbFlatten(poOriginGeometry->getGeometryType()) != wkbPoint )
{
delete poOriginGeometry;
poOriginGeometry = NULL;
}
if( bOldWrap )
strcpy( psOriginPoint->pszValue, "origin");
// SRS?
pszSRSName = CPLGetXMLValue( psOriginPoint, "srsName", NULL );
}
/* -------------------------------------------------------------------- */
/* Extract offset(s) */
/* -------------------------------------------------------------------- */
char **papszOffset1Tokens = NULL;
char **papszOffset2Tokens = NULL;
int bSuccess = FALSE;
papszOffset1Tokens =
CSLTokenizeStringComplex( pszOffset1, " ,", FALSE, FALSE );
papszOffset2Tokens =
CSLTokenizeStringComplex( pszOffset2, " ,", FALSE, FALSE );
if( CSLCount(papszOffset1Tokens) >= 2
&& CSLCount(papszOffset2Tokens) >= 2
&& poOriginGeometry != NULL )
{
padfGeoTransform[0] = poOriginGeometry->getX();
padfGeoTransform[1] = atof(papszOffset1Tokens[0]);
padfGeoTransform[2] = atof(papszOffset1Tokens[1]);
padfGeoTransform[3] = poOriginGeometry->getY();
padfGeoTransform[4] = atof(papszOffset2Tokens[0]);
padfGeoTransform[5] = atof(papszOffset2Tokens[1]);
// offset from center of pixel.
padfGeoTransform[0] -= padfGeoTransform[1]*0.5;
padfGeoTransform[0] -= padfGeoTransform[2]*0.5;
padfGeoTransform[3] -= padfGeoTransform[4]*0.5;
padfGeoTransform[3] -= padfGeoTransform[5]*0.5;
bSuccess = TRUE;
//bHaveGeoTransform = TRUE;
}
CSLDestroy( papszOffset1Tokens );
CSLDestroy( papszOffset2Tokens );
if( poOriginGeometry != NULL )
delete poOriginGeometry;
/* -------------------------------------------------------------------- */
/* If we have gotten a geotransform, then try to interprete the */
/* srsName. */
/* -------------------------------------------------------------------- */
if( bSuccess && pszSRSName != NULL
&& (*ppszProjection == NULL || strlen(*ppszProjection) == 0) )
{
if( EQUALN(pszSRSName,"epsg:",5) )
{
OGRSpatialReference oSRS;
if( oSRS.SetFromUserInput( pszSRSName ) == OGRERR_NONE )
oSRS.exportToWkt( ppszProjection );
}
else if( EQUALN(pszSRSName,"urn:ogc:def:crs:",16) )
{
OGRSpatialReference oSRS;
if( oSRS.importFromURN( pszSRSName ) == OGRERR_NONE )
oSRS.exportToWkt( ppszProjection );
}
else
*ppszProjection = CPLStrdup(pszSRSName);
}
if( *ppszProjection )
CPLDebug( "GDALJP2Metadata",
"Got projection from GML box: %s",
*ppszProjection );
return CE_None;
}
CPLErr GDALWMSMiniDriver_TiledWMS::Initialize(CPLXMLNode *config, CPL_UNUSED char **OpenOptions)
{
CPLErr ret = CE_None;
CPLXMLNode *tileServiceConfig=NULL;
CPLHTTPResult *psResult=NULL;
CPLXMLNode *TG=NULL;
char **requests=NULL;
char **substs=NULL;
char **keys=NULL;
for (int once=1;once;once--) { // Something to break out of
// Parse info from the service
m_end_url = CPLGetXMLValue(config,"AdditionalArgs","");
m_base_url = CPLGetXMLValue(config, "ServerURL", "");
if (m_base_url.empty()) {
CPLError(ret=CE_Failure, CPLE_AppDefined, "%s ServerURL missing.",SIG);
break;
}
CPLString tiledGroupName (CPLGetXMLValue(config, "TiledGroupName", ""));
if (tiledGroupName.empty()) {
CPLError(ret=CE_Failure, CPLE_AppDefined, "%s TiledGroupName missing.",SIG);
break;
}
// Change strings, key is an attribute, value is the value of the Change node
// Multiple substitutions are possible
TG=CPLSearchXMLNode(config, "Change");
while(TG!=NULL) {
CPLString name=CPLGetXMLValue(TG,"key","");
if (name.empty()) {
CPLError(ret=CE_Failure, CPLE_AppDefined,
"%s Change element needs a non-empty \"key\" attribute",SIG);
break;
}
substs=CSLSetNameValue(substs,name,CPLGetXMLValue(TG,"",""));
TG=SearchXMLSiblings(TG,"Change");
}
if (ret!=CE_None) break;
CPLString getTileServiceUrl = m_base_url + "request=GetTileService";
psResult = CPLHTTPFetch(getTileServiceUrl, NULL);
if (NULL==psResult) {
CPLError(ret=CE_Failure, CPLE_AppDefined, "%s Can't use HTTP", SIG);
break;
}
if ((psResult->nStatus!=0)||(NULL==psResult->pabyData)||('\0'==psResult->pabyData[0])) {
CPLError(ret=CE_Failure, CPLE_AppDefined, "%s Server response error on GetTileService.",SIG);
break;
}
if (NULL==(tileServiceConfig=CPLParseXMLString((const char*)psResult->pabyData))) {
CPLError(ret=CE_Failure,CPLE_AppDefined, "%s Error parsing the GetTileService response.",SIG);
break;
}
if (NULL==(TG=CPLSearchXMLNode(tileServiceConfig, "TiledPatterns"))) {
CPLError(ret=CE_Failure,CPLE_AppDefined,
"%s Can't locate TiledPatterns in server response.",SIG);
break;
}
// Get the global base_url and bounding box, these can be overwritten at the tileGroup level
// They are just pointers into existing structures, cleanup is not required
const char *global_base_url=CPLGetXMLValue(tileServiceConfig,"TiledPatterns.OnlineResource.xlink:href","");
CPLXMLNode *global_latlonbbox=CPLGetXMLNode(tileServiceConfig, "TiledPatterns.LatLonBoundingBox");
CPLXMLNode *global_bbox=CPLGetXMLNode(tileServiceConfig, "TiledPatterns.BoundingBox");
if (NULL==(TG=SearchLeafGroupName(TG->psChild,tiledGroupName))) {
CPLError(ret=CE_Failure,CPLE_AppDefined,
"%s Can't locate TiledGroup ""%s"" in server response.",SIG,
tiledGroupName.c_str());
break;
}
int band_count=atoi(CPLGetXMLValue(TG, "Bands", "3"));
if (!GDALCheckBandCount(band_count, FALSE)) {
CPLError(ret=CE_Failure,CPLE_AppDefined,"%s%s",SIG,
"Invalid number of bands in server response");
break;
}
// Collect all keys defined by this tileset
if (NULL!=CPLGetXMLNode(TG,"Key")) {
CPLXMLNode *node=CPLGetXMLNode(TG,"Key");
while (NULL!=node) {
const char *val=CPLGetXMLValue(node,NULL,NULL);
if (val) keys=CSLAddString(keys,val);
node=SearchXMLSiblings(node,"Key");
}
}
// Data values are attributes, they include NoData Min and Max
if (NULL!=CPLGetXMLNode(TG,"DataValues")) {
const char *nodata=CPLGetXMLValue(TG,"DataValues.NoData",NULL);
if (nodata!=NULL) m_parent_dataset->WMSSetNoDataValue(nodata);
const char *min=CPLGetXMLValue(TG,"DataValues.min",NULL);
if (min!=NULL) m_parent_dataset->WMSSetMinValue(min);
const char *max=CPLGetXMLValue(TG,"DataValues.max",NULL);
if (max!=NULL) m_parent_dataset->WMSSetMaxValue(max);
}
m_parent_dataset->WMSSetBandsCount(band_count);
m_parent_dataset->WMSSetDataType(GDALGetDataTypeByName(CPLGetXMLValue(TG, "DataType", "Byte")));
m_projection_wkt=CPLGetXMLValue(TG, "Projection","");
m_base_url=CPLGetXMLValue(TG,"OnlineResource.xlink:href",global_base_url);
if (m_base_url[0]=='\0') {
CPLError(ret=CE_Failure,CPLE_AppDefined, "%s%s",SIG,
"Can't locate OnlineResource in the server response.");
break;
}
// Bounding box, local, global, local lat-lon, global lat-lon, in this order
CPLXMLNode *bbox = CPLGetXMLNode(TG, "BoundingBox");
if (NULL==bbox) bbox=global_bbox;
if (NULL==bbox) bbox=CPLGetXMLNode(TG, "LatLonBoundingBox");
if (NULL==bbox) bbox=global_latlonbbox;
if (NULL==bbox) {
CPLError(ret=CE_Failure,CPLE_AppDefined,"%s%s",SIG,
"Can't locate the LatLonBoundingBox in server response.");
break;
}
m_data_window.m_x0=CPLAtof(CPLGetXMLValue(bbox,"minx","0"));
m_data_window.m_x1=CPLAtof(CPLGetXMLValue(bbox,"maxx","-1"));
m_data_window.m_y0=CPLAtof(CPLGetXMLValue(bbox,"maxy","0"));
m_data_window.m_y1=CPLAtof(CPLGetXMLValue(bbox,"miny","-1"));
if ((m_data_window.m_x1-m_data_window.m_x0)<0) {
CPLError(ret=CE_Failure,CPLE_AppDefined,"%s%s", SIG,
"Coordinate order in BBox, problem in server response");
break;
}
// Is there a palette?
//
// Format is
// <Palette>
// <Size>N</Size> : Optional
// <Model>RGBA|RGB|CMYK|HSV|HLS|L</Model> :mandatory
// <Entry idx=i c1=v1 c2=v2 c3=v3 c4=v4/> :Optional
// <Entry .../>
// </Palette>
// the idx attribute is optional, it autoincrements
// The entries are actually vertices, interpolation takes place inside
// The palette starts initialized with zeros
// HSV and HLS are the similar, with c2 and c3 swapped
// RGB or RGBA are same
//
GDALColorTable *poColorTable=NULL;
if ((band_count==1) && CPLGetXMLNode(TG,"Palette")) {
CPLXMLNode *node=CPLGetXMLNode(TG,"Palette");
int entries=static_cast<int>(getXMLNum(node,"Size","255"));
GDALPaletteInterp eInterp=GPI_RGB;
CPLString pModel=CPLGetXMLValue(node,"Model","RGB");
if (!pModel.empty() && pModel.find("RGB")!=std::string::npos)
eInterp=GPI_RGB;
else {
CPLError(CE_Failure, CPLE_AppDefined,
"%s Palette Model %s is unknown, use RGB or RGBA",
SIG, pModel.c_str());
return CE_Failure;
}
if ((entries>0)&&(entries<257)) {
int start_idx, end_idx;
GDALColorEntry ce_start={0,0,0,255},ce_end={0,0,0,255};
// Create it and initialize it to nothing
poColorTable = new GDALColorTable(eInterp);
poColorTable->CreateColorRamp(0,&ce_start,entries-1,&ce_end);
// Read the values
CPLXMLNode *p=CPLGetXMLNode(node,"Entry");
if (p) {
// Initialize the first entry
start_idx=static_cast<int>(getXMLNum(p,"idx","0"));
ce_start=GetXMLColorEntry(p);
if (start_idx<0) {
CPLError(CE_Failure, CPLE_AppDefined,
"%s Palette index %d not allowed",SIG,start_idx);
delete poColorTable;
return CE_Failure;
}
poColorTable->SetColorEntry(start_idx,&ce_start);
while (NULL!=(p=SearchXMLSiblings(p,"Entry"))) {
// For every entry, create a ramp
ce_end=GetXMLColorEntry(p);
end_idx=static_cast<int>(getXMLNum(p,"idx",CPLString().FormatC(start_idx+1).c_str()));
if ((end_idx<=start_idx)||(start_idx>=entries)) {
CPLError(CE_Failure, CPLE_AppDefined,
"%s Index Error at index %d",SIG,end_idx);
delete poColorTable;
return CE_Failure;
}
poColorTable->CreateColorRamp(start_idx,&ce_start,
end_idx,&ce_end);
ce_start=ce_end;
start_idx=end_idx;
}
}
m_parent_dataset->SetColorTable(poColorTable);
} else {
CPLError(CE_Failure, CPLE_AppDefined,"%s Palette definition error",SIG);
return CE_Failure;
}
}
int overview_count=0;
CPLXMLNode *Pattern=TG->psChild;
m_bsx=m_bsy=-1;
m_data_window.m_sx=m_data_window.m_sy=0;
for (int once2=1;once2;once2--) { // Something to break out of
while ((NULL!=Pattern)&&(NULL!=(Pattern=SearchXMLSiblings(Pattern,"=TilePattern")))) {
int mbsx,mbsy;
CPLString request;
FindChangePattern(Pattern->psChild->pszValue,substs,keys,request);
char **papszTokens=CSLTokenizeString2(request,"&",0);
const char* pszWIDTH = CSLFetchNameValue(papszTokens,"WIDTH");
const char* pszHEIGHT = CSLFetchNameValue(papszTokens,"HEIGHT");
if (pszWIDTH == NULL || pszHEIGHT == NULL)
{
CPLError(ret=CE_Failure,CPLE_AppDefined,"%s%s",SIG,
"Cannot find width and/or height parameters.");
overview_count=0;
CSLDestroy(papszTokens);
break;
}
mbsx=atoi(pszWIDTH);
mbsy=atoi(pszHEIGHT);
if (m_projection_wkt.empty()) {
m_projection_wkt = CSLFetchNameValueDef(papszTokens,"SRS", "");
if (!m_projection_wkt.empty())
m_projection_wkt=ProjToWKT(m_projection_wkt);
}
if (-1==m_bsx) m_bsx=mbsx;
if (-1==m_bsy) m_bsy=mbsy;
if ((m_bsx!=mbsx)||(m_bsy!=mbsy)) {
CPLError(ret=CE_Failure,CPLE_AppDefined,"%s%s",SIG,
"Tileset uses different block sizes.");
overview_count=0;
CSLDestroy(papszTokens);
break;
}
double x,y,X,Y;
if (CPLsscanf(CSLFetchNameValueDef(papszTokens,"BBOX", ""),"%lf,%lf,%lf,%lf",&x,&y,&X,&Y)!=4)
{
CPLError(ret=CE_Failure,CPLE_AppDefined,
"%s Error parsing BBOX, pattern %d\n",SIG,overview_count+1);
CSLDestroy(papszTokens);
break;
}
// Pick the largest size
int sx=static_cast<int>((m_data_window.m_x1-m_data_window.m_x0)/(X-x)*m_bsx);
int sy=static_cast<int>(fabs((m_data_window.m_y1-m_data_window.m_y0)/(Y-y)*m_bsy));
if (sx>m_data_window.m_sx) m_data_window.m_sx=sx;
if (sy>m_data_window.m_sy) m_data_window.m_sy=sy;
CSLDestroy(papszTokens);
// Only use overlays where the top coordinate is within a pixel from the top of coverage
double pix_off,temp;
pix_off=m_bsy*modf(fabs((Y-m_data_window.m_y0)/(Y-y)),&temp);
if ((pix_off<1)||((m_bsy-pix_off)<1)) {
requests=CSLAddString(requests,request);
overview_count++;
} else
CPLError(CE_Warning,CPLE_AppDefined,
"%s Overlay size %dX%d can't be used due to alignment",SIG,sx,sy);
Pattern=Pattern->psNext;
}
// The tlevel is needed, the tx and ty are not used by this minidriver
m_data_window.m_tlevel = 0;
m_data_window.m_tx = 0;
m_data_window.m_ty = 0;
// Make sure the parent_dataset values are set before creating the bands
m_parent_dataset->WMSSetBlockSize(m_bsx,m_bsy);
m_parent_dataset->WMSSetRasterSize(m_data_window.m_sx,m_data_window.m_sy);
m_parent_dataset->WMSSetDataWindow(m_data_window);
//m_parent_dataset->WMSSetOverviewCount(overview_count);
m_parent_dataset->WMSSetClamp(false);
// Ready for the Rasterband creation
for (int i=0;i<overview_count;i++) {
CPLString request=GetLowestScale(requests,i);
double scale=Scale(request);
// Base scale should be very close to 1
if ((0==i)&&(fabs(scale-1) > 1e-6)) {
CPLError(ret=CE_Failure,CPLE_AppDefined,"%s%s",SIG,
"Base resolution pattern missing.");
break;
}
// Prepare the request and insert it back into the list
// Find returns an answer relative to the original string start!
size_t startBbox=FindBbox(request);
size_t endBbox=request.find('&',startBbox);
if (endBbox==std::string::npos) endBbox=request.size();
request.replace(startBbox,endBbox-startBbox,"${GDAL_BBOX}");
requests = CSLInsertString(requests,i,request);
// Create the Rasterband or overview
for (int j = 1; j <= band_count; j++) {
if (i!=0)
m_parent_dataset->mGetBand(j)->AddOverview(scale);
else { // Base resolution
GDALWMSRasterBand *band=new
GDALWMSRasterBand(m_parent_dataset,j,1);
if (poColorTable!=NULL) band->SetColorInterpretation(GCI_PaletteIndex);
else band->SetColorInterpretation(BandInterp(band_count,j));
m_parent_dataset->mSetBand(j, band);
};
}
}
if ((overview_count==0)||(m_bsx<1)||(m_bsy<1)) {
CPLError(ret=CE_Failure,CPLE_AppDefined,
"%s No usable TilePattern elements found",SIG);
break;
}
}
}
CSLDestroy(keys);
CSLDestroy(substs);
if (tileServiceConfig) CPLDestroyXMLNode(tileServiceConfig);
if (psResult) CPLHTTPDestroyResult(psResult);
m_requests=requests;
return ret;
}
int main(int nArgc, char* papszArgv[])
{
const char *pszFilename = NULL, *pszOutFilename = NULL;
DDFModule oModule;
/* -------------------------------------------------------------------- */
/* Check arguments. */
/* -------------------------------------------------------------------- */
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( pszFilename == NULL )
pszFilename = papszArgv[iArg];
else if( pszOutFilename == NULL )
pszOutFilename = papszArgv[iArg];
else
{
pszFilename = NULL;
break;
}
}
if( pszFilename == NULL )
{
printf( "Usage: 8211createfromxml filename.xml outfilename\n" );
exit( 1 );
}
CPLXMLNode* poRoot = CPLParseXMLFile( pszFilename );
if( poRoot == NULL )
{
fprintf(stderr, "Cannot parse XML file '%s'\n", pszFilename);
exit( 1 );
}
CPLXMLNode* poXMLDDFModule = CPLSearchXMLNode(poRoot, "=DDFModule");
if( poXMLDDFModule == NULL )
{
fprintf(stderr, "Cannot find DDFModule node in XML file '%s'\n", pszFilename);
exit( 1 );
}
/* Compute the size of the DDFField tag */
CPLXMLNode* psIter = poXMLDDFModule->psChild;
int nSizeFieldTag = 0;
while( psIter != NULL )
{
if( psIter->eType == CXT_Element &&
strcmp(psIter->pszValue, "DDFFieldDefn") == 0 )
{
const char* pszTag = CPLGetXMLValue(psIter, "tag", "");
if( nSizeFieldTag == 0 )
nSizeFieldTag = (int)strlen(pszTag);
else if( nSizeFieldTag != (int)strlen(pszTag) )
{
fprintf(stderr, "All fields have not the same tag size\n");
exit( 1 );
}
}
psIter = psIter->psNext;
}
char chInterchangeLevel = '3';
char chLeaderIden = 'L';
char chCodeExtensionIndicator = 'E';
char chVersionNumber = '1';
char chAppIndicator = ' ';
const char *pszExtendedCharSet = " ! ";
int nSizeFieldLength = 3;
int nSizeFieldPos = 4;
chInterchangeLevel = CPLGetXMLValue(poXMLDDFModule, "_interchangeLevel", CPLSPrintf("%c", chInterchangeLevel))[0];
chLeaderIden = CPLGetXMLValue(poXMLDDFModule, "_leaderIden", CPLSPrintf("%c", chLeaderIden))[0];
chCodeExtensionIndicator = CPLGetXMLValue(poXMLDDFModule, "_inlineCodeExtensionIndicator", CPLSPrintf("%c", chCodeExtensionIndicator))[0];
chVersionNumber = CPLGetXMLValue(poXMLDDFModule, "_versionNumber", CPLSPrintf("%c", chVersionNumber))[0];
chAppIndicator = CPLGetXMLValue(poXMLDDFModule, "_appIndicator", CPLSPrintf("%c", chAppIndicator))[0];
char szExtendedCharSet[4];
snprintf(szExtendedCharSet, sizeof(szExtendedCharSet), "%s", CPLGetXMLValue(poXMLDDFModule, "_extendedCharSet", pszExtendedCharSet));
pszExtendedCharSet = szExtendedCharSet;
nSizeFieldLength = atoi(CPLGetXMLValue(poXMLDDFModule, "_sizeFieldLength", CPLSPrintf("%d", nSizeFieldLength)));
nSizeFieldPos = atoi(CPLGetXMLValue(poXMLDDFModule, "_sizeFieldPos", CPLSPrintf("%d", nSizeFieldPos)));
nSizeFieldTag = atoi(CPLGetXMLValue(poXMLDDFModule, "_sizeFieldTag", CPLSPrintf("%d", nSizeFieldTag)));
oModule.Initialize(chInterchangeLevel,
chLeaderIden,
chCodeExtensionIndicator,
chVersionNumber,
chAppIndicator,
pszExtendedCharSet,
nSizeFieldLength,
nSizeFieldPos,
nSizeFieldTag);
oModule.SetFieldControlLength(atoi(CPLGetXMLValue(poXMLDDFModule, "_fieldControlLength", CPLSPrintf("%d", oModule.GetFieldControlLength()))));
int bCreated = FALSE;
/* Create DDFFieldDefn and DDFRecord elements */
psIter = poXMLDDFModule->psChild;
while( psIter != NULL )
{
if( psIter->eType == CXT_Element &&
strcmp(psIter->pszValue, "DDFFieldDefn") == 0 )
{
DDFFieldDefn* poFDefn = new DDFFieldDefn();
DDF_data_struct_code eStructCode = dsc_elementary;
const char* pszStructCode = CPLGetXMLValue(psIter, "dataStructCode", "");
if( strcmp(pszStructCode, "elementary") == 0 ) eStructCode = dsc_elementary;
else if( strcmp(pszStructCode, "vector") == 0 ) eStructCode = dsc_vector;
else if( strcmp(pszStructCode, "array") == 0 ) eStructCode = dsc_array;
else if( strcmp(pszStructCode, "concatenated") == 0 ) eStructCode = dsc_concatenated;
DDF_data_type_code eTypeCode = dtc_char_string;
const char* pszTypeCode = CPLGetXMLValue(psIter, "dataTypeCode", "");
if( strcmp(pszTypeCode, "char_string") == 0 ) eTypeCode = dtc_char_string;
else if( strcmp(pszTypeCode, "implicit_point") == 0 ) eTypeCode = dtc_implicit_point;
else if( strcmp(pszTypeCode, "explicit_point") == 0 ) eTypeCode = dtc_explicit_point;
else if( strcmp(pszTypeCode, "explicit_point_scaled") == 0 ) eTypeCode = dtc_explicit_point_scaled;
else if( strcmp(pszTypeCode, "char_bit_string") == 0 ) eTypeCode = dtc_char_bit_string;
else if( strcmp(pszTypeCode, "bit_string") == 0 ) eTypeCode = dtc_bit_string;
else if( strcmp(pszTypeCode, "mixed_data_type") == 0 ) eTypeCode = dtc_mixed_data_type;
const char* pszFormatControls = CPLGetXMLValue(psIter, "formatControls", NULL);
if( eStructCode != dsc_elementary )
pszFormatControls = NULL;
const char* pszArrayDescr = CPLGetXMLValue(psIter, "arrayDescr", "");
if( eStructCode == dsc_vector )
pszArrayDescr = "";
else if( eStructCode == dsc_array )
pszArrayDescr = "*";
poFDefn->Create( CPLGetXMLValue(psIter, "tag", ""),
CPLGetXMLValue(psIter, "fieldName", ""),
pszArrayDescr,
eStructCode, eTypeCode,
pszFormatControls );
CPLXMLNode* psSubIter = psIter->psChild;
while( psSubIter != NULL )
{
if( psSubIter->eType == CXT_Element &&
strcmp(psSubIter->pszValue, "DDFSubfieldDefn") == 0 )
{
poFDefn->AddSubfield( CPLGetXMLValue(psSubIter, "name", ""),
CPLGetXMLValue(psSubIter, "format", "") );
}
psSubIter = psSubIter->psNext;
}
pszFormatControls = CPLGetXMLValue(psIter, "formatControls", NULL);
if( pszFormatControls )
poFDefn->SetFormatControls(pszFormatControls);
oModule.AddField( poFDefn );
}
else if( psIter->eType == CXT_Element &&
strcmp(psIter->pszValue, "DDFRecord") == 0 )
{
//const bool bFirstRecord = !bCreated;
if( !bCreated )
{
oModule.Create( pszOutFilename );
bCreated = TRUE;
}
DDFRecord *poRec = new DDFRecord( &oModule );
std::map<std::string, int> oMapField;
//if( !bFirstRecord )
// poRec->SetReuseHeader(atoi(CPLGetXMLValue(psIter, "reuseHeader", CPLSPrintf("%d", poRec->GetReuseHeader()))));
poRec->SetSizeFieldLength(atoi(CPLGetXMLValue(psIter, "_sizeFieldLength", CPLSPrintf("%d", poRec->GetSizeFieldLength()))));
poRec->SetSizeFieldPos(atoi(CPLGetXMLValue(psIter, "_sizeFieldPos", CPLSPrintf("%d", poRec->GetSizeFieldPos()))));
poRec->SetSizeFieldTag(atoi(CPLGetXMLValue(psIter, "_sizeFieldTag", CPLSPrintf("%d", poRec->GetSizeFieldTag()))));
CPLXMLNode* psSubIter = psIter->psChild;
while( psSubIter != NULL )
{
if( psSubIter->eType == CXT_Element &&
strcmp(psSubIter->pszValue, "DDFField") == 0 )
{
const char* pszFieldName = CPLGetXMLValue(psSubIter, "name", "");
DDFFieldDefn* poFieldDefn = oModule.FindFieldDefn( pszFieldName );
if( poFieldDefn == NULL )
{
fprintf(stderr, "Can't find field '%s'\n", pszFieldName );
exit(1);
}
int nFieldOcc = oMapField[pszFieldName];
oMapField[pszFieldName] ++ ;
DDFField *poField = poRec->AddField( poFieldDefn );
const char* pszValue = CPLGetXMLValue(psSubIter, "value", NULL);
if( pszValue != NULL && STARTS_WITH(pszValue, "0x") )
{
pszValue += 2;
int nDataLen = (int)strlen(pszValue) / 2;
char* pabyData = (char*) malloc(nDataLen);
for(int i=0;i<nDataLen;i++)
{
char c;
int nHigh, nLow;
c = pszValue[2*i];
if( c >= 'A' && c <= 'F' )
nHigh = 10 + c - 'A';
else
nHigh = c - '0';
c = pszValue[2*i + 1];
if( c >= 'A' && c <= 'F' )
nLow = 10 + c - 'A';
else
nLow = c - '0';
pabyData[i] = (nHigh << 4) + nLow;
}
poRec->SetFieldRaw( poField, nFieldOcc, (const char *) pabyData, nDataLen );
free(pabyData);
}
else
{
CPLXMLNode* psSubfieldIter = psSubIter->psChild;
std::map<std::string, int> oMapSubfield;
while( psSubfieldIter != NULL )
{
if( psSubfieldIter->eType == CXT_Element &&
strcmp(psSubfieldIter->pszValue, "DDFSubfield") == 0 )
{
const char* pszSubfieldName = CPLGetXMLValue(psSubfieldIter, "name", "");
const char* pszSubfieldType = CPLGetXMLValue(psSubfieldIter, "type", "");
const char* pszSubfieldValue = CPLGetXMLValue(psSubfieldIter, NULL, "");
int nOcc = oMapSubfield[pszSubfieldName];
oMapSubfield[pszSubfieldName] ++ ;
if( strcmp(pszSubfieldType, "float") == 0 )
{
poRec->SetFloatSubfield( pszFieldName, nFieldOcc, pszSubfieldName, nOcc,
CPLAtof(pszSubfieldValue) );
}
else if( strcmp(pszSubfieldType, "integer") == 0 )
{
poRec->SetIntSubfield( pszFieldName, nFieldOcc, pszSubfieldName, nOcc,
atoi(pszSubfieldValue) );
}
else if( strcmp(pszSubfieldType, "string") == 0 )
{
poRec->SetStringSubfield( pszFieldName, nFieldOcc, pszSubfieldName, nOcc,
pszSubfieldValue );
}
else if( strcmp(pszSubfieldType, "binary") == 0 &&
STARTS_WITH(pszSubfieldValue, "0x") )
{
pszSubfieldValue += 2;
int nDataLen = (int)strlen(pszSubfieldValue) / 2;
char* pabyData = (char*) malloc(nDataLen);
for(int i=0;i<nDataLen;i++)
{
char c;
int nHigh, nLow;
c = pszSubfieldValue[2*i];
if( c >= 'A' && c <= 'F' )
nHigh = 10 + c - 'A';
else
nHigh = c - '0';
c = pszSubfieldValue[2*i + 1];
if( c >= 'A' && c <= 'F' )
nLow = 10 + c - 'A';
else
nLow = c - '0';
pabyData[i] = (nHigh << 4) + nLow;
}
poRec->SetStringSubfield( pszFieldName, nFieldOcc, pszSubfieldName, nOcc,
pabyData, nDataLen );
free(pabyData);
}
}
psSubfieldIter = psSubfieldIter->psNext;
}
}
}
psSubIter = psSubIter->psNext;
}
poRec->Write();
delete poRec;
}
psIter = psIter->psNext;
}
CPLDestroyXMLNode(poRoot);
oModule.Close();
return 0;
}
/**
* LoadMetadata()
*/
void GDALMDReaderDigitalGlobe::LoadMetadata()
{
if(m_bIsMetadataLoad)
return;
if (!m_osIMDSourceFilename.empty())
{
m_papszIMDMD = GDALLoadIMDFile( m_osIMDSourceFilename );
}
if(!m_osRPBSourceFilename.empty())
{
m_papszRPCMD = GDALLoadRPBFile( m_osRPBSourceFilename );
}
if((NULL == m_papszIMDMD || NULL == m_papszRPCMD) && !m_osXMLSourceFilename.empty())
{
CPLXMLNode* psNode = CPLParseXMLFile(m_osXMLSourceFilename);
if(psNode != NULL)
{
CPLXMLNode* psisdNode = psNode->psNext;
if(psisdNode != NULL)
{
if( m_papszIMDMD == NULL )
m_papszIMDMD = LoadIMDXmlNode( CPLSearchXMLNode(psisdNode,
"IMD") );
if( m_papszRPCMD == NULL )
m_papszRPCMD = LoadRPBXmlNode( CPLSearchXMLNode(psisdNode,
"RPB") );
}
CPLDestroyXMLNode(psNode);
}
}
m_papszDEFAULTMD = CSLAddNameValue(m_papszDEFAULTMD, MD_NAME_MDTYPE, "DG");
m_bIsMetadataLoad = true;
if(NULL == m_papszIMDMD)
{
return;
}
//extract imagery metadata
const char* pszSatId = CSLFetchNameValue(m_papszIMDMD, "IMAGE.SATID");
if(NULL != pszSatId)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_SATELLITE,
CPLStripQuotes(pszSatId));
}
else
{
pszSatId = CSLFetchNameValue(m_papszIMDMD, "IMAGE_1.SATID");
if(NULL != pszSatId)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_SATELLITE,
CPLStripQuotes(pszSatId));
}
}
const char* pszCloudCover = CSLFetchNameValue(m_papszIMDMD,
"IMAGE.CLOUDCOVER");
if(NULL != pszCloudCover)
{
double fCC = CPLAtofM(pszCloudCover);
if(fCC < 0)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_CLOUDCOVER,
MD_CLOUDCOVER_NA);
}
else
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_CLOUDCOVER, CPLSPrintf("%d", int(fCC * 100)));
}
}
else
{
pszCloudCover = CSLFetchNameValue(m_papszIMDMD, "IMAGE_1.cloudCover");
if(NULL != pszCloudCover)
{
double fCC = CPLAtofM(pszCloudCover);
if(fCC < 0)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_CLOUDCOVER,
MD_CLOUDCOVER_NA);
}
else
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_CLOUDCOVER, CPLSPrintf("%d", int(fCC * 100)));
}
}
}
const char* pszDateTime = CSLFetchNameValue(m_papszIMDMD,
"IMAGE.FIRSTLINETIME");
if(NULL != pszDateTime)
{
time_t timeStart = GetAcquisitionTimeFromString(pszDateTime);
char szMidDateTime[80];
strftime (szMidDateTime, 80, MD_DATETIMEFORMAT, localtime(&timeStart));
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_ACQDATETIME,
szMidDateTime);
}
else
{
pszDateTime = CSLFetchNameValue(m_papszIMDMD, "IMAGE_1.firstLineTime");
if(NULL != pszDateTime)
{
time_t timeStart = GetAcquisitionTimeFromString(pszDateTime);
char szMidDateTime[80];
strftime (szMidDateTime, 80, MD_DATETIMEFORMAT, localtime(&timeStart));
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_ACQDATETIME,
szMidDateTime);
}
}
}