/**
* 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);
}
}
/**
* LoadMetadata()
*/
void GDALMDReaderGeoEye::LoadMetadata()
{
if(m_bIsMetadataLoad)
return;
if (!m_osIMDSourceFilename.empty())
{
m_papszIMDMD = LoadIMDWktFile( );
}
if(!m_osRPBSourceFilename.empty())
{
m_papszRPCMD = GDALLoadRPCFile( m_osRPBSourceFilename );
}
m_papszDEFAULTMD = CSLAddNameValue(m_papszDEFAULTMD, MD_NAME_MDTYPE, "GE");
m_bIsMetadataLoad = true;
if(NULL == m_papszIMDMD)
{
return;
}
//extract imagery metadata
const char* pszSatId = CSLFetchNameValue(m_papszIMDMD,
"Source Image Metadata.Sensor");
if(NULL != pszSatId)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_SATELLITE,
CPLStripQuotes(pszSatId));
}
const char* pszCloudCover = CSLFetchNameValue(m_papszIMDMD,
"Source Image Metadata.Percent Cloud Cover");
if(NULL != pszCloudCover)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_CLOUDCOVER, pszCloudCover);
}
const char* pszDateTime = CSLFetchNameValue(m_papszIMDMD,
"Source Image Metadata.Acquisition Date/Time");
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);
}
}
/**
* LoadMetadata()
*/
void GDALMDReaderOrbView::LoadMetadata()
{
if(m_bIsMetadataLoad)
return;
if (!m_osIMDSourceFilename.empty())
{
m_papszIMDMD = GDALLoadIMDFile( m_osIMDSourceFilename );
}
if(!m_osRPBSourceFilename.empty())
{
m_papszRPCMD = GDALLoadRPCFile( m_osRPBSourceFilename );
}
m_papszDEFAULTMD = CSLAddNameValue(m_papszDEFAULTMD, MD_NAME_MDTYPE, "OV");
m_bIsMetadataLoad = true;
if(NULL == m_papszIMDMD)
{
return;
}
//extract imagery metadata
const char* pszSatId = CSLFetchNameValue(m_papszIMDMD,
"sensorInfo.satelliteName");
if(NULL != pszSatId)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_SATELLITE,
CPLStripQuotes(pszSatId));
}
const char* pszCloudCover = CSLFetchNameValue(m_papszIMDMD,
"productInfo.productCloudCoverPercentage");
if(NULL != pszCloudCover)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_CLOUDCOVER, pszCloudCover);
}
const char* pszDateTime = CSLFetchNameValue(m_papszIMDMD,
"inputImageInfo.firstLineAcquisitionDateTime");
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);
}
}
void OGRElasticDataSource::UploadFile(const CPLString &url, const CPLString &data) {
char** papszOptions = NULL;
papszOptions = CSLAddNameValue(papszOptions, "POSTFIELDS", data.c_str());
papszOptions = CSLAddNameValue(papszOptions, "HEADERS",
"Content-Type: application/x-javascript; charset=UTF-8");
CPLHTTPResult* psResult = CPLHTTPFetch(url, papszOptions);
CSLDestroy(papszOptions);
if (psResult) {
CPLHTTPDestroyResult(psResult);
}
}
TIF_Band::TIF_Band(GDALMRFDataset *pDS, const ILImage &image, int b, int level):
GDALMRFRasterBand(pDS,image,b,int(level))
{
// Increase the page buffer by 1K in case Tiff expands data
pDS->SetPBuffer(image.pageSizeBytes + 1024);
// Static create options for TIFF tiles
papszOptions = CSLAddNameValue(NULL, "COMPRESS", "DEFLATE");
papszOptions = CSLAddNameValue(papszOptions, "TILED", "Yes");
papszOptions = CSLAddNameValue(papszOptions, "BLOCKXSIZE", CPLString().Printf("%d",img.pagesize.x));
papszOptions = CSLAddNameValue(papszOptions, "BLOCKYSIZE", CPLString().Printf("%d",img.pagesize.y));
int q = img.quality / 10;
// Move down so the default 85 maps to 6. This makes the maz ZLEVEL 8, which is OK
if (q >2) q-=2;
papszOptions = CSLAddNameValue(papszOptions, "ZLEVEL", CPLString().Printf("%d",q));
};
void OGRElasticDataSource::DeleteIndex(const CPLString &url) {
char** papszOptions = NULL;
papszOptions = CSLAddNameValue(papszOptions, "CUSTOMREQUEST", "DELETE");
CPLHTTPResult* psResult = CPLHTTPFetch(url, papszOptions);
CSLDestroy(papszOptions);
if (psResult) {
CPLHTTPDestroyResult(psResult);
}
}
OGRLayer *GNMGenericNetwork::CopyLayer(OGRLayer *poSrcLayer,
const char *pszNewName, char **papszOptions)
{
if(CSLFindName(papszOptions, "DST_SRSWKT") == -1)
{
papszOptions = CSLAddNameValue(papszOptions, "DST_SRSWKT",
GetProjectionRef());
}
else
{
papszOptions = CSLSetNameValue(papszOptions, "DST_SRSWKT",
GetProjectionRef());
}
return GDALDataset::CopyLayer(poSrcLayer, pszNewName, papszOptions);
}
void CPLHTTPInitializeRequest(CPLHTTPRequest *psRequest, const char *pszURL, const char *const *papszOptions) {
psRequest->pszURL = CPLStrdup(pszURL);
psRequest->papszOptions = CSLDuplicate(const_cast<char **>(papszOptions));
psRequest->nStatus = 0;
psRequest->pszContentType = 0;
psRequest->pszError = 0;
psRequest->pabyData = 0;
psRequest->nDataLen = 0;
psRequest->nDataAlloc = 0;
psRequest->m_curl_handle = 0;
psRequest->m_headers = 0;
psRequest->m_curl_error = 0;
psRequest->m_curl_handle = curl_easy_init();
if (psRequest->m_curl_handle == NULL) {
CPLError(CE_Fatal, CPLE_AppDefined, "CPLHTTPInitializeRequest(): Unable to create CURL handle.");
}
char** papszOptionsDup = CSLDuplicate(const_cast<char **>(psRequest->papszOptions));
/* Set User-Agent */
const char *pszUserAgent = CSLFetchNameValue(papszOptionsDup, "USERAGENT");
if (pszUserAgent == NULL)
papszOptionsDup = CSLAddNameValue(papszOptionsDup, "USERAGENT",
"GDAL WMS driver (http://www.gdal.org/frmt_wms.html)");
/* Set URL */
curl_easy_setopt(psRequest->m_curl_handle, CURLOPT_URL, psRequest->pszURL);
/* Set Headers (copied&pasted from cpl_http.cpp, but unused by callers of CPLHTTPInitializeRequest) .*/
const char *headers = CSLFetchNameValue(const_cast<char **>(psRequest->papszOptions), "HEADERS");
if (headers != NULL) {
psRequest->m_headers = curl_slist_append(psRequest->m_headers, headers);
curl_easy_setopt(psRequest->m_curl_handle, CURLOPT_HTTPHEADER, psRequest->m_headers);
}
curl_easy_setopt(psRequest->m_curl_handle, CURLOPT_WRITEDATA, psRequest);
curl_easy_setopt(psRequest->m_curl_handle, CURLOPT_WRITEFUNCTION, CPLHTTPWriteFunc);
psRequest->m_curl_error = reinterpret_cast<char *>(CPLMalloc(CURL_ERROR_SIZE + 1));
psRequest->m_curl_error[0] = '\0';
curl_easy_setopt(psRequest->m_curl_handle, CURLOPT_ERRORBUFFER, psRequest->m_curl_error);
CPLHTTPSetOptions(psRequest->m_curl_handle, papszOptionsDup);
CSLDestroy(papszOptionsDup);
}
SEXP
RGDAL_SetMetadata(SEXP sxpObj, SEXP sxpMetadataList) {
void *pGDALObj = getGDALObjPtr(sxpObj);
SEXP sxpNames = getAttrib(sxpMetadataList, R_NamesSymbol);
char **metadata = (char **) CPLCalloc(1, sizeof(char *));
const char *name, *value;
if (isNull(sxpNames)) {
int i;
for (i = 0; i < length(sxpMetadataList); ++i) {
value = asString(VECTOR_ELT(sxpMetadataList, i));
CSLAddString(metadata, value);
}
} else {
int i;
for (i = 0; i < length(sxpMetadataList); ++i) {
name = asString(sxpNames, i);
value = asString(VECTOR_ELT(sxpMetadataList, i));
CSLAddNameValue(metadata, name, value);
}
}
CPLErr err = ((GDALMajorObject *)pGDALObj)->SetMetadata(metadata, NULL);
if (err == CE_Failure) warning("Failed to set metadata\n");
return(sxpObj);
}
CPLErr GNMDatabaseNetwork::Open(GDALOpenInfo *poOpenInfo)
{
FormName(poOpenInfo->pszFilename, poOpenInfo->papszOpenOptions);
if(CSLFindName(poOpenInfo->papszOpenOptions, "LIST_ALL_TABLES") == -1)
poOpenInfo->papszOpenOptions = CSLAddNameValue(
poOpenInfo->papszOpenOptions, "LIST_ALL_TABLES", "YES");
m_poDS = (GDALDataset*) GDALOpenEx( m_soNetworkFullName, GDAL_OF_VECTOR |
GDAL_OF_UPDATE, NULL, NULL, poOpenInfo->papszOpenOptions );
if( NULL == m_poDS )
{
CPLError( CE_Failure, CPLE_OpenFailed, "Open '%s' failed",
m_soNetworkFullName.c_str() );
return CE_Failure;
}
// There should be only one schema so no schema name can be in table name
if(LoadMetadataLayer(m_poDS) != CE_None)
{
return CE_Failure;
}
if(LoadGraphLayer(m_poDS) != CE_None)
{
return CE_Failure;
}
if(LoadFeaturesLayer(m_poDS) != CE_None)
{
return CE_Failure;
}
return CE_None;
}
/**
* LoadMetadata()
*/
void GDALMDReaderLandsat::LoadMetadata()
{
if(m_bIsMetadataLoad)
return;
if (!m_osIMDSourceFilename.empty())
{
m_papszIMDMD = GDALLoadIMDFile( m_osIMDSourceFilename );
}
m_papszDEFAULTMD = CSLAddNameValue(m_papszDEFAULTMD, MD_NAME_MDTYPE, "ODL");
m_bIsMetadataLoad = true;
// date/time
// DATE_ACQUIRED = 2013-04-07
// SCENE_CENTER_TIME = 15:47:03.0882620Z
// L1_METADATA_FILE.PRODUCT_METADATA.SPACECRAFT_ID
const char* pszSatId = CSLFetchNameValue(m_papszIMDMD,
"L1_METADATA_FILE.PRODUCT_METADATA.SPACECRAFT_ID");
if(NULL != pszSatId)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_SATELLITE,
CPLStripQuotes(pszSatId));
}
// L1_METADATA_FILE.IMAGE_ATTRIBUTES.CLOUD_COVER
const char* pszCloudCover = CSLFetchNameValue(m_papszIMDMD,
"L1_METADATA_FILE.IMAGE_ATTRIBUTES.CLOUD_COVER");
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)));
}
}
// L1_METADATA_FILE.PRODUCT_METADATA.ACQUISITION_DATE
// L1_METADATA_FILE.PRODUCT_METADATA.SCENE_CENTER_SCAN_TIME
// L1_METADATA_FILE.PRODUCT_METADATA.DATE_ACQUIRED
// L1_METADATA_FILE.PRODUCT_METADATA.SCENE_CENTER_TIME
const char* pszDate = CSLFetchNameValue(m_papszIMDMD,
"L1_METADATA_FILE.PRODUCT_METADATA.ACQUISITION_DATE");
if(NULL == pszDate)
{
pszDate = CSLFetchNameValue(m_papszIMDMD,
"L1_METADATA_FILE.PRODUCT_METADATA.DATE_ACQUIRED");
}
if(NULL != pszDate)
{
const char* pszTime = CSLFetchNameValue(m_papszIMDMD,
"L1_METADATA_FILE.PRODUCT_METADATA.SCENE_CENTER_SCAN_TIME");
if(NULL == pszTime)
{
pszTime = CSLFetchNameValue(m_papszIMDMD,
"L1_METADATA_FILE.PRODUCT_METADATA.SCENE_CENTER_TIME");
}
if(NULL == pszTime)
pszTime = "00:00:00.000000Z";
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);
}
}
int main( int nArgc, char ** papszArgv )
{
int bQuiet = FALSE;
const char *pszDataSource = NULL;
GNMGFID nFromFID = -1;
GNMGFID nToFID = -1;
int nK = 1;
const char *pszDataset = NULL;
const char *pszFormat = "ESRI Shapefile";
const char *pszLayer = NULL;
GNMNetwork *poDS = NULL;
OGRLayer* poResultLayer = NULL;
char **papszDSCO = NULL, **papszLCO = NULL, **papszALO = NULL;
operation stOper = op_unknown;
int nRet = 0;
// Check strict compilation and runtime library version as we use C++ API
if (! GDAL_CHECK_VERSION(papszArgv[0]))
exit(1);
EarlySetConfigOptions(nArgc, papszArgv);
/* -------------------------------------------------------------------- */
/* Register format(s). */
/* -------------------------------------------------------------------- */
GDALAllRegister();
/* -------------------------------------------------------------------- */
/* Processing command line arguments. */
/* -------------------------------------------------------------------- */
nArgc = GDALGeneralCmdLineProcessor( nArgc, &papszArgv, GDAL_OF_GNM );
if( nArgc < 1 )
{
exit( -nArgc );
}
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[1], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(papszArgv[iArg],"--help") )
{
Usage();
}
else if ( EQUAL(papszArgv[iArg], "--long-usage") )
{
Usage(FALSE);
}
else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet") )
{
bQuiet = TRUE;
}
else if( EQUAL(papszArgv[iArg],"dijkstra") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
stOper = op_dijkstra;
nFromFID = atoi(papszArgv[++iArg]);
nToFID = atoi(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg],"kpaths") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(3);
stOper = op_kpaths;
nFromFID = atoi(papszArgv[++iArg]);
nToFID = atoi(papszArgv[++iArg]);
nK = atoi(papszArgv[++iArg]);
}
else if( EQUAL(papszArgv[iArg],"resource") )
{
stOper = op_resource;
}
else if( EQUAL(papszArgv[iArg],"-ds") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszDataset = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-f") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszFormat = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-l") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
pszLayer = papszArgv[++iArg];
}
else if( EQUAL(papszArgv[iArg],"-dsco") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszDSCO = CSLAddString(papszDSCO, papszArgv[++iArg] );
}
else if( EQUAL(papszArgv[iArg],"-lco") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszLCO = CSLAddString(papszLCO, papszArgv[++iArg] );
}
else if( EQUAL(papszArgv[iArg],"-alo") )
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1);
papszALO = CSLAddString(papszALO, papszArgv[++iArg] );
}
else if( papszArgv[iArg][0] == '-' )
{
Usage(CPLSPrintf("Unknown option name '%s'", papszArgv[iArg]));
}
else if( pszDataSource == NULL )
pszDataSource = papszArgv[iArg];
}
// do the work ////////////////////////////////////////////////////////////////
if(stOper == op_dijkstra)
{
if(pszDataSource == NULL)
Usage("No network dataset provided");
if(nFromFID == -1 || nToFID == -1)
Usage("Invalid input from or to identificators");
// open
poDS = (GNMNetwork*) GDALOpenEx( pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_GNM, NULL, NULL, NULL );
if(NULL == poDS)
{
fprintf( stderr, "\nFailed to open network at %s\n", pszDataSource);
nRet = 1;
goto exit;
}
poResultLayer = poDS->GetPath(nFromFID, nToFID, GATDijkstraShortestPath,
papszALO);
if(NULL == pszDataset)
{
ReportOnLayer(poResultLayer, bQuiet == FALSE);
}
else
{
if(CreateAndFillOutputDataset(poResultLayer, pszDataset, pszFormat,
pszLayer, papszDSCO, papszLCO, bQuiet)
!= OGRERR_NONE)
{
nRet = 1;
goto exit;
}
}
}
else if(stOper == op_kpaths)
{
if(pszDataSource == NULL)
Usage("No network dataset provided");
if(nFromFID == -1 || nToFID == -1)
Usage("Invalid input from or to identificators");
// open
poDS = (GNMNetwork*) GDALOpenEx( pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_GNM, NULL, NULL, NULL );
if(NULL == poDS)
{
fprintf( stderr, "\nFailed to open network at %s\n", pszDataSource);
nRet = 1;
goto exit;
}
if(CSLFindName(papszALO, GNM_MD_NUM_PATHS) == -1)
{
CPLDebug("GNM", "No K in options, add %d value", nK);
papszALO = CSLAddNameValue(papszALO, GNM_MD_NUM_PATHS,
CPLSPrintf("%d", nK));
}
poResultLayer = poDS->GetPath(nFromFID, nToFID, GATKShortestPath,
papszALO);
if(NULL == pszDataset)
{
ReportOnLayer(poResultLayer, bQuiet == FALSE);
}
else
{
if(CreateAndFillOutputDataset(poResultLayer, pszDataset, pszFormat,
pszLayer, papszDSCO, papszLCO, bQuiet)
!= OGRERR_NONE)
{
nRet = 1;
goto exit;
}
}
}
else if(stOper == op_resource)
{
if(pszDataSource == NULL)
Usage("No network dataset provided");
// open
poDS = (GNMNetwork*) GDALOpenEx( pszDataSource,
GDAL_OF_UPDATE | GDAL_OF_GNM, NULL, NULL, NULL );
if(NULL == poDS)
{
fprintf( stderr, "\nFailed to open network at %s\n", pszDataSource);
nRet = 1;
goto exit;
}
poResultLayer = poDS->GetPath(nFromFID, nToFID, GATConnectedComponents,
papszALO);
if(NULL == pszDataset)
{
ReportOnLayer(poResultLayer, bQuiet == FALSE);
}
else
{
if(CreateAndFillOutputDataset(poResultLayer, pszDataset, pszFormat,
pszLayer, papszDSCO, papszLCO, bQuiet)
!= OGRERR_NONE)
{
nRet = 1;
goto exit;
}
}
}
else
{
printf("\nNeed an operation. See help what you can do with gnmanalyse:\n");
Usage();
}
exit:
CSLDestroy(papszDSCO);
CSLDestroy(papszLCO);
CSLDestroy(papszALO);
if(poResultLayer != NULL)
poDS->ReleaseResultSet(poResultLayer);
if( poDS != NULL )
GDALClose( (GDALDatasetH)poDS );
GDALDestroyDriverManager();
return nRet;
}
/**
* LoadMetadata()
*/
void GDALMDReaderALOS::LoadMetadata()
{
if(m_bIsMetadataLoad)
return;
if(!m_osIMDSourceFilename.empty())
{
m_papszIMDMD = CSLLoad(m_osIMDSourceFilename);
}
if(!m_osHDRSourceFilename.empty())
{
if(NULL == m_papszIMDMD)
{
m_papszIMDMD = CSLLoad(m_osHDRSourceFilename);
}
else
{
char** papszHDR = CSLLoad(m_osHDRSourceFilename);
m_papszIMDMD = CSLMerge(m_papszIMDMD, papszHDR);
CSLDestroy(papszHDR);
}
}
m_papszRPCMD = LoadRPCTxtFile();
m_papszDEFAULTMD = CSLAddNameValue(m_papszDEFAULTMD, MD_NAME_MDTYPE, "ALOS");
m_bIsMetadataLoad = true;
const char* pszSatId1 = CSLFetchNameValue(m_papszIMDMD, "Lbi_Satellite");
const char* pszSatId2 = CSLFetchNameValue(m_papszIMDMD, "Lbi_Sensor");
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* pszCloudCover = CSLFetchNameValue(m_papszIMDMD,
"Img_CloudQuantityOfAllImage");
if(NULL != pszCloudCover)
{
int nCC = atoi(pszCloudCover);
if(nCC >= 99)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_CLOUDCOVER,
MD_CLOUDCOVER_NA);
}
else
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_CLOUDCOVER, CPLSPrintf("%d", nCC * 10));
}
}
const char* pszDate = CSLFetchNameValue(m_papszIMDMD,
"Img_SceneCenterDateTime");
if(NULL != pszDate)
{
char buffer[80];
time_t timeMid = GetAcquisitionTimeFromString(CPLStripQuotes(pszDate));
strftime (buffer, 80, MD_DATETIMEFORMAT, localtime(&timeMid));
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_ACQDATETIME, buffer);
}
else
{
pszDate = CSLFetchNameValue(m_papszIMDMD, "Lbi_ObservationDate");
if(NULL != pszDate)
{
const char* pszTime = "00:00:00.000";
char buffer[80];
time_t timeMid = GetAcquisitionTimeFromString(CPLSPrintf( "%s %s",
CPLStripQuotes(pszDate).c_str(),
CPLStripQuotes(pszTime).c_str()));
strftime (buffer, 80, MD_DATETIMEFORMAT, localtime(&timeMid));
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_ACQDATETIME, buffer);
}
}
}
/**
* 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);
}
/**
* LoadMetadata()
*/
void GDALMDReaderKompsat::LoadMetadata()
{
if(m_bIsMetadataLoad)
return;
if(!m_osIMDSourceFilename.empty())
{
m_papszIMDMD = ReadTxtToList( );
}
if(!m_osRPBSourceFilename.empty())
{
m_papszRPCMD = GDALLoadRPCFile( m_osRPBSourceFilename );
}
m_papszDEFAULTMD = CSLAddNameValue(m_papszDEFAULTMD, MD_NAME_MDTYPE, "KARI");
m_bIsMetadataLoad = true;
const char* pszSatId1 = CSLFetchNameValue(m_papszIMDMD, "AUX_SATELLITE_NAME");
const char* pszSatId2 = CSLFetchNameValue(m_papszIMDMD, "AUX_SATELLITE_SENSOR");
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* pszCloudCover = CSLFetchNameValue(m_papszIMDMD,
"AUX_CLOUD_STATUS");
if(NULL != pszCloudCover)
{
int nCC = atoi(pszCloudCover);
if(nCC > 100 || nCC < 0)
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_CLOUDCOVER,
MD_CLOUDCOVER_NA);
}
else
{
m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD,
MD_NAME_CLOUDCOVER, CPLSPrintf("%d", nCC));
}
}
const char* pszDate = CSLFetchNameValue(m_papszIMDMD,
"AUX_STRIP_ACQ_DATE_UT");
if(NULL != pszDate)
{
const char* pszTime = CSLFetchNameValue(m_papszIMDMD,
"AUX_STRIP_ACQ_START_UT");
if(NULL == pszTime)
pszTime = "000000.000000";
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);
}
}
void GMLFeature::AddOBProperty( const char *pszName, const char *pszValue )
{
m_papszOBProperties =
CSLAddNameValue( m_papszOBProperties, pszName, pszValue );
}
GDALDataset *DOQ2Dataset::Open( GDALOpenInfo * poOpenInfo )
{
int nWidth=0, nHeight=0, nBandStorage=0, nBandTypes=0;
/* -------------------------------------------------------------------- */
/* We assume the user is pointing to the binary (ie. .bil) file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < 212 )
return NULL;
int nLineCount = 0;
const char *pszLine;
int nBytesPerPixel=0;
const char *pszDatumLong=NULL, *pszDatumShort=NULL;
const char *pszUnits=NULL;
char *pszQuadname = NULL;
char *pszQuadquad = NULL;
char *pszState = NULL;
int nZone=0, nProjType=0;
int nSkipBytes=0, nBytesPerLine, i, nBandCount = 0;
double dfULXMap=0.0, dfULYMap = 0.0;
double dfXDim=0.0, dfYDim=0.0;
char **papszMetadata = NULL;
if(! EQUALN((const char *) poOpenInfo->pabyHeader,
"BEGIN_USGS_DOQ_HEADER", 21) )
return NULL;
VSILFILE* fp = VSIFOpenL(poOpenInfo->pszFilename, "rb");
if (fp == NULL)
return NULL;
/* read and discard the first line */
pszLine = CPLReadLineL( fp );
while( (pszLine = CPLReadLineL( fp )) != NULL )
{
char **papszTokens;
nLineCount++;
if( EQUAL(pszLine,"END_USGS_DOQ_HEADER") )
break;
papszTokens = CSLTokenizeString( pszLine );
if( CSLCount( papszTokens ) < 2 )
{
CSLDestroy( papszTokens );
break;
}
if( EQUAL(papszTokens[0],"SAMPLES_AND_LINES") && CSLCount(papszTokens) >= 3 )
{
nWidth = atoi(papszTokens[1]);
nHeight = atoi(papszTokens[2]);
}
else if( EQUAL(papszTokens[0],"BYTE_COUNT") )
{
nSkipBytes = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"XY_ORIGIN") && CSLCount(papszTokens) >= 3 )
{
dfULXMap = atof(papszTokens[1]);
dfULYMap = atof(papszTokens[2]);
}
else if( EQUAL(papszTokens[0],"HORIZONTAL_RESOLUTION") )
{
dfXDim = dfYDim = atof(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"BAND_ORGANIZATION") )
{
if( EQUAL(papszTokens[1],"SINGLE FILE") )
nBandStorage = 1;
if( EQUAL(papszTokens[1],"BSQ") )
nBandStorage = 1;
if( EQUAL(papszTokens[1],"BIL") )
nBandStorage = 1;
if( EQUAL(papszTokens[1],"BIP") )
nBandStorage = 4;
}
else if( EQUAL(papszTokens[0],"BAND_CONTENT") )
{
if( EQUAL(papszTokens[1],"BLACK&WHITE") )
nBandTypes = 1;
else if( EQUAL(papszTokens[1],"COLOR") )
nBandTypes = 5;
else if( EQUAL(papszTokens[1],"RGB") )
nBandTypes = 5;
else if( EQUAL(papszTokens[1],"RED") )
nBandTypes = 5;
else if( EQUAL(papszTokens[1],"GREEN") )
nBandTypes = 5;
else if( EQUAL(papszTokens[1],"BLUE") )
nBandTypes = 5;
nBandCount++;
}
else if( EQUAL(papszTokens[0],"BITS_PER_PIXEL") )
{
nBytesPerPixel = (atoi(papszTokens[1]) / 8);
}
else if( EQUAL(papszTokens[0],"HORIZONTAL_COORDINATE_SYSTEM") )
{
if( EQUAL(papszTokens[1],"UTM") )
nProjType = 1;
else if( EQUAL(papszTokens[1],"SPCS") )
nProjType = 2;
else if( EQUAL(papszTokens[1],"GEOGRAPHIC") )
nProjType = 0;
}
else if( EQUAL(papszTokens[0],"COORDINATE_ZONE") )
{
nZone = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"HORIZONTAL_UNITS") )
{
if( EQUAL(papszTokens[1],"METERS") )
pszUnits = "UNIT[\"metre\",1]";
else if( EQUAL(papszTokens[1],"FEET") )
pszUnits = "UNIT[\"US survey foot\",0.304800609601219]";
}
else if( EQUAL(papszTokens[0],"HORIZONTAL_DATUM") )
{
if( EQUAL(papszTokens[1],"NAD27") )
{
pszDatumLong = NAD27_DATUM;
pszDatumShort = "NAD 27";
}
else if( EQUAL(papszTokens[1],"WGS72") )
{
pszDatumLong = WGS72_DATUM;
pszDatumShort = "WGS 72";
}
else if( EQUAL(papszTokens[1],"WGS84") )
{
pszDatumLong = WGS84_DATUM;
pszDatumShort = "WGS 84";
}
else if( EQUAL(papszTokens[1],"NAD83") )
{
pszDatumLong = NAD83_DATUM;
pszDatumShort = "NAD 83";
}
else
{
pszDatumLong = "DATUM[\"unknown\"]";
pszDatumShort = "unknown";
}
}
else
{
/* we want to generically capture all the other metadata */
CPLString osMetaDataValue;
int iToken;
for( iToken = 1; papszTokens[iToken] != NULL; iToken++ )
{
if( EQUAL(papszTokens[iToken],"*") )
continue;
if( iToken > 1 )
osMetaDataValue += " " ;
osMetaDataValue += papszTokens[iToken];
}
papszMetadata = CSLAddNameValue( papszMetadata,
papszTokens[0],
osMetaDataValue );
}
CSLDestroy( papszTokens );
}
CPLReadLineL( NULL );
/* -------------------------------------------------------------------- */
/* Do these values look coherent for a DOQ file? It would be */
/* nice to do a more comprehensive test than this! */
/* -------------------------------------------------------------------- */
if( nWidth < 500 || nWidth > 25000
|| nHeight < 500 || nHeight > 25000
|| nBandStorage < 0 || nBandStorage > 4
|| nBandTypes < 1 || nBandTypes > 9 )
{
CSLDestroy( papszMetadata );
VSIFCloseL(fp);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Check the configuration. We don't currently handle all */
/* variations, only the common ones. */
/* -------------------------------------------------------------------- */
if( nBandTypes > 5 )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"DOQ Data Type (%d) is not a supported configuration.\n",
nBandTypes );
CSLDestroy( papszMetadata );
VSIFCloseL(fp);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CSLDestroy( papszMetadata );
CPLError( CE_Failure, CPLE_NotSupported,
"The DOQ2 driver does not support update access to existing"
" datasets.\n" );
VSIFCloseL(fp);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
DOQ2Dataset *poDS;
poDS = new DOQ2Dataset();
poDS->nRasterXSize = nWidth;
poDS->nRasterYSize = nHeight;
poDS->SetMetadata( papszMetadata );
CSLDestroy( papszMetadata );
poDS->fpImage = fp;
/* -------------------------------------------------------------------- */
/* Compute layout of data. */
/* -------------------------------------------------------------------- */
if( nBandCount < 2 )
nBandCount = nBytesPerPixel;
else
nBytesPerPixel *= nBandCount;
nBytesPerLine = nBytesPerPixel * nWidth;
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
for( i = 0; i < nBandCount; i++ )
{
poDS->SetBand( i+1,
new RawRasterBand( poDS, i+1, poDS->fpImage,
nSkipBytes + i, nBytesPerPixel, nBytesPerLine,
GDT_Byte, TRUE, TRUE ) );
}
if (nProjType == 1)
{
poDS->pszProjection =
CPLStrdup(CPLSPrintf( UTM_FORMAT, pszDatumShort, nZone,
pszDatumLong, nZone * 6 - 183, pszUnits ));
}
else
{
poDS->pszProjection = CPLStrdup("");
}
poDS->dfULX = dfULXMap;
poDS->dfULY = dfULYMap;
poDS->dfXPixelSize = dfXDim;
poDS->dfYPixelSize = dfYDim;
if ( pszQuadname ) CPLFree( pszQuadname );
if ( pszQuadquad) CPLFree( pszQuadquad );
if ( pszState) CPLFree( pszState );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
bool wxGISGPSubRasterByVectorTool::Execute(ITrackCancel* pTrackCancel)
{
if(!Validate())
{
//add messages to pTrackCancel
if(pTrackCancel)
pTrackCancel->PutMessage(_("Unexpected error occurred"), -1, enumGISMessageErr);
return false;
}
IGxObjectContainer* pGxObjectContainer = dynamic_cast<IGxObjectContainer*>(m_pCatalog);
if(!pGxObjectContainer)
{
//add messages to pTrackCancel
if(pTrackCancel)
pTrackCancel->PutMessage(_("Error getting catalog object"), -1, enumGISMessageErr);
return false;
}
wxString sSrcVecPath = m_paParam[0]->GetValue();
IGxObject* pGxObject = pGxObjectContainer->SearchChild(sSrcVecPath);
if(!pGxObject)
{
//add messages to pTrackCancel
if(pTrackCancel)
pTrackCancel->PutMessage(_("Error getting source vector object"), -1, enumGISMessageErr);
return false;
}
IGxDataset* pGxDataset = dynamic_cast<IGxDataset*>(pGxObject);
if(!pGxDataset)
{
//add messages to pTrackCancel
if(pTrackCancel)
pTrackCancel->PutMessage(_("Source object is of incompatible type"), -1, enumGISMessageErr);
return false;
}
wxGISFeatureDatasetSPtr pSrcFeatureDataSet = boost::dynamic_pointer_cast<wxGISFeatureDataset>(pGxDataset->GetDataset());
if(!pSrcFeatureDataSet)
{
//add messages to pTrackCancel
if(pTrackCancel)
pTrackCancel->PutMessage(_("Source vector dataset is of incompatible type"), -1, enumGISMessageErr);
return false;
}
wxString sSrcRasterPath = m_paParam[1]->GetValue();
pGxObject = pGxObjectContainer->SearchChild(sSrcRasterPath);
if(!pGxObject)
{
//add messages to pTrackCancel
if(pTrackCancel)
pTrackCancel->PutMessage(_("Error getting source raster object"), -1, enumGISMessageErr);
return false;
}
pGxDataset = dynamic_cast<IGxDataset*>(pGxObject);
if(!pGxDataset)
{
//add messages to pTrackCancel
if(pTrackCancel)
pTrackCancel->PutMessage(_("Source object is of incompatible type"), -1, enumGISMessageErr);
return false;
}
wxGISRasterDatasetSPtr pSrcRasterDataSet = boost::dynamic_pointer_cast<wxGISRasterDataset>(pGxDataset->GetDataset());
if(!pSrcRasterDataSet)
{
//add messages to pTrackCancel
if(pTrackCancel)
pTrackCancel->PutMessage(_("Source raster dataset is of incompatible type"), -1, enumGISMessageErr);
return false;
}
wxString sDstPath = m_paParam[2]->GetValue();
IGxObject* pGxDstObject = pGxObjectContainer->SearchChild(sDstPath);
if(!pGxDstObject)
{
//add messages to pTrackCancel
if(pTrackCancel)
pTrackCancel->PutMessage(_("Error get destination object"), -1, enumGISMessageErr);
return false;
}
CPLString szDstPath = pGxDstObject->GetInternalName();
bool bRes = true;
wxGxRasterFilter* pFilter = new wxGxRasterFilter(enumRasterTiff);
GDALDataType eOutputType = GDT_Byte;
int nBandCount = 0;
int *panBandList = NULL;
bool bUseCounter = false;
int nCounterBegin = -1;
int nFieldNo = 0;
double dfOutResX = -1;
double dfOutResY = -1;
bool bCopyNodata = false;
bool bSkipSourceMetadata = false;
char** papszOptions = NULL;
papszOptions = CSLAddNameValue(papszOptions, "DEST_RESAMPLING", "near");
papszOptions = CSLAddNameValue(papszOptions, "COMPRESS", "LZW");
papszOptions = CSLAddNameValue(papszOptions, "PREDICTOR", "2");
bRes = SubrasterByVector(pSrcFeatureDataSet, pSrcRasterDataSet, szDstPath, pFilter, eOutputType, nBandCount, panBandList, bUseCounter, nCounterBegin, nFieldNo, dfOutResX, dfOutResY, bCopyNodata, bSkipSourceMetadata, papszOptions, pTrackCancel);
if(pGxObjectContainer)
{
IGxObject* pParentLoc = pGxObjectContainer->SearchChild(sDstPath);
if(pParentLoc)
pParentLoc->Refresh();
}
return bRes;
}
/**
* 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);
}
}
}
