ScopePathGlobalInit() {
data_path = FindDataPath();
assert(data_path != NULL);
data_path_length = _tcslen(data_path);
}
SURF_FETCH_E LandfireClient::FetchBoundingBox( double *bbox, double resolution,
const char *filename,
char **options )
{
(void)resolution;
if( NULL == filename )
{
return SURF_FETCH_E_BAD_INPUT;
}
/*
** We have an arbitrary limit on request size, 0.001 degrees
*/
if( fabs( bbox[0] - bbox[2] ) < 0.001 || fabs( bbox[1] - bbox[3] ) < 0.001 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Bounding box too small, must be greater than " \
"0.001 x 0.001 degrees." );
return SURF_FETCH_E_BAD_INPUT;
}
/*-----------------------------------------------------------------------------
* Local Variable Declarations
*-----------------------------------------------------------------------------*/
int i = 0;
char *p;
int nMaxTries = atoi( CPLGetConfigOption( "LCP_MAX_DOWNLOAD_TRIES", "40" ) );
double dfWait = atof( CPLGetConfigOption( "LCP_DOWNLOAD_WAIT", "3" ) );
const char *pszProduct = CPLStrdup( CSLFetchNameValue( options, "PRODUCT" ) );
/*
** Stupidly simple heuristics to try to get the 'correct' product.
*/
if( pszProduct == NULL || EQUAL( pszProduct, "" ) )
{
if( EQUAL( pszProduct, "" ) )
CPLFree( (void*)pszProduct );
std::string osDataPath = FindDataPath( "landfire.zip" );
osDataPath = "/vsizip/" + osDataPath;
const char *pszGeom;
pszGeom = CPLSPrintf( "POLYGON((%lf %lf,%lf %lf,%lf %lf,%lf %lf,%lf %lf))",
bbox[1], bbox[0], bbox[3], bbox[0],
bbox[3], bbox[2], bbox[1], bbox[2],
bbox[1], bbox[0] );
CPLDebug( "LCP_CLIENT", "Testing if %s contains %s", osDataPath.c_str(),
pszGeom );
if( NinjaOGRContain( pszGeom, osDataPath.c_str(), "conus" ) )
{
pszProduct = CPLStrdup( "F4W21HZ" );
}
else if( NinjaOGRContain( pszGeom, osDataPath.c_str(), "ak" ) )
{
pszProduct = CPLStrdup( "F7C29HZ" );
}
else if( NinjaOGRContain( pszGeom, osDataPath.c_str(), "hi" ) )
{
pszProduct = CPLStrdup( "F4825HZ" );
}
/* Contiguous US */
//if( bbox[0] < 52 && bbox[1] < -60 && bbox[2] > 22 && bbox[3] > -136 )
// pszProduct = CPLStrdup( "F4W21HZ" );
/* Alaska */
//else if( bbox[0] < 75 && bbox[1] < -125 && bbox[2] > 50 && bbox[3] > -179 )
// pszProduct = CPLStrdup( "F7C29HZ" );
/* Hawaii */
//else if( bbox[0] < 25 && bbox[1] < -150 && bbox[2] > 15 && bbox[3] > -170 )
// pszProduct = CPLStrdup( "F4825HZ" );
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to locate product." );
return SURF_FETCH_E_BAD_INPUT;
}
}
CPLDebug( "LCP_CLIENT", "Using product: %s", pszProduct );
const char *pszUrl;
const char *pszTemp = CSLFetchNameValue( options, "OVERRIDE_BEST_UTM" );
int nEpsgCode = -1;
if( pszTemp == NULL )
{
nEpsgCode = BoundingBoxUtm( bbox );
}
else
{
nEpsgCode = atoi( pszTemp );
}
/*
** Better check?
*/
if( nEpsgCode < 1 )
{
CPLError( CE_Failure, CPLE_AppDefined, "Invalid EPSG code." );
CPLFree( (void*)pszProduct );
return SURF_FETCH_E_BAD_INPUT;
}
/*-----------------------------------------------------------------------------
* Request a Model via the landfire.cr.usgs.gov REST client
*-----------------------------------------------------------------------------*/
pszUrl = CPLSPrintf( LF_REQUEST_TEMPLATE, bbox[0], bbox[2], bbox[3],
bbox[1], pszProduct );
CPLFree( (void*)pszProduct );
m_poResult = CPLHTTPFetch( pszUrl, NULL );
CHECK_HTTP_RESULT( "Failed to get download URL" );
CPLDebug( "LCP_CLIENT", "Request URL: %s", pszUrl );
/*-----------------------------------------------------------------------------
* Parse the JSON result of the request
*-----------------------------------------------------------------------------*/
int nSize = strlen( (char*) m_poResult->pabyData );
//Create a buffer so we can use sscanf, couldn't find a CPL version
char *pszResponse = new char[ nSize + 1 ];
pszResponse[0] = '\0';
CPLDebug( "LCP_CLIENT", "JSON Response: %s", m_poResult->pabyData );
/*
** Regular expression support if we have C++11 support. isnan ambiguouity
** is causing non-C++11 compliance. Not tested or used, 0 disables.
*/
#if __cplusplus >= 201103 && 0
std::string s((const char*) m_poResult->pabyData );
std::smatch m;
std::regex e( "\\b(?:(?:https?)://|www\\.)[a-z-A-Z0-9+&@#/%=~_|$?!:,.]" \
"*[a-z-A-Z0-9+&@#/%=~_|$]" );
std::regex_search( s, m, e );
std::string url = m[0].str(); //retrieve first match
CPLStrlcpy( pszResponse, url.c_str(), nSize );
#else
char **papszTokens = NULL;
papszTokens = CSLTokenizeString2( (const char*)m_poResult->pabyData, ",:",
CSLT_HONOURSTRINGS | CSLT_PRESERVEESCAPES |
CSLT_STRIPENDSPACES | CSLT_STRIPLEADSPACES );
int nTokens = CSLCount( papszTokens );
if( nTokens < 2 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to generate valid URL for LCP download." );
delete [] pszResponse;
CPLHTTPDestroyResult( m_poResult );
CSLDestroy( papszTokens );
return SURF_FETCH_E_IO_ERR;
}
for( int i = 1; i < nTokens; i++ )
{
if( EQUALN( papszTokens[i], "https://", 6 ) &&
EQUAL( papszTokens[i - 1], "DOWNLOAD_URL" ) )
{
CPLStrlcpy( pszResponse, papszTokens[i], nSize );
break;
}
}
CSLDestroy( papszTokens );
#endif
//Grab the download URL from the JSON response, stores in pszResponse
//std::sscanf( (char*) m_poResult->pabyData, LF_REQUEST_RETURN_TEMPLATE, pszResponse);
CPLHTTPDestroyResult( m_poResult );
if( !EQUALN( pszResponse, "https://", 6 ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to generate valid URL for LCP download." );
delete [] pszResponse;
return SURF_FETCH_E_IO_ERR;
}
p = strstr( pszResponse, "}]" );
if( p )
*p = '\0';
CPLDebug( "LCP_CLIENT", "Download URL: %s", pszResponse );
// Fix the SRS
const char *pszNewUrl = ReplaceSRS( nEpsgCode, pszResponse );
CPLDebug( "LCP_CLIENT", "Sanitized SRS Download URL: %s", pszNewUrl );
/*-----------------------------------------------------------------------------
* Get the Job ID by visiting the download URL
*-----------------------------------------------------------------------------*/
m_poResult = CPLHTTPFetch( pszNewUrl, NULL );
CPLFree( (void*)pszNewUrl );
delete [] pszResponse;
CHECK_HTTP_RESULT( "Failed to get Job ID" );
nSize = strlen( (char*) m_poResult->pabyData );
pszResponse = new char[ nSize + 1 ];
//grabs the Job ID from the Download URL response
std::sscanf( (char*) m_poResult->pabyData, LF_INIT_RESPONSE_TEMPLATE, pszResponse);
CPLHTTPDestroyResult( m_poResult );
//store the Job Id into a class attribute, so we can reuse pszResponse, but keep
//the Job Id (needed for future parts)
m_JobId = std::string( pszResponse );
CPLDebug( "LCP_CLIENT", "Job id: %s", m_JobId.c_str() );
/*-----------------------------------------------------------------------------
* Initiate the download by using the obtained Job ID
*-----------------------------------------------------------------------------*/
pszUrl = CPLSPrintf( LF_INIT_DOWNLOAD_TEMPLATE, m_JobId.c_str() );
//fetch the response of download initiation
//note: for some reason it alway returns a key error, but download still works
m_poResult = CPLHTTPFetch( pszUrl, NULL );
CPLHTTPDestroyResult( m_poResult );
/*-----------------------------------------------------------------------------
* Check the status of the download, able to download when status=400
*-----------------------------------------------------------------------------*/
int dl_status = 0;
//Obtain the readiness status of the current job
pszUrl = CPLSPrintf( LF_GET_STATUS_TEMPLATE, m_JobId.c_str() );
CPLDebug( "LCP_CLIENT", "Status url: %s", pszUrl );
do
{
m_poResult = CPLHTTPFetch( pszUrl, NULL );
delete [] pszResponse;
CHECK_HTTP_RESULT( "Failed to get job status" );
nSize = strlen( (char*) m_poResult->pabyData );
pszResponse = new char[ nSize + 1 ];
std::sscanf( (char*) m_poResult->pabyData, LF_STATUS_RESPONSE_TEMPLATE,
&dl_status, pszResponse );
CPLHTTPDestroyResult( m_poResult );
i++;
CPLSleep( dfWait );
CPLDebug( "LCP_CLIENT", "Attempting to fetch LCP, try %d of %d, " \
"status: %d", i, nMaxTries, dl_status );
} while( dl_status < 400 && dl_status > 0 && i < nMaxTries );
delete [] pszResponse;
if( dl_status >= 900 && dl_status <= 902)
{
CPLError( CE_Warning, CPLE_AppDefined, "Failed to download lcp," \
"There was an extraction " \
"error on the server." );
return SURF_FETCH_E_IO_ERR;
}
else if( dl_status != 400 )
{
CPLError( CE_Warning, CPLE_AppDefined, "Failed to download lcp, timed " \
"out. Try increasing " \
"LCP_MAX_DOWNLOAD_TRIES or "
"LCP_DOWNLOAD_WAIT" );
return SURF_FETCH_E_TIMEOUT;
}
/*-----------------------------------------------------------------------------
* Download the landfire model
*-----------------------------------------------------------------------------*/
pszUrl = CPLSPrintf( LF_DOWNLOAD_JOB_TEMPLATE, m_JobId.c_str() );
m_poResult = CPLHTTPFetch( pszUrl, NULL );
CHECK_HTTP_RESULT( "Failed to get job status" );
/*
** Parse the URL from the returned string
*/
std::string ss((const char*) m_poResult->pabyData );
CPLHTTPDestroyResult( m_poResult );
std::size_t pos1 = ss.find("https://");
std::size_t pos2 = ss.find(".zip");
std::string url = ss.substr(pos1, (pos2+4-pos1));
pszUrl = url.c_str();
m_poResult = CPLHTTPFetch( pszUrl, NULL );
CHECK_HTTP_RESULT( "Failed to get job status" );
nSize = m_poResult->nDataLen;
VSILFILE *fout;
const char *pszTmpZip = CPLFormFilename( NULL,
CPLGenerateTempFilename( "NINJA_LCP_CLIENT" ),
".zip" );
fout = VSIFOpenL( pszTmpZip, "w+" );
if( NULL == fout )
{
CPLError( CE_Warning, CPLE_AppDefined, "Failed to create output file" );
CPLHTTPDestroyResult( m_poResult );
return SURF_FETCH_E_IO_ERR;
}
VSIFWriteL( m_poResult->pabyData, nSize, 1, fout );
VSIFCloseL( fout );
CPLHTTPDestroyResult( m_poResult );
/*
** Extract the lcp and the prj file, and 'save as'
*/
char **papszFileList = NULL;
std::string osPathInZip;
const char *pszVSIZip = CPLSPrintf( "/vsizip/%s", pszTmpZip );
CPLDebug( "LCP_CLIENT", "Extracting lcp from %s", pszVSIZip );
papszFileList = VSIReadDirRecursive( pszVSIZip );
int bFound = FALSE;
std::string osFullPath;
for( int i = 0; i < CSLCount( papszFileList ); i++ )
{
osFullPath = papszFileList[i];
if( osFullPath.find( "Landscape_1.lcp" ) != std::string::npos )
{
osPathInZip = CPLGetPath( papszFileList[i] );
CPLDebug( "LCP_CLIENT", "Found lcp in: %s", osPathInZip.c_str() );
bFound = TRUE;
break;
}
}
CSLDestroy( papszFileList );
if( !bFound )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to find lcp in archive" );
//VSIUnlink( pszTmpZip );
return SURF_FETCH_E_IO_ERR;
}
int nError = 0;
const char *pszFileToFind = CPLSPrintf( "%s/Landscape_1.lcp",
osPathInZip.c_str() );
nError = ExtractFileFromZip( pszTmpZip, pszFileToFind, filename );
if( nError )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to extract LCP from zip." );
VSIUnlink( pszTmpZip );
return SURF_FETCH_E_IO_ERR;
}
pszFileToFind = CPLSPrintf( "%s/Landscape_1.prj", osPathInZip.c_str() );
nError = ExtractFileFromZip( pszTmpZip, pszFileToFind,
CPLFormFilename( CPLGetPath( filename ),
CPLGetBasename( filename ),
".prj" ) );
if( nError )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to extract PRJ from zip." );
return SURF_FETCH_E_IO_ERR;
}
if( !CSLTestBoolean( CPLGetConfigOption( "LCP_KEEP_ARCHIVE", "FALSE" ) ) )
{
VSIUnlink( pszTmpZip );
}
return SURF_FETCH_E_NONE;
}
/**
* Constructor
*
* @param parent parent widget for the widget
*/
weatherModel::weatherModel(QWidget *parent) : QWidget(parent)
{
try {
tz_db.load_from_file( FindDataPath("date_time_zonespec.csv") );
}
catch( boost::local_time::data_not_accessible ) {
qDebug() << "diurnalInput::loadBoostTimeZones():"
<< "caught data_not_accessible";
//throw( new guiInitializationError( "Failed to load time zone, "
// "Cannot initialize interface. " ) );
}
catch( boost::local_time::bad_field_count ) {
qDebug() << "diurnalInput::loadBoostTimeZones():"
<< "caught bad_field_count";
//throw( new guiInitializationError( "Failed to load time zone, "
// "Cannot initialize interface. " ) );
}
//setDisabled(true);
weatherGroupBox = new QGroupBox( tr( "Weather Model Initialization" ),
this );
weatherGroupBox->setCheckable( true );
weatherGroupBox->setChecked(false);
downloadGroupBox = new QGroupBox(tr("Download Weather Data"));
modelComboBox = new QComboBox(this);
modelComboBox->setDuplicatesEnabled(false);
hourSpinBox = new QSpinBox(this);
hourSpinBox->setRange(3, 84);
hourSpinBox->setSingleStep(1);
hourSpinBox->setSuffix(" hours");
hourSpinBox->setValue(3);
hourSpinBox->setAccelerated( true );
//hourSpinBox->setVisible( false );
downloadToolButton = new QToolButton(this);
downloadToolButton->setText(tr("Download data"));
downloadToolButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
downloadToolButton->setIcon(QIcon(":server_go.png"));
//QDirModel will be deprecated in 4.7, use QFileSystemModel if upgrading
model = new QDirModel(this);
model->setReadOnly(true);
model->setSorting( QDir::Time );
forecastListLabel = new QLabel( this );
forecastListLabel->setText( "Downloaded forecasts" );
treeView = new QTreeView(this);
treeView->setModel(model);
treeView->header()->setStretchLastSection(true);
treeView->setAnimated(true);
treeView->setColumnHidden(1, true);
treeView->setColumnHidden(2, true);
//treeView->setColumnHidden(3, true);
//treeView->setDragDropMode( QAbstractItemView::DragOnly );
treeView->setAlternatingRowColors( true );
statusLabel = new QLabel(this);
statusLabel->setText(tr("Ready."));
refreshToolButton = new QToolButton(this);
refreshToolButton->setText(tr("Refresh Forecast List"));
refreshToolButton->setIcon(QIcon(":arrow_rotate_clockwise.png"));
refreshToolButton->setToolTip(tr("Refresh the forecast listing."));
refreshToolButton->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
connect(downloadToolButton, SIGNAL(clicked()),
this, SLOT(getData()));
connect(refreshToolButton, SIGNAL(clicked()),
this, SLOT(checkForModelData()));
connect(treeView, SIGNAL(clicked(const QModelIndex &)),
this, SLOT(displayForecastTime(const QModelIndex &)));
//clear the selection on uncheck of group box
connect(weatherGroupBox, SIGNAL(toggled(bool)),
this, SLOT(unselectForecast(bool)));
//change time for given model
connect(modelComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(setTimeLimits(int)));
connect(modelComboBox, SIGNAL(currentIndexChanged(int)),
this, SLOT(setComboToolTip(int)));
//layout
downloadLayout = new QHBoxLayout;
downloadLayout->addWidget(modelComboBox);
downloadLayout->addWidget(hourSpinBox);
downloadLayout->addWidget(downloadToolButton);
downloadGroupBox->setLayout(downloadLayout);
treeLayout = new QHBoxLayout;
treeLayout->addWidget(treeView);
loadLayout = new QHBoxLayout;
loadLayout->addWidget(statusLabel);
loadLayout->addWidget(refreshToolButton);
weatherLayout = new QVBoxLayout;
weatherLayout->addWidget(downloadGroupBox);
weatherLayout->addWidget(forecastListLabel);
weatherLayout->addLayout(treeLayout);
weatherLayout->addLayout(loadLayout);
weatherGroupBox->setLayout( weatherLayout );
layout = new QVBoxLayout;
layout->addWidget( weatherGroupBox );
setLayout(layout);
#ifdef WITH_NOMADS_SUPPORT
nNomadsCount = 0;
while( apszNomadsKeys[nNomadsCount][0] != NULL )
nNomadsCount++;
papoNomads = new NomadsWxModel*[nNomadsCount];
int i = 0;
while( apszNomadsKeys[i][0] != NULL )
{
papoNomads[i] = new NomadsWxModel( apszNomadsKeys[i][0] );
i++;
}
CPLDebug( "WINDNINJA", "Loaded %d NOMADS models", nNomadsCount );
#endif
progressDialog = new QProgressDialog( this );
progressDialog->setAutoClose( false );
progressDialog->setAutoReset( false );
progressDialog->setModal( true );
pGlobProg = progressDialog;
loadModelComboBox();
checkForModelData();
}
std::string FetchTimeZone( double dfX, double dfY, const char *pszWkt )
{
CPLDebug( "WINDNINJA", "Fetching timezone for %lf,%lf", dfX, dfY );
if( pszWkt != NULL )
{
OGRSpatialReference oSourceSRS, oTargetSRS;
OGRCoordinateTransformation *poCT;
oSourceSRS.SetWellKnownGeogCS( "WGS84" );
oTargetSRS.importFromWkt( (char**)&pszWkt );
poCT = OGRCreateCoordinateTransformation( &oSourceSRS, &oTargetSRS );
if( poCT == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"OGR coordinate transformation failed" );
return std::string();
}
if( !poCT->Transform( 1, &dfX, &dfY ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"OGR coordinate transformation failed" );
return std::string();
}
OGRCoordinateTransformation::DestroyCT( poCT );
}
OGRGeometryH hGeometry = OGR_G_CreateGeometry( wkbPoint );
OGR_G_SetPoint_2D( hGeometry, 0, dfX, dfY );
OGRDataSourceH hDS;
OGRLayerH hLayer;
OGRFeatureH hFeature;
std::string oTzFile = FindDataPath( "tz_world.zip" );
oTzFile = "/vsizip/" + oTzFile + "/world/tz_world.shp";
hDS = OGROpen( oTzFile.c_str(), 0, NULL );
if( hDS == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to open datasource: %s", oTzFile.c_str() );
return std::string();
}
hLayer = OGR_DS_GetLayer( hDS, 0 );
OGR_L_SetSpatialFilter( hLayer, hGeometry );
OGR_L_ResetReading( hLayer );
int nMaxTries = 5;
int nTries = 0;
OGRGeometryH hBufferGeometry;
do
{
if( nTries == 0 )
{
hBufferGeometry = OGR_G_Clone( hGeometry );
}
else
{
hBufferGeometry = OGR_G_Buffer( hGeometry, 0.2 * nTries, 30 );
}
OGR_L_SetSpatialFilter( hLayer, hBufferGeometry );
hFeature = OGR_L_GetNextFeature( hLayer );
OGR_G_DestroyGeometry( hBufferGeometry );
nTries++;
}
while( hFeature == NULL && nTries < nMaxTries );
std::string oTimeZone;
if( hFeature == NULL )
{
oTimeZone = std::string();
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to find timezone" );
}
else
{
oTimeZone = std::string( OGR_F_GetFieldAsString( hFeature, 0 ) );
}
OGR_F_Destroy( hFeature );
OGR_G_DestroyGeometry( hGeometry );
OGR_DS_Destroy( hDS );
return oTimeZone;
}
