10. Representación del Mapa e Impresión

Consejo

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

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)

# 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. 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 = QgsMapSettings()
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.instance()
layout = QgsPrintLayout(project)
layout.initializeDefaults()

Esto inicializa el diseño con algunas configuraciones predeterminadas, específicamente agregando una página A4 vacía al diseño. Puede crear diseños sin llamar al método initializeDefaults(), pero deberá encargarse de agregar páginas al diseño usted mismo.

El código anterior crea un diseño «temporal» que no es visible en la GUI. Puede ser útil p.Ej. agregue rápidamente algunos elementos y exporte sin modificar el proyecto en sí ni exponer estos cambios al usuario. Si desea que el diseño se guarde/restaure junto con el proyecto y esté disponible en el administrador de diseño, agregue:

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

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 — Aquí creamos un mapa de un tamaño personalizado y renderizamos el lienzo del mapa actual.

  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)
  

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

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

• leyenda

  legend = QgsLayoutItemLegend(layout)
  legend.setLinkedMap(map) # map is an instance of QgsLayoutItemMap
  layout.addLayoutItem(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.addLayoutItem(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.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)
  

• 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.