Utilizando o Mapa da 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 na tela e definir a lista de camadas na 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 o mapa panorâmica e zoom. Ações são criadas para a ativação de cada ferramenta: panning é feito com: class: QgsMapToolPan, zoom in / out com um par de: class:` QgsMapToolZoom` instâncias. As ações são definidas como verificável e posteriormente atribuído às ferramentas para permitir o tratamento automático das verificados / estado desmarcado das ações - quando uma ferramenta de mapa é ativado, a sua ação está marcado como selecionado e a ação da ferramenta mapa anterior é desmarcada. As ferramentas de do mapa são ativados usando o seguinte método: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, `` mywnd.py`` e experimentá-lo no console do Python dentro QGIS. Este código irá colocar a camada selecionada atualmente em lona recém-criado

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

Apenas certifique-se de que o arquivo `` mywnd.py`` está localizado dentro de busca Python caminho (`` sys.path``). Se não for, você pode simplesmente adicioná-lo: `` sys.path.insert (0, ‘/ minha / 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 na tela, use itens de mapa de lona. É possível criar classes de itens na tela personalizados (cobertos abaixo), no entanto, existem duas classes de itens úteis tela para conveniência:: class: QgsRubberBand para polylines desenho ou polígonos, e: class:` QgsVertexMarker` para desenhar pontos. Ambos trabalham com as coordenadas do mapa, assim que a forma é movido / escalados automaticamente quando a tela está sendo muito deslocado 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.xMin(), r.yMin(), r.xMax(), r.yMax()

  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