Los fragmentos de código en esta página necesitan las siguientes importaciones:

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,
)

10. Representación del Mapa e Impresión

Por lo general, hay dos enfoques cuando los datos de entrada deben representarse como un mapa: hacerlo de manera rápida usando QgsMapRendererJob o producir una salida más ajustada componiendo el mapa con la clase QgsLayout.

10.1. Representación Simple

La renderización se realiza creando un objeto QgsMapSettings para definir la configuración de renderizado, y luego construir una clase QgsMapRendererJob con esos ajustes. Este último se utiliza para crear la imagen resultante.

He aquí un ejemplo:

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)

render.start()

10.2. Representando capas con diferente SRC

Si tiene más de una capa y tienen un SRC diferente, el simple ejemplo anterior probablemente no funcionará: para obtener los valores correctos de los cálculos de extensión, debe establecer explícitamente el SRC de destino

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

10.3. Salida usando diseño de impresión

El diseño de impresión es una herramienta muy útil si desea realizar una salida más sofisticada que la representación simple que se muestra arriba. Es posible crear diseños de mapas complejos que constan de vistas de mapa, etiquetas, leyendas, tablas y otros elementos que suelen estar presentes en los mapas de papel. Los diseños se pueden exportar a PDF, imágenes rasterizadas o imprimir directamente en una impresora.

El diseño consta de varias clases. Todos pertenecen a la biblioteca principal. La aplicación QGIS tiene una GUI conveniente para la ubicación de los elementos, aunque no está disponible en la biblioteca de la GUI. Si no está familiarizado con Qt Graphics View framework, entonces le recomendamos que consulte la documentación ahora, porque el diseño se basa en ella.

La clase central del diseño es la clase QgsLayout, que deriva de la clase de Qt QGraphicsScene . Creemos una instancia de ello:

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

Ahora podemos agregar varios elementos (mapa, etiqueta, …) al diseño. Todos estos objetos están representados por clases que heredan de la clase base QgsLayoutItem.

Aquí hay una descripción de algunos de los elementos de diseño principales que se pueden agregar a un diseño.

• mapa — este elemento dice a las bibliotecas dónde ponen el propio mapa. Aquí creamos un mapa y estiramos sobre el tamaño de papel

  map = QgsLayoutItemMap(layout)
  layout.addItem(map)
  

• etiqueta — permite mostrar etiquetas. Es posible modificar su letra, color, alineación y margen.

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

• leyenda

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

• barra de escala

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

• flecha

• imagen

• forma básica

• forma basada en nodos

  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.addItem(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)
  

• tabla

Una vez que un elemento es añadido a la composiciónm puede ser movida y redimensionadas:

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

Un cuadro es dibujado alrededor de cada elemento por defecto. Puede borrarlo como sigue:

# for a composer label
label.setFrameEnabled(False)

Además de crear los elementos de diseño a mano, QGIS tiene soporte para plantillas de diseño que son esencialmente composiciones con todos sus elementos guardados en un archivo .qpt (con sintaxis XML).

Una vez que la composición está lista (los elementos de diseño se han creado y agregado a la composición), podemos proceder a producir una salida rasterizada y/o vectorial.

10.3.1. Exportando la composición

Para exportar una composición, la clase QgsLayoutExporter debe ser usada.

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())

Use exportToImage() en caso de que desee exportar a una imagen en lugar de un archivo PDF.

10.3.2. Exportar un atlas de diseño

Si desea exportar todas las páginas de un diseño que tiene la opción de atlas configurada y habilitada, debe usar el método atlas() en el exportador (QgsLayoutExporter) con pequeños ajustes. En el siguiente ejemplo, las páginas se exportan a imágenes PNG:

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

Observe que las salidas se guardarán en la carpeta de ruta base, utilizando la expresión de nombre de archivo de salida configurada en atlas.