QgsMapLayer* QgsHostedRDSBuilder::createMapLayer( const QDomElement& elem, const QString& layerName, QList<QTemporaryFile*>& filesToRemove, QList<QgsMapLayer*>& layersToRemove, bool allowCaching ) const
{
QgsMSDebugMsg( "entering." );
if ( elem.isNull() )
{
return 0;
}
QString uri = elem.attribute( "uri", "not found" );
if ( uri == "not found" )
{
QgsMSDebugMsg( "Uri not found" );
return 0;
}
else
{
QgsMSDebugMsg( "Trying to get hostedrds layer from cache with uri: " + uri );
QgsRasterLayer* rl = 0;
if ( allowCaching )
{
rl = dynamic_cast<QgsRasterLayer*>( QgsMSLayerCache::instance()->searchLayer( uri, layerName ) );
}
if ( !rl )
{
QgsMSDebugMsg( "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( "epsg" );
if ( !epsg.isEmpty() )
{
bool conversionOk;
int epsgnr = epsg.toInt( &conversionOk );
if ( conversionOk )
{
//set spatial ref sys
QgsCoordinateReferenceSystem srs;
srs.createFromOgcWmsCrs( QString( "EPSG:%1" ).arg( epsgnr ) );
rl->setCrs( srs );
}
}
}
return rl;
}
}
void QgsTileScaleWidget::layerChanged( QgsMapLayer *layer )
{
mSlider->setDisabled( true );
QgsRasterLayer *rl = qobject_cast<QgsRasterLayer *>( layer );
if ( !rl || rl->providerType() != QLatin1String( "wms" ) || !rl->dataProvider() )
return;
QVariant res = rl->dataProvider()->property( "resolutions" );
mResolutions.clear();
Q_FOREACH ( const QVariant &r, res.toList() )
{
QgsDebugMsg( QString( "found resolution: %1" ).arg( r.toDouble() ) );
mResolutions << r.toDouble();
}
if ( mResolutions.isEmpty() )
return;
mSlider->setRange( 0, mResolutions.size() - 1 );
mSlider->setTickInterval( 1 );
mSlider->setInvertedAppearance( true );
mSlider->setPageStep( 1 );
mSlider->setTracking( false );
scaleChanged( mMapCanvas->scale() );
mSlider->setEnabled( true );
show();
}
double QgsGCPCanvasItem::residualToScreenFactor() const
{
if ( !mMapCanvas )
{
return 1;
}
double mapUnitsPerScreenPixel = mMapCanvas->mapUnitsPerPixel();
double mapUnitsPerRasterPixel = 1.0;
if ( mMapCanvas->mapRenderer() )
{
QStringList canvasLayers = mMapCanvas->mapRenderer()->layerSet();
if ( canvasLayers.size() > 0 )
{
QString layerId = canvasLayers.at( 0 );
QgsMapLayer* mapLayer = QgsMapLayerRegistry::instance()->mapLayer( layerId );
if ( mapLayer )
{
QgsRasterLayer* rasterLayer = dynamic_cast<QgsRasterLayer*>( mapLayer );
if ( rasterLayer )
{
mapUnitsPerRasterPixel = rasterLayer->rasterUnitsPerPixel();
}
}
}
}
return 1.0 / ( mapUnitsPerScreenPixel * mapUnitsPerRasterPixel );
}
void QgsZonalStatisticsDialog::insertAvailableLayers()
{
//insert available raster layers
//enter available layers into the combo box
QMap<QString, QgsMapLayer*> mapLayers = QgsMapLayerRegistry::instance()->mapLayers();
QMap<QString, QgsMapLayer*>::iterator layer_it = mapLayers.begin();
for ( ; layer_it != mapLayers.end(); ++layer_it )
{
QgsRasterLayer* rl = dynamic_cast<QgsRasterLayer*>( layer_it.value() );
if ( rl )
{
QgsRasterDataProvider* rp = rl->dataProvider();
if ( rp && rp->name() == "gdal" )
{
mRasterLayerComboBox->addItem( rl->name(), QVariant( rl->id() ) );
}
}
else
{
QgsVectorLayer* vl = dynamic_cast<QgsVectorLayer*>( layer_it.value() );
if ( vl && vl->geometryType() == QGis::Polygon )
{
QgsVectorDataProvider* provider = vl->dataProvider();
if ( provider->capabilities() & QgsVectorDataProvider::AddAttributes )
{
mPolygonLayerComboBox->addItem( vl->name(), QVariant( vl->id() ) );
}
}
}
}
}
QImage QgsWmsLegendNode::getLegendGraphic() const
{
if ( ! mValid && ! mFetcher )
{
// or maybe in presence of a downloader we should just delete it
// and start a new one ?
QgsRasterLayer *layer = qobject_cast<QgsRasterLayer *>( mLayerNode->layer() );
const QgsLayerTreeModel *mod = model();
if ( ! mod )
return mImage;
const QgsMapSettings *ms = mod->legendFilterMapSettings();
QgsRasterDataProvider *prov = layer->dataProvider();
if ( ! prov )
return mImage;
Q_ASSERT( ! mFetcher );
mFetcher.reset( prov->getLegendGraphicFetcher( ms ) );
if ( mFetcher )
{
connect( mFetcher.get(), &QgsImageFetcher::finish, this, &QgsWmsLegendNode::getLegendGraphicFinished );
connect( mFetcher.get(), &QgsImageFetcher::error, this, &QgsWmsLegendNode::getLegendGraphicErrored );
connect( mFetcher.get(), &QgsImageFetcher::progress, this, &QgsWmsLegendNode::getLegendGraphicProgress );
mFetcher->start();
} // else QgsDebugMsg("XXX No legend supported?");
}
return mImage;
}
const QImage& QgsWMSLegendNode::getLegendGraphic() const
{
if ( ! mValid && ! mFetcher )
{
// or maybe in presence of a downloader we should just delete it
// and start a new one ?
QgsRasterLayer* layer = qobject_cast<QgsRasterLayer*>( mLayerNode->layer() );
const QgsLayerTreeModel* mod = model();
if ( ! mod ) return mImage;
const QgsMapSettings* ms = mod->legendFilterByMap();
QgsRasterDataProvider* prov = layer->dataProvider();
Q_ASSERT( ! mFetcher );
mFetcher.reset( prov->getLegendGraphicFetcher( ms ) );
if ( mFetcher )
{
connect( mFetcher.data(), SIGNAL( finish( const QImage& ) ), this, SLOT( getLegendGraphicFinished( const QImage& ) ) );
connect( mFetcher.data(), SIGNAL( error( const QString& ) ), this, SLOT( getLegendGraphicErrored( const QString& ) ) );
connect( mFetcher.data(), SIGNAL( progress( qint64, qint64 ) ), this, SLOT( getLegendGraphicProgress( qint64, qint64 ) ) );
mFetcher->start();
} // else QgsDebugMsg("XXX No legend supported ?");
}
double QgsGCPCanvasItem::residualToScreenFactor() const
{
if ( !mMapCanvas )
{
return 1;
}
double mapUnitsPerScreenPixel = mMapCanvas->mapUnitsPerPixel();
double mapUnitsPerRasterPixel = 1.0;
QList<QgsMapLayer*> canvasLayers = mMapCanvas->mapSettings().layers();
if ( !canvasLayers.isEmpty() )
{
QgsMapLayer* mapLayer = canvasLayers.at( 0 );
if ( mapLayer )
{
QgsRasterLayer* rasterLayer = dynamic_cast<QgsRasterLayer*>( mapLayer );
if ( rasterLayer )
{
mapUnitsPerRasterPixel = rasterLayer->rasterUnitsPerPixelX();
}
}
}
return 1.0 / ( mapUnitsPerScreenPixel * mapUnitsPerRasterPixel );
}
int QgsLegendModel::addRasterLayerItem( QStandardItem* layerItem, QgsMapLayer* rlayer )
{
if ( !layerItem || !rlayer )
{
return 1;
}
QgsRasterLayer* rasterLayer = qobject_cast<QgsRasterLayer *>( rlayer );
if ( !rasterLayer )
{
return 2;
}
QgsComposerRasterSymbolItem* currentSymbolItem = new QgsComposerRasterSymbolItem();
//use a vector symbol item without symbol
if ( mHasTopLevelWindow ) //only use QIcon / QPixmap if we have a running x-server
{
currentSymbolItem->setIcon( QIcon( rasterLayer->legendAsPixmap( true ) ) );
}
currentSymbolItem->setLayerID( rasterLayer->id() );
int currentRowCount = layerItem->rowCount();
layerItem->setChild( currentRowCount, 0, currentSymbolItem );
return 0;
}
void QgsRasterCalcDialog::on_mCurrentLayerExtentButton_clicked()
{
QListWidgetItem* currentLayerItem = mRasterBandsListWidget->currentItem();
if ( currentLayerItem )
{
QgsRasterLayer* rlayer = nullptr;
QList<QgsRasterCalculatorEntry>::const_iterator rasterIt = mAvailableRasterBands.constBegin();
for ( ; rasterIt != mAvailableRasterBands.constEnd(); ++rasterIt )
{
if ( rasterIt->ref == currentLayerItem->text() )
{
rlayer = rasterIt->raster;
}
}
if ( !rlayer )
{
return;
}
QgsRectangle layerExtent = rlayer->extent();
mXMinSpinBox->setValue( layerExtent.xMinimum() );
mXMaxSpinBox->setValue( layerExtent.xMaximum() );
mYMinSpinBox->setValue( layerExtent.yMinimum() );
mYMaxSpinBox->setValue( layerExtent.yMaximum() );
mNColumnsSpinBox->setValue( rlayer->width() );
mNRowsSpinBox->setValue( rlayer->height() );
mCrsSelector->setCrs( rlayer->crs() );
}
}
int QgsLegendModel::addRasterLayerItems( QStandardItem* layerItem, QgsMapLayer* rlayer )
{
if ( !layerItem || !rlayer )
{
return 1;
}
QgsRasterLayer* rasterLayer = qobject_cast<QgsRasterLayer *>( rlayer );
if ( !rasterLayer )
{
return 2;
}
QList< QPair< QString, QColor > > rasterItemList = rasterLayer->legendSymbologyItems();
QList< QPair< QString, QColor > >::const_iterator itemIt = rasterItemList.constBegin();
for(; itemIt != rasterItemList.constEnd(); ++itemIt )
{
QgsComposerRasterSymbolItem* currentSymbolItem = new QgsComposerRasterSymbolItem( itemIt->first );
if( mHasTopLevelWindow )
{
QPixmap itemPixmap( 20, 20 );
itemPixmap.fill( itemIt->second );
currentSymbolItem->setIcon( QIcon( itemPixmap ) );
}
currentSymbolItem->setLayerID( rasterLayer->id() );
currentSymbolItem->setColor( itemIt->second );
int currentRowCount = layerItem->rowCount();
layerItem->setChild( currentRowCount, 0, currentSymbolItem );
}
return 0;
}
void SWGISBrowser::updateCurrentTab()
{
Tab currentTab = this->activeTab();
if(currentTab == Metadata && this->m_DirtyMetadata)
{
if(this->m_Layer && this->m_Layer->isValid())
{
QString myStyle = QgsApplication::reportStyleSheet();
ui->metaTextBrowser->document()->setDefaultStyleSheet(myStyle);
ui->metaTextBrowser->setHtml(this->m_Layer->metadata());
}
else
ui->metaTextBrowser->setHtml(QString());
this->m_DirtyMetadata = false;
}
if(currentTab == Preview && this->m_DirtyPreview)
{
if (this->m_Layer && this->m_Layer->isValid())
{
// Create preview: add to map canvas
QList<QgsMapCanvasLayer> layers;
layers << QgsMapCanvasLayer( this->m_Layer );
ui->mapCanvas->setLayerSet( layers );
QgsRectangle fullExtent = this->m_Layer->extent();
fullExtent.scale( 1.05 ); // add some border
ui->mapCanvas->setExtent( fullExtent );
ui->mapCanvas->refresh();
QgsRasterLayer *rlayer = qobject_cast<QgsRasterLayer *>(this->m_Layer);
if (rlayer)
{
connect(rlayer->dataProvider(), SIGNAL(dataChanged()), rlayer, SLOT(triggerRepaint()));
connect(rlayer->dataProvider(), SIGNAL(dataChanged()), ui->mapCanvas, SLOT(refresh()));
}
}
this->m_DirtyPreview = false;
}
if (currentTab == Attributes && this->m_DirtyAttributes)
{
if (this->m_Layer && this->m_Layer->isValid() && this->m_Layer->type() == QgsMapLayer::VectorLayer)
{
QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer*>(this->m_Layer);
QApplication::setOverrideCursor(Qt::WaitCursor);
this->setLayer(vlayer);
QApplication::restoreOverrideCursor();
}
else
{
this->setLayer(nullptr);
}
this->m_DirtyAttributes = false;
}
}
void QgsRasterCalcDialog::insertAvailableRasterBands()
{
const QMap<QString, QgsMapLayer *> &layers = QgsProject::instance()->mapLayers();
QMap<QString, QgsMapLayer *>::const_iterator layerIt = layers.constBegin();
for ( ; layerIt != layers.constEnd(); ++layerIt )
{
QgsRasterLayer *rlayer = dynamic_cast<QgsRasterLayer *>( layerIt.value() );
if ( rlayer && rlayer->dataProvider() && rlayer->dataProvider()->name() == QLatin1String( "gdal" ) )
{
if ( !mExtentSizeSet ) //set bounding box / resolution of output to the values of the first possible input layer
{
setExtentSize( rlayer->width(), rlayer->height(), rlayer->extent() );
mCrsSelector->setCrs( rlayer->crs() );
}
//get number of bands
for ( int i = 0; i < rlayer->bandCount(); ++i )
{
QgsRasterCalculatorEntry entry;
entry.raster = rlayer;
entry.bandNumber = i + 1;
entry.ref = rlayer->name() + '@' + QString::number( i + 1 );
mAvailableRasterBands.push_back( entry );
mRasterBandsListWidget->addItem( entry.ref );
}
}
}
}
QVector<QgsRasterCalculatorEntry> QgsRasterCalculatorEntry::rasterEntries()
{
QVector<QgsRasterCalculatorEntry> availableEntries;
const QMap<QString, QgsMapLayer *> &layers = QgsProject::instance()->mapLayers();
auto uniqueRasterBandIdentifier = [ & ]( QgsRasterCalculatorEntry & entry ) -> bool
{
unsigned int i( 1 );
entry.ref = QStringLiteral( "%1@%2" ).arg( entry.raster->name() ).arg( entry.bandNumber );
while ( true )
{
bool unique( true );
for ( const auto &ref : qgis::as_const( availableEntries ) )
{
// Safety belt
if ( !( entry.raster && ref.raster ) )
continue;
// Check if a layer with the same data source was already added to the list
if ( ref.raster->publicSource() == entry.raster->publicSource() )
return false;
// If same name but different source
if ( ref.ref == entry.ref )
{
unique = false;
entry.ref = QStringLiteral( "%1_%2@%3" ).arg( entry.raster->name() ).arg( i++ ).arg( entry.bandNumber );
}
}
if ( unique )
return true;
}
};
QMap<QString, QgsMapLayer *>::const_iterator layerIt = layers.constBegin();
for ( ; layerIt != layers.constEnd(); ++layerIt )
{
QgsRasterLayer *rlayer = qobject_cast<QgsRasterLayer *>( layerIt.value() );
if ( rlayer && rlayer->dataProvider() && rlayer->dataProvider()->name() == QLatin1String( "gdal" ) )
{
//get number of bands
for ( int i = 0; i < rlayer->bandCount(); ++i )
{
QgsRasterCalculatorEntry entry;
entry.raster = rlayer;
entry.bandNumber = i + 1;
if ( ! uniqueRasterBandIdentifier( entry ) )
continue;
availableEntries.push_back( entry );
}
}
}
return availableEntries;
}
QgsLayerRestorer::QgsLayerRestorer( const QList<QgsMapLayer *> &layers )
{
for ( QgsMapLayer *layer : layers )
{
QgsLayerSettings settings;
settings.name = layer->name();
QString style = layer->styleManager()->currentStyle();
settings.mNamedStyle = layer->styleManager()->currentStyle();
// set a custom property allowing to keep in memory if a SLD file has
// been loaded for rendering
layer->setCustomProperty( "readSLD", false );
QString errMsg;
QDomDocument sldDoc;
layer->exportSldStyle( sldDoc, errMsg );
( void )settings.mSldStyle.setContent( sldDoc.toString(), true ); // for namespace processing
switch ( layer->type() )
{
case QgsMapLayer::VectorLayer:
{
QgsVectorLayer *vLayer = qobject_cast<QgsVectorLayer *>( layer );
if ( vLayer )
{
settings.mOpacity = vLayer->opacity();
settings.mSelectedFeatureIds = vLayer->selectedFeatureIds();
settings.mFilter = vLayer->subsetString();
}
break;
}
case QgsMapLayer::LayerType::RasterLayer:
{
QgsRasterLayer *rLayer = qobject_cast<QgsRasterLayer *>( layer );
if ( rLayer )
{
settings.mOpacity = rLayer->renderer()->opacity();
}
break;
}
case QgsMapLayer::MeshLayer:
case QgsMapLayer::PluginLayer:
break;
}
mLayerSettings[layer] = settings;
}
}
void QgsRasterCalcDialog::insertAvailableRasterBands()
{
const QMap<QString, QgsMapLayer*>& layers = QgsMapLayerRegistry::instance()->mapLayers();
QMap<QString, QgsMapLayer*>::const_iterator layerIt = layers.constBegin();
bool firstLayer = true;
for ( ; layerIt != layers.constEnd(); ++layerIt )
{
QgsRasterLayer* rlayer = dynamic_cast<QgsRasterLayer*>( layerIt.value() );
if ( rlayer && rlayer->dataProvider() && rlayer->dataProvider()->name() == "gdal" )
{
if ( firstLayer ) //set bounding box / resolution of output to the values of the first possible input layer
{
mNColumnsSpinBox->setValue( rlayer->width() );
mNRowsSpinBox->setValue( rlayer->height() );
QgsRectangle bbox = rlayer->extent();
mXMinSpinBox->setValue( bbox.xMinimum() );
mXMaxSpinBox->setValue( bbox.xMaximum() );
mYMinSpinBox->setValue( bbox.yMinimum() );
mYMaxSpinBox->setValue( bbox.yMaximum() );
firstLayer = false;
}
//get number of bands
for ( int i = 0; i < rlayer->bandCount(); ++i )
{
QgsRasterCalculatorEntry entry;
entry.raster = rlayer;
entry.bandNumber = i + 1;
entry.ref = rlayer->name() + '@' + QString::number( i + 1 );
mAvailableRasterBands.push_back( entry );
mRasterBandsListWidget->addItem( entry.ref );
}
}
}
}
QgsLayerRestorer::~QgsLayerRestorer()
{
for ( QgsMapLayer *layer : mLayerSettings.keys() )
{
QgsLayerSettings settings = mLayerSettings[layer];
layer->styleManager()->setCurrentStyle( settings.mNamedStyle );
layer->setName( mLayerSettings[layer].name );
// if a SLD file has been loaded for rendering, we restore the previous one
QString errMsg;
QDomElement root = settings.mSldStyle.firstChildElement( "StyledLayerDescriptor" );
QDomElement el = root.firstChildElement( "NamedLayer" );
if ( layer->customProperty( "readSLD", false ).toBool() )
{
layer->readSld( el, errMsg );
}
layer->removeCustomProperty( "readSLD" );
switch ( layer->type() )
{
case QgsMapLayer::LayerType::VectorLayer:
{
QgsVectorLayer *vLayer = qobject_cast<QgsVectorLayer *>( layer );
if ( vLayer )
{
vLayer->setOpacity( settings.mOpacity );
vLayer->selectByIds( settings.mSelectedFeatureIds );
vLayer->setSubsetString( settings.mFilter );
}
break;
}
case QgsMapLayer::LayerType::RasterLayer:
{
QgsRasterLayer *rLayer = qobject_cast<QgsRasterLayer *>( layer );
if ( rLayer )
{
rLayer->renderer()->setOpacity( settings.mOpacity );
}
break;
}
case QgsMapLayer::MeshLayer:
case QgsMapLayer::PluginLayer:
break;
}
}
}
void QgsComposerRasterSymbolItem::readXML( const QDomElement& itemElem )
{
if ( itemElem.isNull() )
{
return;
}
setText( itemElem.attribute( "text", "" ) );
setLayerID( itemElem.attribute( "layerId", "" ) );
QgsRasterLayer* rLayer = qobject_cast<QgsRasterLayer*>( QgsMapLayerRegistry::instance()->mapLayer( mLayerID ) );
if ( rLayer )
{
setIcon( QIcon( rLayer->legendAsPixmap( true ) ) );
}
}
void QgsTileScaleWidget::layerChanged( QgsMapLayer *layer )
{
QgsRasterLayer *rl = qobject_cast<QgsRasterLayer *>( layer );
mResolutions.clear();
mSlider->setDisabled( true );
if ( !rl || rl->providerType() != "wms" )
return;
QString uri = rl->source();
int tiledpos = uri.indexOf( "tiled=" );
int urlpos = uri.indexOf( "url=" );
if ( tiledpos >= 0 && urlpos >= 0 && urlpos > tiledpos )
{
uri = uri.mid( tiledpos + 6 );
int pos = uri.indexOf( "," );
if ( pos >= 0 )
uri = uri.left( pos );
QStringList params = uri.split( ";" );
if ( params.size() < 3 )
return;
params.takeFirst();
params.takeFirst();
mResolutions.clear();
foreach( QString r, params )
{
mResolutions << r.toDouble();
}
qSort( mResolutions );
for ( int i = 0; i < mResolutions.size(); i++ )
QgsDebugMsg( QString( "found resolution %1: %2" ).arg( i ).arg( mResolutions[i] ) );
mSlider->setRange( 0, mResolutions.size() - 1 );
mSlider->setTickInterval( 1 );
mSlider->setInvertedAppearance( true );
mSlider->setPageStep( 1 );
mSlider->setTracking( false );
scaleChanged( mMapCanvas->scale() );
mSlider->setEnabled( true );
show();
}
int QgsLegendModel::addRasterLayerItems( QStandardItem* layerItem, QgsMapLayer* rlayer )
{
if ( !layerItem || !rlayer )
{
return 1;
}
QgsRasterLayer* rasterLayer = qobject_cast<QgsRasterLayer *>( rlayer );
if ( !rasterLayer )
{
return 2;
}
QList< QPair< QString, QColor > > rasterItemList = rasterLayer->legendSymbologyItems();
QList< QPair< QString, QColor > >::const_iterator itemIt = rasterItemList.constBegin();
int row = 0;
for ( ; itemIt != rasterItemList.constEnd(); ++itemIt )
{
QgsComposerRasterSymbolItem* currentSymbolItem = new QgsComposerRasterSymbolItem( itemIt->first );
QgsComposerRasterSymbolItem* oldSymbolItem = dynamic_cast<QgsComposerRasterSymbolItem*>( layerItem->child( row, 0 ) );
if ( oldSymbolItem )
{
currentSymbolItem->setUserText( oldSymbolItem->userText() );
currentSymbolItem->setText( currentSymbolItem->userText() );
}
if ( mHasTopLevelWindow )
{
QPixmap itemPixmap( 20, 20 );
itemPixmap.fill( itemIt->second );
currentSymbolItem->setIcon( QIcon( itemPixmap ) );
}
currentSymbolItem->setLayerID( rasterLayer->id() );
currentSymbolItem->setColor( itemIt->second );
int currentRowCount = layerItem->rowCount();
layerItem->setChild( currentRowCount, 0, currentSymbolItem );
row++;
}
// Delete following old items (if current number of items decreased)
for ( int i = layerItem->rowCount() - 1; i >= row; --i )
{
layerItem->removeRow( i );
}
return 0;
}
QPixmap QgsLegendLayer::getOriginalPixmap()
{
QgsMapLayer* theLayer = layer();
if ( theLayer )
{
if ( theLayer->type() == QgsMapLayer::VectorLayer )
{
QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer *>( theLayer );
switch ( vlayer->geometryType() )
{
case QGis::Point:
return QgisApp::getThemePixmap( "/mIconPointLayer.png" );
break;
case QGis::Line:
return QgisApp::getThemePixmap( "/mIconLineLayer.png" );
break;
case QGis::Polygon:
return QgisApp::getThemePixmap( "/mIconPolygonLayer.png" );
break;
case QGis::NoGeometry:
return QgisApp::getThemePixmap( "/mIconTableLayer.png" );
default:
return QgisApp::getThemePixmap( "/mIconLayer.png" );
}
}
else if ( theLayer->type() == QgsMapLayer::RasterLayer )
{
QSettings s;
if ( s.value( "/qgis/createRasterLegendIcons", true ).toBool() )
{
QgsRasterLayer* rlayer = qobject_cast<QgsRasterLayer *>( theLayer );
QPixmap myPixmap( 32, 32 );
rlayer->thumbnailAsPixmap( &myPixmap );
return myPixmap;
}
else
{
return QPixmap();
}
}
}
// undefined - should never reach this
return QgisApp::getThemePixmap( "/mIconLayer.png" );
}
bool QgsDecorationGrid::getIntervalFromCurrentLayer( double* values )
{
// get current layer and make sure it is a raster layer and CRSs match
QgsMapLayer* layer = QgisApp::instance()->mapCanvas()->currentLayer();
if ( ! layer )
{
QMessageBox::warning( nullptr, tr( "Error" ), tr( "No active layer" ) );
return false;
}
if ( layer->type() != QgsMapLayer::RasterLayer )
{
QMessageBox::warning( nullptr, tr( "Error" ), tr( "Please select a raster layer" ) );
return false;
}
QgsRasterLayer* rlayer = dynamic_cast<QgsRasterLayer*>( layer );
if ( !rlayer || rlayer->width() == 0 || rlayer->height() == 0 )
{
QMessageBox::warning( nullptr, tr( "Error" ), tr( "Invalid raster layer" ) );
return false;
}
QgsCoordinateReferenceSystem layerCRS = layer->crs();
const QgsCoordinateReferenceSystem& mapCRS =
QgisApp::instance()->mapCanvas()->mapSettings().destinationCrs();
// is this the best way to compare CRS? should we also make sure map has OTF enabled?
// TODO calculate transformed values if necessary
if ( layerCRS != mapCRS )
{
QMessageBox::warning( nullptr, tr( "Error" ), tr( "Layer CRS must be equal to project CRS" ) );
return false;
}
// calculate interval
// TODO add a function in QgsRasterLayer to get x/y resolution from provider,
// because this might not be 100% accurate
QgsRectangle extent = rlayer->extent();
values[0] = fabs( extent.xMaximum() - extent.xMinimum() ) / rlayer->width();
values[1] = fabs( extent.yMaximum() - extent.yMinimum() ) / rlayer->height();
// calculate offset - when using very high resolution rasters in geographic CRS
// there seems to be a small shift, but this may be due to rendering issues and depends on zoom
double ratio = extent.xMinimum() / values[0];
values[2] = ( ratio - floor( ratio ) ) * values[0];
ratio = extent.yMinimum() / values[1];
values[3] = ( ratio - floor( ratio ) ) * values[1];
QgsDebugMsg( QString( "xmax: %1 xmin: %2 width: %3 xInterval: %4 xOffset: %5" ).arg(
extent.xMaximum() ).arg( extent.xMinimum() ).arg( rlayer->width() ).arg( values[0] ).arg( values[2] ) );
QgsDebugMsg( QString( "ymax: %1 ymin: %2 height: %3 yInterval: %4 yOffset: %5" ).arg(
extent.yMaximum() ).arg( extent.yMinimum() ).arg( rlayer->height() ).arg( values[1] ).arg( values[3] ) );
return true;
}
void QgsZonalStatisticsDialog::on_mRasterLayerComboBox_currentIndexChanged( int index )
{
Q_UNUSED( index );
QgsRasterLayer* layer = rasterLayer();
if ( !layer )
{
mBandComboBox->setEnabled( false );
return;
}
mBandComboBox->setEnabled( true );
mBandComboBox->clear();
int bandCountInt = layer->bandCount();
for ( int i = 1; i <= bandCountInt; ++i )
{
mBandComboBox->addItem( layer->bandName( i ) );
}
}
void QgsLegendModel::updateRasterSymbolItemText( QStandardItem* symbolItem )
{
QgsComposerRasterSymbolItem* rItem = dynamic_cast<QgsComposerRasterSymbolItem*>( symbolItem );
if ( !rItem ) return;
QgsComposerLayerItem* lItem = dynamic_cast<QgsComposerLayerItem*>( rItem->parent() );
if ( !lItem ) return;
QgsMapLayer* mapLayer = QgsMapLayerRegistry::instance()->mapLayer( lItem->layerID() );
if ( !mapLayer ) return;
QgsRasterLayer* rLayer = qobject_cast<QgsRasterLayer*>( mapLayer );
if ( !rLayer ) return;
QPair< QString, QColor> symbol = rLayer->legendSymbologyItems().value( symbolItem->row() );
QString label = rItem->userText().isEmpty() ? symbol.first : rItem->userText();
symbolItem->setText( label );
}
QPixmap QgsLegendLayer::getOriginalPixmap()
{
QgsMapLayer* theLayer = layer();
if ( theLayer )
{
if ( theLayer->type() == QgsMapLayer::VectorLayer )
{
QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer *>( theLayer );
switch ( vlayer->geometryType() )
{
case QGis::Point:
return QgsApplication::getThemePixmap( "/mIconPointLayer.svg" );
case QGis::Line:
return QgsApplication::getThemePixmap( "/mIconLineLayer.svg" );
case QGis::Polygon:
return QgsApplication::getThemePixmap( "/mIconPolygonLayer.svg" );
case QGis::NoGeometry:
return QgsApplication::getThemePixmap( "/mIconTableLayer.png" );
default:
return QgsApplication::getThemePixmap( "/mIconLayer.png" );
}
}
else if ( theLayer->type() == QgsMapLayer::RasterLayer )
{
QSettings s;
if ( s.value( "/qgis/createRasterLegendIcons", false ).toBool() )
{
QgsRasterLayer* rlayer = qobject_cast<QgsRasterLayer *>( theLayer );
return rlayer->previewAsPixmap( QSize( 32, 32 ) );
}
else
{
return QgsApplication::getThemePixmap( "/mIconRasterLayer.svg" );
}
}
}
// undefined - should never reach this
return QgsApplication::getThemePixmap( "/mIconLayer.png" );
}
bool QgsReclassifyAlgorithmBase::prepareAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
mDataType = QgsRasterAnalysisUtils::rasterTypeChoiceToDataType( parameterAsEnum( parameters, QStringLiteral( "DATA_TYPE" ), context ) );
QgsRasterLayer *layer = parameterAsRasterLayer( parameters, QStringLiteral( "INPUT_RASTER" ), context );
if ( !layer )
throw QgsProcessingException( invalidRasterError( parameters, QStringLiteral( "INPUT_RASTER" ) ) );
mBand = parameterAsInt( parameters, QStringLiteral( "RASTER_BAND" ), context );
if ( mBand < 1 || mBand > layer->bandCount() )
throw QgsProcessingException( QObject::tr( "Invalid band number for RASTER_BAND (%1): Valid values for input raster are 1 to %2" ).arg( mBand )
.arg( layer->bandCount() ) );
mInterface.reset( layer->dataProvider()->clone() );
mExtent = layer->extent();
mCrs = layer->crs();
mRasterUnitsPerPixelX = std::abs( layer->rasterUnitsPerPixelX() );
mRasterUnitsPerPixelY = std::abs( layer->rasterUnitsPerPixelY() );
mNbCellsXProvider = mInterface->xSize();
mNbCellsYProvider = mInterface->ySize();
mNoDataValue = parameterAsDouble( parameters, QStringLiteral( "NO_DATA" ), context );
mUseNoDataForMissingValues = parameterAsBool( parameters, QStringLiteral( "NODATA_FOR_MISSING" ), context );
int boundsType = parameterAsEnum( parameters, QStringLiteral( "RANGE_BOUNDARIES" ), context );
switch ( boundsType )
{
case 0:
mBoundsType = QgsReclassifyUtils::RasterClass::IncludeMax;
break;
case 1:
mBoundsType = QgsReclassifyUtils::RasterClass::IncludeMin;
break;
case 2:
mBoundsType = QgsReclassifyUtils::RasterClass::IncludeMinAndMax;
break;
case 3:
mBoundsType = QgsReclassifyUtils::RasterClass::Exclusive;
break;
}
return _prepareAlgorithm( parameters, context, feedback );
}
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 QgsRasterCalcDialog::insertAvailableRasterBands()
{
mAvailableRasterBands = QgsRasterCalculatorEntry::rasterEntries().toList();
mRasterBandsListWidget->clear();
for ( const auto &entry : qgis::as_const( mAvailableRasterBands ) )
{
QgsRasterLayer *rlayer = entry.raster;
if ( rlayer && rlayer->dataProvider() && rlayer->dataProvider()->name() == QLatin1String( "gdal" ) )
{
if ( !mExtentSizeSet ) //set bounding box / resolution of output to the values of the first possible input layer
{
setExtentSize( rlayer->width(), rlayer->height(), rlayer->extent() );
mCrsSelector->setCrs( rlayer->crs() );
}
QListWidgetItem *item = new QListWidgetItem( entry.ref, mRasterBandsListWidget );
item->setData( Qt::ToolTipRole, rlayer->publicSource() );
mRasterBandsListWidget->addItem( item );
}
}
}
bool QgsZonalHistogramAlgorithm::prepareAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback * )
{
QgsRasterLayer *layer = parameterAsRasterLayer( parameters, QStringLiteral( "INPUT_RASTER" ), context );
if ( !layer )
throw QgsProcessingException( invalidRasterError( parameters, QStringLiteral( "INPUT_RASTER" ) ) );
mRasterBand = parameterAsInt( parameters, QStringLiteral( "RASTER_BAND" ), context );
mHasNoDataValue = layer->dataProvider()->sourceHasNoDataValue( mRasterBand );
mNodataValue = layer->dataProvider()->sourceNoDataValue( mRasterBand );
mRasterInterface.reset( layer->dataProvider()->clone() );
mRasterExtent = layer->extent();
mCrs = layer->crs();
mCellSizeX = std::abs( layer->rasterUnitsPerPixelX() );
mCellSizeY = std::abs( layer->rasterUnitsPerPixelX() );
mNbCellsXProvider = mRasterInterface->xSize();
mNbCellsYProvider = mRasterInterface->ySize();
return true;
}
void QgsLegendLayer::addToPopupMenu( QMenu& theMenu )
{
QgsMapLayer *lyr = layer();
QAction *toggleEditingAction = QgisApp::instance()->actionToggleEditing();
QAction *saveLayerEditsAction = QgisApp::instance()->actionSaveActiveLayerEdits();
QAction *allEditsAction = QgisApp::instance()->actionAllEdits();
// zoom to layer extent
theMenu.addAction( QgsApplication::getThemeIcon( "/mActionZoomToLayer.svg" ),
tr( "&Zoom to Layer Extent" ), legend(), SLOT( legendLayerZoom() ) );
if ( lyr->type() == QgsMapLayer::RasterLayer )
{
theMenu.addAction( tr( "&Zoom to Best Scale (100%)" ), legend(), SLOT( legendLayerZoomNative() ) );
QgsRasterLayer *rasterLayer = qobject_cast<QgsRasterLayer *>( lyr );
if ( rasterLayer && rasterLayer->rasterType() != QgsRasterLayer::Palette )
{
theMenu.addAction( tr( "&Stretch Using Current Extent" ), legend(), SLOT( legendLayerStretchUsingCurrentExtent() ) );
}
}
// show in overview
QAction* showInOverviewAction = theMenu.addAction( tr( "&Show in Overview" ), this, SLOT( showInOverview() ) );
showInOverviewAction->setCheckable( true );
showInOverviewAction->blockSignals( true );
showInOverviewAction->setChecked( mLyr.isInOverview() );
showInOverviewAction->blockSignals( false );
// remove from canvas
theMenu.addAction( QgsApplication::getThemeIcon( "/mActionRemoveLayer.svg" ), tr( "&Remove" ), QgisApp::instance(), SLOT( removeLayer() ) );
// duplicate layer
QAction* duplicateLayersAction = theMenu.addAction( QgsApplication::getThemeIcon( "/mActionDuplicateLayer.svg" ), tr( "&Duplicate" ), QgisApp::instance(), SLOT( duplicateLayers() ) );
// set layer crs
theMenu.addAction( QgsApplication::getThemeIcon( "/mActionSetCRS.png" ), tr( "&Set Layer CRS" ), QgisApp::instance(), SLOT( setLayerCRS() ) );
// assign layer crs to project
theMenu.addAction( QgsApplication::getThemeIcon( "/mActionSetProjectCRS.png" ), tr( "Set &Project CRS from Layer" ), QgisApp::instance(), SLOT( setProjectCRSFromLayer() ) );
theMenu.addSeparator();
if ( lyr->type() == QgsMapLayer::VectorLayer )
{
QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer *>( lyr );
// attribute table
theMenu.addAction( QgsApplication::getThemeIcon( "/mActionOpenTable.png" ), tr( "&Open Attribute Table" ),
QgisApp::instance(), SLOT( attributeTable() ) );
// allow editing
int cap = vlayer->dataProvider()->capabilities();
if ( cap & QgsVectorDataProvider::EditingCapabilities )
{
if ( toggleEditingAction )
{
theMenu.addAction( toggleEditingAction );
toggleEditingAction->setChecked( vlayer->isEditable() );
}
if ( saveLayerEditsAction && vlayer->isModified() )
{
theMenu.addAction( saveLayerEditsAction );
}
}
if ( allEditsAction->isEnabled() )
{
theMenu.addAction( allEditsAction );
}
// disable duplication of memory layers
if ( vlayer->storageType() == "Memory storage" && legend()->selectedLayers().count() == 1 )
{
duplicateLayersAction->setEnabled( false );
}
// save as vector file
theMenu.addAction( tr( "Save As..." ), QgisApp::instance(), SLOT( saveAsFile() ) );
// save selection as vector file
QAction* saveSelectionAsAction = theMenu.addAction( tr( "Save Selection As..." ), QgisApp::instance(), SLOT( saveSelectionAsVectorFile() ) );
if ( vlayer->selectedFeatureCount() == 0 )
{
saveSelectionAsAction->setEnabled( false );
}
if ( !vlayer->isEditable() && vlayer->dataProvider()->supportsSubsetString() && vlayer->vectorJoins().isEmpty() )
theMenu.addAction( tr( "&Filter..." ), QgisApp::instance(), SLOT( layerSubsetString() ) );
//show number of features in legend if requested
QAction* showNFeaturesAction = new QAction( tr( "Show Feature Count" ), &theMenu );
showNFeaturesAction->setCheckable( true );
showNFeaturesAction->setChecked( mShowFeatureCount );
QObject::connect( showNFeaturesAction, SIGNAL( toggled( bool ) ), this, SLOT( setShowFeatureCount( bool ) ) );
theMenu.addAction( showNFeaturesAction );
theMenu.addSeparator();
}
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();
}
}
