/** * 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); } } }