void MainWindow::addLayer()
{
QString myFileName = QFileDialog::getOpenFileName(this, tr("Open File"),
QCoreApplication::applicationDirPath () + "/data",
tr("GeoTiff (*.tif)"));
QFileInfo myRasterFileInfo(myFileName);
QgsRasterLayer * mypLayer = new QgsRasterLayer(myRasterFileInfo.filePath(),
myRasterFileInfo.completeBaseName());
if (mypLayer->isValid())
{
qDebug("Layer is valid");
}
else
{
qDebug("Layer is NOT valid");
return;
}
// render strategy for grayscale image (will be rendered as pseudocolor)
mypLayer->setDrawingStyle( QgsRasterLayer::SingleBandPseudoColor );
mypLayer->setColorShadingAlgorithm( QgsRasterLayer::PseudoColorShader );
mypLayer->setContrastEnhancementAlgorithm(
QgsContrastEnhancement::StretchToMinimumMaximum, false );
mypLayer->setMinimumValue( mypLayer->grayBandName(), 0.0, false );
mypLayer->setMaximumValue( mypLayer->grayBandName(), 10.0 );
// Add the Vector Layer to the Layer Registry
QgsMapLayerRegistry::instance()->addMapLayer(mypLayer, TRUE);
//create a layerset
QList<QgsMapCanvasLayer> myList;
// Add the layers to the Layer Set
myList.append(QgsMapCanvasLayer(mypLayer, TRUE));//bool visibility
// set the canvas to the extent of our layer
mpMapCanvas->setExtent(mypLayer->extent());
// Set the Map Canvas Layer Set
mpMapCanvas->setLayerSet(myList);
}
void QgsBrowserLayerProperties::setItem( QgsDataItem* item )
{
QgsLayerItem *layerItem = qobject_cast<QgsLayerItem*>( item );
if ( !layerItem )
return;
mNoticeLabel->clear();
QgsMapLayer::LayerType type = layerItem->mapLayerType();
QString layerMetadata = tr( "Error" );
QgsCoordinateReferenceSystem layerCrs;
// temporarily override /Projections/defaultBehaviour to avoid dialog prompt
QSettings settings;
QString defaultProjectionOption = settings.value( "/Projections/defaultBehaviour", "prompt" ).toString();
if ( settings.value( "/Projections/defaultBehaviour", "prompt" ).toString() == "prompt" )
{
settings.setValue( "/Projections/defaultBehaviour", "useProject" );
}
// find root item
// we need to create a temporary layer to get metadata
// we could use a provider but the metadata is not as complete and "pretty" and this is easier
QgsDebugMsg( QString( "creating temporary layer using path %1" ).arg( layerItem->path() ) );
if ( type == QgsMapLayer::RasterLayer )
{
QgsDebugMsg( "creating raster layer" );
// should copy code from addLayer() to split uri ?
QgsRasterLayer* layer = new QgsRasterLayer( layerItem->uri(), layerItem->uri(), layerItem->providerKey() );
if ( layer )
{
if ( layer->isValid() )
{
layerCrs = layer->crs();
layerMetadata = layer->metadata();
}
delete layer;
}
}
else if ( type == QgsMapLayer::VectorLayer )
{
QgsDebugMsg( "creating vector layer" );
QgsVectorLayer* layer = new QgsVectorLayer( layerItem->uri(), layerItem->name(), layerItem->providerKey() );
if ( layer )
{
if ( layer->isValid() )
{
layerCrs = layer->crs();
layerMetadata = layer->metadata();
}
delete layer;
}
}
else if ( type == QgsMapLayer::PluginLayer )
{
// TODO: support display of properties for plugin layers
return;
}
// restore /Projections/defaultBehaviour
if ( defaultProjectionOption == "prompt" )
{
settings.setValue( "/Projections/defaultBehaviour", defaultProjectionOption );
}
mNameLabel->setText( layerItem->name() );
mUriLabel->setText( layerItem->uri() );
mProviderLabel->setText( layerItem->providerKey() );
QString myStyle = QgsApplication::reportStyleSheet();
mMetadataTextBrowser->document()->setDefaultStyleSheet( myStyle );
mMetadataTextBrowser->setHtml( layerMetadata );
// report if layer was set to to project crs without prompt (may give a false positive)
if ( defaultProjectionOption == "prompt" )
{
QgsCoordinateReferenceSystem defaultCrs =
QgisApp::instance()->mapCanvas()->mapSettings().destinationCrs();
if ( layerCrs == defaultCrs )
mNoticeLabel->setText( "NOTICE: Layer srs set from project (" + defaultCrs.authid() + ')' );
}
if ( mNoticeLabel->text().isEmpty() )
{
mNoticeLabel->hide();
}
}
void TestQgsWcsPublicServers::test( )
{
QStringList versions;
// It may happen that server supports 1.1.1, but does not accept 1.1 (http://zeus.pin.unifi.it/gi-wcs/http)
versions << "" << "1.0.0" << "1.1.0"; // empty for default
QStringList servers;
// Some (first) coverages do not advertize any supportedCRS and sever gives
// error both with native CRS (EPSG::561005) and EPSG:4326
// MOD* coverages work OK
servers << "http://argon.geogr.uni-jena.de:8080/geoserver/ows";
servers << "http://demo.geonode.org/geoserver/wcs";
servers << "http://demo.mapserver.org/cgi-bin/wcs";
servers << "http://demo.opengeo.org/geoserver/wcs";
// geobrain.laits.gmu.edu servers are quite slow
servers << "http://geobrain.laits.gmu.edu/cgi-bin/gbwcs-dem";
servers << "http://geobrain.laits.gmu.edu/cgi-bin/ows8/wcseo";
servers << "http://geobrain.laits.gmu.edu/cgi-bin/wcs110";
servers << "http://geobrain.laits.gmu.edu/cgi-bin/wcs-all";
servers << "http://iceds.ge.ucl.ac.uk/cgi-bin/icedswcs";
servers << "http://motherlode.ucar.edu:8080/thredds/wcs/fmrc/NCEP/DGEX/Alaska_12km/NCEP-DGEX-Alaska_12km_best.ncd";
servers << "http://navigator.state.or.us/ArcGIS/services/Framework/Imagery_Mosaic2009/ImageServer/WCSServer";
servers << "http://nsidc.org/cgi-bin/atlas_north";
servers << "http://sedac.ciesin.columbia.edu/geoserver/wcs";
// Big and slow
//servers << "http://webmap.ornl.gov/ogcbroker/wcs";
servers << "http://ws.csiss.gmu.edu/cgi-bin/wcs-t";
// Big and slow
//servers << "http://ws.laits.gmu.edu/cgi-bin/wcs-all";
// Currently very slow or down
//servers << "http://www.sogeo.ch/geoserver/wcs";
// Slow and erroneous
//servers << "http://zeus.pin.unifi.it/gi-wcs/http";
foreach ( QString server, servers )
{
QStringList myServerLog;
myServerLog << "server:" + server;
QString myServerDirName = server;
myServerDirName.replace( QRegExp( "[:/]+" ), "." );
myServerDirName.replace( QRegExp( "\\.$" ), "" );
QgsDebugMsg( "myServerDirName = " + myServerDirName );
QDir myServerDir( mCacheDir.absolutePath() + QDir::separator() + myServerDirName );
QString myServerLogPath = myServerDir.absolutePath() + QDir::separator() + "server.log";
if ( QFileInfo( myServerLogPath ).exists() )
{
QgsDebugMsg( "cache exists " + myServerDir.absolutePath() );
continue;
}
if ( !myServerDir.exists() )
{
mCacheDir.mkdir( myServerDirName );
}
foreach ( QString version, versions )
{
QgsDebugMsg( "server: " + server + " version: " + version );
QgsDataSourceURI myServerUri;
myServerUri.setParam( "url", server );
if ( !version.isEmpty() )
{
myServerUri.setParam( "version", version );
}
QgsWcsCapabilities myCapabilities;
myCapabilities.setUri( myServerUri );
if ( !myCapabilities.lastError().isEmpty() )
{
QgsDebugMsg( myCapabilities.lastError() );
myServerLog << "error: (version: " + version + ") " + myCapabilities.lastError().replace( "\n", " " );
continue;
}
QVector<QgsWcsCoverageSummary> myCoverages;
if ( !myCapabilities.supportedCoverages( myCoverages ) )
{
QgsDebugMsg( "Cannot get list of coverages" );
myServerLog << "error: (version: " + version + ") Cannot get list of coverages";
continue;
}
int myCoverageCount = 0;
int myStep = myCoverages.size() / mMaxCoverages;
int myStepCount = -1;
foreach ( QgsWcsCoverageSummary myCoverage, myCoverages )
{
QgsDebugMsg( "coverage: " + myCoverage.identifier );
// Go in steps to get more success/errors
if ( myStepCount == -1 || myStepCount > myStep )
{
myStepCount = 0;
}
else
{
myStepCount++;
continue;
}
myCoverageCount++;
if ( myCoverageCount > mMaxCoverages ) break;
QString myPath = myServerDir.absolutePath() + QDir::separator() + myCoverage.identifier;
if ( !version.isEmpty() )
{
myPath += "-" + version;
}
QString myLogPath = myPath + ".log";
if ( QFileInfo( myLogPath ).exists() )
{
QMap<QString, QString> log = readLog( myLogPath );
if ( !log.value( "identifier" ).isEmpty() && log.value( "error" ).isEmpty() ) continue;
}
QStringList myLog;
myLog << "identifier:" + myCoverage.identifier;
myCapabilities.describeCoverage( myCoverage.identifier );
myCoverage = myCapabilities.coverage( myCoverage.identifier ); // get described
QgsDataSourceURI myUri = myServerUri;
myUri.setParam( "identifier", myCoverage.identifier );
if ( myCoverage.times.size() > 0 )
{
myUri.setParam( "time", myCoverage.times.value( 0 ) );
}
myLog << "version:" + version;
myLog << "uri:" + myUri.encodedUri();
int myWidth = 100;
int myHeight = 100;
if ( myCoverage.hasSize )
{
myHeight = static_cast<int>( qRound( 1.0 * myWidth * myCoverage.height / myCoverage.width ) );
}
myLog << QString( "hasSize:%1" ).arg( myCoverage.hasSize );
QgsRasterLayer * myLayer = new QgsRasterLayer( myUri.encodedUri(), myCoverage.identifier, "wcs", true );
if ( myLayer->isValid() )
{
int myBandCount = myLayer->dataProvider()->bandCount();
myLog << "bandCount:" + QString::number( myBandCount );
if ( myBandCount > 0 )
{
myLog << "srcType:" + QString::number( myLayer->dataProvider()->srcDataType( 1 ) );
QgsRasterBandStats myStats = myLayer->dataProvider()->bandStatistics( 1, QgsRasterBandStats::All, QgsRectangle(), myWidth * myHeight );
myLog << "min:" + QString::number( myStats.minimumValue );
myLog << "max:" + QString::number( myStats.maximumValue );
}
QgsMapRenderer myMapRenderer;
QList<QgsMapLayer *> myLayersList;
myLayersList.append( myLayer );
QgsMapLayerRegistry::instance()->addMapLayers( myLayersList, false );
QMap<QString, QgsMapLayer*> myLayersMap = QgsMapLayerRegistry::instance()->mapLayers();
myMapRenderer.setLayerSet( myLayersMap.keys() );
myMapRenderer.setExtent( myLayer->extent() );
QImage myImage( myWidth, myHeight, QImage::Format_ARGB32_Premultiplied );
myImage.fill( 0 );
myMapRenderer.setOutputSize( QSize( myWidth, myHeight ), myImage.logicalDpiX() );
QPainter myPainter( &myImage );
myMapRenderer.render( &myPainter );
// Save rendered image
QString myPngPath = myPath + ".png";
QgsDebugMsg( "myPngPath = " + myPngPath );
myImage.save( myPngPath );
// Verify data
QSet<QString> myValues; // cannot be QSet<double>
void *myData = myLayer->dataProvider()->readBlock( 1, myLayer->extent(), myWidth, myHeight );
if ( myData )
{
int myType = myLayer->dataProvider()->dataType( 1 );
for ( int row = 0; row < myHeight; row++ )
{
for ( int col = 0; col < myWidth; col++ )
{
double value = myLayer->dataProvider()->readValue( myData, myType, row * myWidth + col );
QString valueStr = QString::number( value );
if ( !myValues.contains( valueStr ) ) myValues.insert( valueStr );
}
}
free( myData );
}
QgsDebugMsg( QString( "%1 values" ).arg( myValues.size() ) );
myLog << QString( "valuesCount:%1" ).arg( myValues.size() );
// Verify image colors
QSet<QRgb> myColors;
for ( int row = 0; row < myHeight; row++ )
{
for ( int col = 0; col < myWidth; col++ )
{
QRgb color = myImage.pixel( col, row );
if ( !myColors.contains( color ) ) myColors.insert( color );
}
}
QgsDebugMsg( QString( "%1 colors" ).arg( myColors.size() ) );
myLog << QString( "colorsCount:%1" ).arg( myColors.size() );
}
else
{
QgsDebugMsg( "Layer is not valid" );
myLog << "error:Layer is not valid";
}
QFile myLogFile( myLogPath );
myLogFile.open( QIODevice::WriteOnly | QIODevice::Text );
QTextStream myStream( &myLogFile );
myStream << myLog.join( "\n" );
myLogFile.close();
QgsMapLayerRegistry::instance()->removeAllMapLayers();
}
QgsMapLayer* QgsHostedRDSBuilder::createMapLayer( const QDomElement& elem,
const QString &layerName,
QList<QTemporaryFile*> &filesToRemove,
QList<QgsMapLayer*> &layersToRemove,
bool allowCaching ) const
{
Q_UNUSED( filesToRemove );
if ( elem.isNull() )
{
return nullptr;
}
QString uri = elem.attribute( QStringLiteral( "uri" ), QStringLiteral( "not found" ) );
if ( uri == QLatin1String( "not found" ) )
{
QgsDebugMsg( "Uri not found" );
return nullptr;
}
else
{
QgsDebugMsg( "Trying to get hostedrds layer from cache with uri: " + uri );
QgsRasterLayer* rl = nullptr;
if ( allowCaching )
{
rl = qobject_cast<QgsRasterLayer*>( QgsMSLayerCache::instance()->searchLayer( uri, layerName ) );
}
if ( !rl || !rl->isValid() )
{
QgsDebugMsg( "hostedrds layer not in cache, so create and insert it" );
rl = new QgsRasterLayer( uri, layerNameFromUri( uri ) );
if ( allowCaching )
{
QgsMSLayerCache::instance()->insertLayer( uri, layerName, rl );
}
else
{
layersToRemove.push_back( rl );
}
}
clearRasterSymbology( rl );
//projection
if ( rl )
{
QString epsg = elem.attribute( QStringLiteral( "epsg" ) );
if ( !epsg.isEmpty() )
{
bool conversionOk;
int epsgnr = epsg.toInt( &conversionOk );
if ( conversionOk )
{
//set spatial ref sys
QgsCoordinateReferenceSystem srs = QgsCoordinateReferenceSystem::fromOgcWmsCrs( QStringLiteral( "EPSG:%1" ).arg( epsgnr ) );
rl->setCrs( srs );
}
}
}
return rl;
}
}
QgsRasterLayer* QgsRemoteOWSBuilder::wmsLayerFromUrl( const QString& url, const QString& layerName, QList<QgsMapLayer*>& layersToRemove, bool allowCaching ) const
{
QgsDebugMsg( "Entering" );
QgsRasterLayer* result = nullptr;
QString baseUrl, format, crs;
QStringList layerList, styleList;
if ( allowCaching )
{
result = qobject_cast<QgsRasterLayer*>( QgsMSLayerCache::instance()->searchLayer( url, layerName ) );
}
if ( result )
{
return result;
}
QStringList urlList = url.split( QStringLiteral( "?" ) );
if ( urlList.size() < 2 )
{
return nullptr;
}
baseUrl = urlList.at( 0 );
QStringList paramList = urlList.at( 1 ).split( QStringLiteral( "&" ) );
QStringList::const_iterator paramIt;
for ( paramIt = paramList.constBegin(); paramIt != paramList.constEnd(); ++paramIt )
{
if ( paramIt->startsWith( QLatin1String( "http" ), Qt::CaseInsensitive ) )
{
baseUrl = paramIt->split( QStringLiteral( "=" ) ).at( 1 );
}
else if ( paramIt->startsWith( QLatin1String( "FORMAT" ), Qt::CaseInsensitive ) )
{
format = paramIt->split( QStringLiteral( "=" ) ).at( 1 );
}
else if ( paramIt->startsWith( QLatin1String( "CRS" ), Qt::CaseInsensitive ) )
{
crs = paramIt->split( QStringLiteral( "=" ) ).at( 1 );
}
else if ( paramIt->startsWith( QLatin1String( "LAYERS" ), Qt::CaseInsensitive ) )
{
layerList = paramIt->split( QStringLiteral( "=" ) ).at( 1 ).split( QStringLiteral( "," ) );
}
else if ( paramIt->startsWith( QLatin1String( "STYLES" ), Qt::CaseInsensitive ) )
{
styleList = paramIt->split( QStringLiteral( "=" ) ).at( 1 ).split( QStringLiteral( "," ) );
}
}
QgsDebugMsg( "baseUrl: " + baseUrl );
QgsDebugMsg( "format: " + format );
QgsDebugMsg( "crs: " + crs );
QgsDebugMsg( "layerList first item: " + layerList.at( 0 ) );
QgsDebugMsg( "styleList first item: " + styleList.at( 0 ) );
QgsDataSourceUri uri;
uri.setParam( QStringLiteral( "url" ), baseUrl );
uri.setParam( QStringLiteral( "format" ), format );
uri.setParam( QStringLiteral( "crs" ), crs );
uri.setParam( QStringLiteral( "layers" ), layerList );
uri.setParam( QStringLiteral( "styles" ), styleList );
result = new QgsRasterLayer( uri.encodedUri(), QLatin1String( "" ), QStringLiteral( "wms" ) );
if ( !result->isValid() )
{
return nullptr;
}
//insert into cache
if ( allowCaching )
{
QgsMSLayerCache::instance()->insertLayer( url, layerName, result );
}
else
{
layersToRemove.push_back( result );
}
return result;
}
