10. Renderização em impressão de mapas

Dica

Os trechos de código nesta página precisam das seguintes importações:

import os

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

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

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

Geralmente, existem duas abordagens em que os dados de entrada devem ser renderizados como um mapa: seja rápido usando QgsMapRendererJob ou produza uma saída mais ajustada compondo o mapa com a classe QgsLayout.

10.1. Renderização simples

A renderização é feita criando um objeto QgsMapSettings para definir as configurações de renderização e, em seguida, construindo um QgsMapRendererJob com essas configurações. O último é usado para criar a imagem 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. Renderizando camadas com CRS diferente

Se você tiver mais de uma camada e eles tiverem SRC diferente, o exemplo simples acima provavelmente não funcionará: para obter os valores corretos a partir dos cálculos de extensão, você deve definir explicitamente o SRC de destino

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

10.3. Saída usando layout de impressão

Print layout is a very handy tool if you would like to do a more sophisticated output than the simple rendering shown above. It is possible to create complex map layouts consisting of map views, labels, legend, tables and other elements that are usually present on paper maps. The layouts can be then exported to PDF, SVG, raster images or directly printed on a printer.

O layout consiste de várias classes. Todos eles pertencem à biblioteca principal. O aplicativo QGIS possui uma GUI conveniente para a colocação dos elementos, embora não esteja disponível na biblioteca da GUI. Se você não estiver familiarizado com a estrutura Qt Graphics View, recomendamos que verifique a documentação agora, porque o layout é baseado nela .

A classe central do layout é a classe QgsLayout, que é derivada da classe Qt QGraphicsScene. Vamos criar uma instância dele:

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

Isto inicializa o layout com algumas configurações padrão, especificamente adicionando uma página A4 vazia ao layout. Você pode criar layouts sem chamar o método initializeDefaults(), mas você mesmo terá que se encarregar de adicionar páginas ao layout.

The previous code creates a “temporary” layout that is not visible in the GUI. It can be handy to e.g. quickly add some items and export without modifying the project itself nor expose these changes to the user. If you want the layout to be saved/restored along with the project and available in the layout manager, then add:

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

Agora podemos adicionar vários elementos (mapa, rõtulo, …) ao layout. Todos esses objetos são representados por classes que herdam da classe base QgsLayoutItem.

Aqui está uma descrição de alguns dos principais itens de layout que podem ser adicionados a um layout.

• mapa — Aqui nós criamos um mapa de um tamanho personalizado e renderizamos a tela do mapa atual

  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 — permite exibir rótulos. É possível modificar a sua fonte, cor, alinhamento e margem

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

• legend

  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)
  

• forma baseada em nós

  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)
  

Depois que um item é adicionado ao layout, ele pode ser movido e redimensionado:

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

Uma moldura é desenhada ao redor de cada item por padrão. Você pode removê-la da seguinte forma:

# for a composer label
label.setFrameEnabled(False)

Além de criar os itens de layout manualmente, o QGIS oferece suporte a modelos de layout que são essencialmente composições com todos os itens salvos em um arquivo .qpt (com sintaxe XML).

Quando a composição estiver pronta (os itens de layout foram criados e adicionados à composição), podemos continuar produzindo uma saída raster e/ou vetorial.

10.3.1. Checking layout validity

A layout is a made of a set of interconnected items and it can happen that these connections are broken during modifications (a legend connected to a removed map, an image item with missing source file,…) or you may want to apply custom constraints to the layout items. The QgsAbstractValidityCheck helps you achieve this.

A basic check looks like:

@check.register(type=QgsAbstractValidityCheck.TypeLayoutCheck)
def my_layout_check(context, feedback):
  results = ...
  return results

Here’s a check which throws a warning whenever a layout map item is set to the web mercator projection:

@check.register(type=QgsAbstractValidityCheck.TypeLayoutCheck)
def layout_map_crs_choice_check(context, feedback):
  layout = context.layout
  results = []
  for i in layout.items():
    if isinstance(i, QgsLayoutItemMap) and i.crs().authid() == 'EPSG:3857':
      res = QgsValidityCheckResult()
      res.type = QgsValidityCheckResult.Warning
      res.title = 'Map projection is misleading'
      res.detailedDescription = 'The projection for the map item {} is set to <i>Web Mercator (EPSG:3857)</i> which misrepresents areas and shapes. Consider using an appropriate local projection instead.'.format(i.displayName())
      results.append(res)

  return results

And here’s a more complex example, which throws a warning if any layout map items are set to a CRS which is only valid outside of the extent shown in that map item:

@check.register(type=QgsAbstractValidityCheck.TypeLayoutCheck)
def layout_map_crs_area_check(context, feedback):
    layout = context.layout
    results = []
    for i in layout.items():
        if isinstance(i, QgsLayoutItemMap):
            bounds = i.crs().bounds()
            ct = QgsCoordinateTransform(QgsCoordinateReferenceSystem('EPSG:4326'), i.crs(), QgsProject.instance())
            bounds_crs = ct.transformBoundingBox(bounds)

            if not bounds_crs.contains(i.extent()):
                res = QgsValidityCheckResult()
                res.type = QgsValidityCheckResult.Warning
                res.title = 'Map projection is incorrect'
                res.detailedDescription = 'The projection for the map item {} is set to \'{}\', which is not valid for the area displayed within the map.'.format(i.displayName(), i.crs().authid())
                results.append(res)

    return results

10.3.2. Exportando o layout

Para exportar um layout, a classe :class: QgsLayoutExporter <qgis.core.QgsLayoutExporter> deve 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 exportToSvg() or exportToImage() in case you want to export to respectively an SVG or image file instead of a PDF file.

10.3.3. Exportando um atlas como layout

Se você deseja exportar todas as páginas de um layout que tenha a opção atlas configurada e ativada, use o método atlas () no exportador (:class:` QgsLayoutExporter <qgis.core.QgsLayoutExporter>`) com pequenos ajustes. No exemplo a seguir, as páginas são exportadas para imagens PNG:

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

Observe que as saídas serão salvas na pasta do caminho base, usando a expressão do nome do arquivo de saída configurada no atlas.