10. Visualizzazione e Stampa di una Mappa

Suggerimento

I frammenti di codice in questa pagina hanno bisogno dei seguenti import:

import os

from qgis.core import (
    QgsGeometry,
    QgsMapSettings,
    QgsPrintLayout,
    QgsMapSettings,
    QgsMapRendererParallelJob,
    QgsLayoutItemLabel,
    QgsLayoutItemLegend,
    QgsLayoutItemMap,
    QgsLayoutItemPolygon,
    QgsLayoutItemScaleBar,
    QgsLayoutExporter,
    QgsLayoutItem,
    QgsLayoutPoint,
    QgsLayoutSize,
    QgsUnitTypes,
    QgsProject,
    QgsFillSymbol,
)

from qgis.PyQt.QtGui import (
    QPolygonF,
    QColor,
)

from qgis.PyQt.QtCore import (
    QPointF,
    QRectF,
    QSize,
)

Ci sono generalmente due approcci quando i dati di input devono essere visualizzati come mappe: o farlo in modo rapido usando QgsMapRendererJob o produrre un output più preciso componendo la mappa con la classe QgsLayout.

10.1. Visualizzazione Semplice

La visualizzazione avviene creando un oggetto QgsMapSettings per definire le impostazioni di visualizzazione e costruendo poi un QgsMapRendererJob con tali impostazioni. Quest’ultimo viene poi utilizzato per creare l’immagine risultante.

Ecco un esempio:

image_location = os.path.join(QgsProject.instance().homePath(), "render.png")

vlayer = iface.activeLayer()
settings = QgsMapSettings()
settings.setLayers([vlayer])
settings.setBackgroundColor(QColor(255, 255, 255))
settings.setOutputSize(QSize(800, 600))
settings.setExtent(vlayer.extent())

render = QgsMapRendererParallelJob(settings)

def finished():
    img = render.renderedImage()
    # save the image; e.g. img.save("/Users/myuser/render.png","png")
    img.save(image_location, "png")

render.finished.connect(finished)

# Start the rendering
render.start()

# The following loop is not normally required, we
# are using it here because this is a standalone example.
from qgis.PyQt.QtCore import QEventLoop
loop = QEventLoop()
render.finished.connect(loop.quit)
loop.exec_()

10.2. Visualizzare layer con diversi SR

Se hai più di un layer e questi hanno un SR diverso, il semplice esempio precedente probabilmente non funzionerà: per ottenere i valori giusti dai calcoli di estensione devi impostare esplicitamente il SR di destinazione

layers = [iface.activeLayer()]
settings = QgsMapSettings()
settings.setLayers(layers)
settings.setDestinationCrs(layers[0].crs())

10.3. Risultato con layout di stampa

Il layout di stampa è uno strumento molto utile se vuoi ottenere un risultato più sofisticato della semplice visualizzazione mostrata sopra. Puoi creare layout cartografici complessi composti da viste della mappa, etichette, legende, tabelle e altri elementi solitamente presenti sulle mappe cartacee. I layout possono essere esportati in PDF, immagini raster o stampati direttamente su una stampante.

Il layout è costituito da un gruppo di classi. Tutte appartengono alla libreria principale. L’applicazione QGIS ha una comoda interfaccia grafica per il posizionamento degli elementi, anche se non è disponibile nella libreria GUI. Se non hai familiarità con il framework Qt Graphics View, ti consigliamo di consultare ora la documentazione, perché il layout si basa su di esso.

La classe principale del layout è la classe QgsLayout, che deriva dalla classe Qt QGraphicsScene. Creiamo un’istanza di questa classe:

project = QgsProject.instance()
layout = QgsPrintLayout(project)
layout.initializeDefaults()

Questo metodo inizializza il layout con alcune impostazioni predefinite, in particolare aggiungendo una pagina A4 vuota al layout. Puoi creare layout senza chiamare il metodo initializeDefaults(), ma dovrai occuparti personalmente di aggiungere pagine al layout.

Il codice precedente crea un layout «temporaneo» che non è visibile nella GUI. Può essere utile, ad esempio, per aggiungere rapidamente alcuni elementi ed esportare senza modificare il progetto stesso né esporre le modifiche all’utente. Se vuoi che il layout venga salvato/ripristinato insieme al progetto e sia disponibile nel gestore dei layout, aggiungi:

layout.setName("MyLayout")
project.layoutManager().addLayout(layout)

Ora possiamo aggiungere vari elementi (mappa, etichetta, …) al layout. Tutti questi oggetti sono rappresentati da classi che ereditano dalla classe base QgsLayoutItem.

Ecco una descrizione di alcuni dei principali oggetti di layout che possono essere aggiunti a un layout.

• map — Qui creiamo una mappa di dimensioni personalizzate e visualizziamo l’area mappa della mappa corrente.

  map = QgsLayoutItemMap(layout)
  # Set map item position and size (by default, it is a 0 width/0 height item placed at 0,0)
  map.attemptMove(QgsLayoutPoint(5,5, QgsUnitTypes.LayoutMillimeters))
  map.attemptResize(QgsLayoutSize(200,200, QgsUnitTypes.LayoutMillimeters))
  # Provide an extent to render
  map.zoomToExtent(iface.mapCanvas().extent())
  layout.addLayoutItem(map)
  

• label — permetta la visualizzazione di etichette. É possibile modificarne il carattere, colore, allineamento e margine

  label = QgsLayoutItemLabel(layout)
  label.setText("Hello world")
  label.adjustSizeToText()
  layout.addLayoutItem(label)
  

• legenda

  legend = QgsLayoutItemLegend(layout)
  legend.setLinkedMap(map) # map is an instance of QgsLayoutItemMap
  layout.addLayoutItem(legend)
  

• barra di scala

  item = QgsLayoutItemScaleBar(layout)
  item.setStyle('Numeric') # optionally modify the style
  item.setLinkedMap(map) # map is an instance of QgsLayoutItemMap
  item.applyDefaultSize()
  layout.addLayoutItem(item)
  

• freccia

• immagine

• forma di base

• forma basata su nodi

  polygon = QPolygonF()
  polygon.append(QPointF(0.0, 0.0))
  polygon.append(QPointF(100.0, 0.0))
  polygon.append(QPointF(200.0, 100.0))
  polygon.append(QPointF(100.0, 200.0))
  
  polygonItem = QgsLayoutItemPolygon(polygon, layout)
  layout.addLayoutItem(polygonItem)
  
  props = {}
  props["color"] = "green"
  props["style"] = "solid"
  props["style_border"] = "solid"
  props["color_border"] = "black"
  props["width_border"] = "10.0"
  props["joinstyle"] = "miter"
  
  symbol = QgsFillSymbol.createSimple(props)
  polygonItem.setSymbol(symbol)
  

• tabella

Una volta aggiunto un oggetto al layout, è possibile spostarlo e ridimensionarlo:

item.attemptMove(QgsLayoutPoint(1.4, 1.8, QgsUnitTypes.LayoutCentimeters))
item.attemptResize(QgsLayoutSize(2.8, 2.2, QgsUnitTypes.LayoutCentimeters))

Per impostazione predefinita, attorno a ciascun elemento viene disegnata una cornice. Puoi rimuoverla come segue:

# for a composer label
label.setFrameEnabled(False)

Oltre a creare gli oggetti del layout a mano, QGIS supporta i modelli di layout, che sono essenzialmente composizioni con tutti i loro oggetti salvati in un file .qpt (con sintassi XML).

Una volta che la composizione è pronta (gli oggetti del layout sono stati creati e aggiunti alla composizione), possiamo procedere alla produzione di un output raster e/o vettoriale.

10.3.1. Esporta il layout

Per esportare un layout, è necessario utilizzare la classe QgsLayoutExporter.

base_path = os.path.join(QgsProject.instance().homePath())
pdf_path = os.path.join(base_path, "output.pdf")

exporter = QgsLayoutExporter(layout)
exporter.exportToPdf(pdf_path, QgsLayoutExporter.PdfExportSettings())

Utilizzare la exportToImage() nel caso in cui si voglia esportare in un’immagine invece che in un file PDF.

10.3.2. Esportare un layout atlante

Se vuoi esportare tutte le pagine da un layout che ha l’opzione atlante configurata e abilitata, devi usare il metodo atlas() nell’esportatore (QgsLayoutExporter) con piccole modifiche. Nell’esempio seguente, le pagine sono esportate in immagini PNG:

exporter.exportToImage(layout.atlas(), base_path, 'png', QgsLayoutExporter.ImageExportSettings())

Da notare che gli output saranno salvati nella cartella del percorso di base, utilizzando l’espressione del nome del file di output configurata su atlante.