Outdated version of the documentation. Find the latest one here.

Utilizando o Mapa da Tela

O Widget tela Mapa é provavelmente o widget mais importante dentro de QGIS porque mostra o mapa composto de camadas de mapas sobrepostos e permite a interação com o mapa e camadas. A tela mostra sempre uma parte do mapa definido pela extensão tela atual. A interação é feita através do uso de ferramentas de mapa existem ferramentas para panorâmica, zoom, identificando camadas, de medida, de edição de vetores e outros. Semelhante a outros programas gráficos, há sempre uma ferramenta ativa e que o usuário pode alternar entre as ferramentas disponíveis.

Mapa na tela é implementado como: class: class QgsMapCanvas no módulo: mod:` qgis.gui`. A implementação é baseada no framework Qt Gráficos View. Este quadro geralmente fornece uma superfície e uma vista onde os itens gráficos personalizados são colocados e usuário pode interagir com eles. Vamos supor que você está bastante familiarizado com Qt para entender os conceitos de cena, vista e itens gráficos. Se não, por favor, certifique-se de ler a visão geral do quadro.

Sempre que o mapa foi muito deslocado, zoom in / out (ou alguma outra ação dispara uma atualização), o mapa é processado novamente dentro da extensão atual. As camadas são prestados a uma imagem (usando: class: classe QgsMapRenderer) e essa imagem é exibida na tela. O item gráfico (em termos de gráficos vista framework Qt) responsável por mostrar o mapa é: class: classe QgsMapCanvasMap. Esta classe também controla a atualização do mapa renderizado. Além disso este item, que atua como um fundo, pode haver mais itens ** mapa de itens na tela**. Mapa típica itens na tela são elásticos (usados para medir, edição vetor etc.) ou marcadores de vértice. Os itens de lona são normalmente utilizados para dar algum feedback visual para ferramentas de mapa, por exemplo, ao criar um novo polígono, a ferramenta de mapa cria um item de canvas elástico que mostra a forma atual do polígono. Todos os itens de mapa de lona são subclasses de: class: QgsMapCanvasItem que acrescenta mais algumas funcionalidades para os` objetos básicos QGraphicsItem`.

Para resumir, a arquitetura do mapa na tela são constituídas por três conceitos:

  • tela do mapa — para visualização do mapa

  • itens na tela do mapa — itens adicionais que podem ser exibidos na tela do mapa

  • ferramentas do mapa — para a interagir com o mapa na tela

Incorporar o Mapa da Tela

Mapa natela é um widget, como qualquer outro widget Qt, então usá-lo é tão simples como criar e mostrá-lo

canvas = QgsMapCanvas()
canvas.show()

Isso produz uma janela independente com o mapa de lona. Ela também pode ser incorporado em um widget ou janela existente. Ao usar .ui arquivos e Qt Designer, coloque um `` QWidget`` no formulário e promovê-lo a uma nova classe: definir `` QgsMapCanvas`` como nome da classe e definir `` qgis.gui`` como arquivo de cabeçalho. O utilitário `` pyuic4`` vai cuidar dele. Esta é uma maneira muito conveniente de incorporar a tela. A outra possibilidade é escrever manualmente o código para construir do mapa na tela e outros widgets (como filhos de uma janela principal ou diálogo) e criar um layout.

Por padrão, o mapa na tela tem fundo preto e não usa anti-aliasing. Para definir o fundo branco e permitir anti-aliasing para renderização suave

canvas.setCanvasColor(Qt.white)
canvas.enableAntiAliasing(True)

(Caso você esteja se perguntando, `` Qt`` vem de `` módulo PyQt4.QtCore`` e `` Qt.white`` é um dos pré-definido `` QColor`` instâncias.)

Agora é hora de adicionar algumas camadas do mapa. Vamos abrir primeiro uma camada e adicioná-lo ao registro camada do mapa. Então, vamos definir a extensão da tela e definir a lista de camadas para tela

layer = QgsVectorLayer(path, name, provider)
if not layer.isValid():
  raise IOError, "Failed to open the layer"

# add layer to the registry
QgsMapLayerRegistry.instance().addMapLayer(layer)

# set extent to the extent of our layer
canvas.setExtent(layer.extent())

# set the map canvas layer set
canvas.setLayerSet([QgsMapCanvasLayer(layer)])

Depois de executar esses comandos, a tela deve mostrar a camada que você carregou.

Usando Ferramentas de Mapas na Tela

O exemplo a seguir constrói uma janela que contém um mapa de tela e ferramentas básicas de mapa para mapa panorâmico e zoom. Ações são criadas para a ativação de cada ferramenta: panorâmica é feito com: class: QgsMapToolPan, zoom in / out com um par de instâncias: class:` QgsMapToolZoom`. As ações são definidas como verificável e posteriormente atribuído às ferramentas para permitir o tratamento automático de do estado das ações verificado / não verificado - quando uma ferramenta de mapa é ativado, a sua ação está marcado como selecionado e a acção da ferramenta mapa anterior é desmarcada. As ferramentas de mapa são ativadas usando o metodo: func: setMapTool.

from qgis.gui import *
from PyQt4.QtGui import QAction, QMainWindow
from PyQt4.QtCore import SIGNAL, Qt, QString

class MyWnd(QMainWindow):
  def __init__(self, layer):
    QMainWindow.__init__(self)

    self.canvas = QgsMapCanvas()
    self.canvas.setCanvasColor(Qt.white)

    self.canvas.setExtent(layer.extent())
    self.canvas.setLayerSet([QgsMapCanvasLayer(layer)])

    self.setCentralWidget(self.canvas)

    actionZoomIn = QAction(QString("Zoom in"), self)
    actionZoomOut = QAction(QString("Zoom out"), self)
    actionPan = QAction(QString("Pan"), self)

    actionZoomIn.setCheckable(True)
    actionZoomOut.setCheckable(True)
    actionPan.setCheckable(True)

    self.connect(actionZoomIn, SIGNAL("triggered()"), self.zoomIn)
    self.connect(actionZoomOut, SIGNAL("triggered()"), self.zoomOut)
    self.connect(actionPan, SIGNAL("triggered()"), self.pan)

    self.toolbar = self.addToolBar("Canvas actions")
    self.toolbar.addAction(actionZoomIn)
    self.toolbar.addAction(actionZoomOut)
    self.toolbar.addAction(actionPan)

    # create the map tools
    self.toolPan = QgsMapToolPan(self.canvas)
    self.toolPan.setAction(actionPan)
    self.toolZoomIn = QgsMapToolZoom(self.canvas, False) # false = in
    self.toolZoomIn.setAction(actionZoomIn)
    self.toolZoomOut = QgsMapToolZoom(self.canvas, True) # true = out
    self.toolZoomOut.setAction(actionZoomOut)

    self.pan()

  def zoomIn(self):
    self.canvas.setMapTool(self.toolZoomIn)

  def zoomOut(self):
    self.canvas.setMapTool(self.toolZoomOut)

  def pan(self):
    self.canvas.setMapTool(self.toolPan)

Você pode colocar o código acima para um arquivo, por exemplo, : file: mywnd.py e experimentá-lo no console do Python dentro QGIS. Este código irá colocar a camada selecionada atualmente na tela recém-criada

import mywnd
w = mywnd.MyWnd(qgis.utils.iface.activeLayer())
w.show()

Apenas certifique-se de que o arquivo: file: mywnd.py está localizado dentro do caminhoo de busca Python (` sys.path`). Se não for, você pode simplesmente adicioná-lo: sys.path.insert(0, '/my/path') — caso contrário, a declaração de importação irá falhar, não encontrando o módulo.

Bandas raster e fazedor de vértices

Para mostrar alguns dados adicionais na parte superior do mapa na tela, use itens de mapa de tela. É possível criar classes de itens de tela (mostradas abaixo), no entanto, existem duas classes úteis de item de tela para sua conveniência:: class: QgsRubberBand para desenhar multilinhas ou polígonos, e: class:` QgsVertexMarker` para desenhar pontos. Ambos trabalham com as coordenadas do mapa, assim que a forma é movida/escalada automaticamente quando a tela está em panorâmica ou ampliada.

Para mostrar as polilinhas

r = QgsRubberBand(canvas, False)  # False = not a polygon
points = [QgsPoint(-1, -1), QgsPoint(0, 1), QgsPoint(1, -1)]
r.setToGeometry(QgsGeometry.fromPolyline(points), None)

Para mostrar o poligono

r = QgsRubberBand(canvas, True)  # True = a polygon
points = [[QgsPoint(-1, -1), QgsPoint(0, 1), QgsPoint(1, -1)]]
r.setToGeometry(QgsGeometry.fromPolygon(points), None)

Note-se que aponta para polígono não é uma lista simples: na verdade, é uma lista de anéis contendo anéis lineares do polígono: primeiro anel é a borda externa, ainda mais (opcional) anéis correspondem aos buracos no polígono.

As Bandas Raster permitem alguma personalização, ou seja, para mudar sua cor e linha de largura

r.setColor(QColor(0, 0, 255))
r.setWidth(3)

Os itens em tela são obrigados a cena na tela. Para escondê-los temporariamente (e mostrar mais uma vez, use a Combinação: hide() and show() Para remover completamente o item, você tem que removê-lo da cena na tela

canvas.scene().removeItem(r)

(em C ++ é possível simplesmente apagar o item, no entanto, em Python `` del r`` seria apenas suprimir a referência eo objeto continuará a existir, uma vez que é de propriedade da tela)

As bandas Rasters também podem serem usadas para desenhar pontos, no entanto a classe : class: class QgsVertexMarker é mais adequado para isso (QgsRubberBand só desenhar um retângulo ao redor do ponto desejado). Como usar o fazedor de Vértices

m = QgsVertexMarker(canvas)
m.setCenter(QgsPoint(0, 0))

Isso vai chamar a uma cruz vermelha sobre a posição [0,0]. É possível personalizar o tipo de ícone, tamanho, cor e espessura da caneta

m.setColor(QColor(0, 255, 0))
m.setIconSize(5)
m.setIconType(QgsVertexMarker.ICON_BOX) # or ICON_CROSS, ICON_X
m.setPenWidth(3)

Para esconder temporáriamente os marcadores de vértice e removê-los da tela, o mesmo se aplica quanto para as bandas rasters.

Desenhar ferramenta de mapa personalizada

Você pode escrever suas ferramentas personalizadas, para implementar um comportamento personalizado às ações realizadas pelos usuários na tela.

Ferramentas de mapa deve herdar a classe: class: QgsMapTool ou qualquer outra classe derivada, e selecionado como ferramentas ativas na tela usando o método: func:setMapTool como já vimos.

Aqui está um exemplo de uma ferramenta de mapa que permite definir uma medida retangular, clicando e arrastando na tela. Quando o retângulo é definido, ele imprime coordena seu limite no console. Ele utiliza os elementos de banda de borracha descritos antes para mostrar o retângulo selecionado, uma vez que está a ser definida.

class RectangleMapTool(QgsMapToolEmitPoint):
  def __init__(self, canvas):
      self.canvas = canvas
      QgsMapToolEmitPoint.__init__(self, self.canvas)
      self.rubberBand = QgsRubberBand(self.canvas, QGis.Polygon)
      self.rubberBand.setColor(Qt.red)
      self.rubberBand.setWidth(1)
      self.reset()

  def reset(self):
      self.startPoint = self.endPoint = None
      self.isEmittingPoint = False
      self.rubberBand.reset(QGis.Polygon)

  def canvasPressEvent(self, e):
      self.startPoint = self.toMapCoordinates(e.pos())
      self.endPoint = self.startPoint
      self.isEmittingPoint = True
      self.showRect(self.startPoint, self.endPoint)

  def canvasReleaseEvent(self, e):
      self.isEmittingPoint = False
      r = self.rectangle()
      if r is not None:
        print "Rectangle:", r.xMinimum(), r.yMinimum(), r.xMaximum(), r.yMaximum()

  def canvasMoveEvent(self, e):
      if not self.isEmittingPoint:
        return

      self.endPoint = self.toMapCoordinates(e.pos())
      self.showRect(self.startPoint, self.endPoint)

  def showRect(self, startPoint, endPoint):
      self.rubberBand.reset(QGis.Polygon)
      if startPoint.x() == endPoint.x() or startPoint.y() == endPoint.y():
        return

      point1 = QgsPoint(startPoint.x(), startPoint.y())
      point2 = QgsPoint(startPoint.x(), endPoint.y())
      point3 = QgsPoint(endPoint.x(), endPoint.y())
      point4 = QgsPoint(endPoint.x(), startPoint.y())

      self.rubberBand.addPoint(point1, False)
      self.rubberBand.addPoint(point2, False)
      self.rubberBand.addPoint(point3, False)
      self.rubberBand.addPoint(point4, True)    # true to update canvas
      self.rubberBand.show()

  def rectangle(self):
      if self.startPoint is None or self.endPoint is None:
        return None
      elif self.startPoint.x() == self.endPoint.x() or self.startPoint.y() == self.endPoint.y():
        return None

      return QgsRectangle(self.startPoint, self.endPoint)

  def deactivate(self):
      QgsMapTool.deactivate(self)
      self.emit(SIGNAL("deactivated()"))

Desenhar itens da tela do mapa

TODO:

Como criar itens do mapa na tela

import sys
from qgis.core import QgsApplication
from qgis.gui import QgsMapCanvas

def init():
  a = QgsApplication(sys.argv, True)
  QgsApplication.setPrefixPath('/home/martin/qgis/inst', True)
  QgsApplication.initQgis()
  return a

def show_canvas(app):
  canvas = QgsMapCanvas()
  canvas.show()
  app.exec_()
app = init()
show_canvas(app)