Les extraits de code sur cette page nécessitent les importations suivantes si vous êtes en dehors de la console pyqgis :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
from qgis.PyQt.QtGui import (
    QColor,
)

from qgis.PyQt.QtCore import Qt, QRectF

from qgis.core import (
    QgsVectorLayer,
    QgsPoint,
    QgsPointXY,
    QgsProject,
    QgsGeometry,
    QgsMapRendererJob,
)

from qgis.gui import (
    QgsMapCanvas,
    QgsVertexMarker,
    QgsMapCanvasItem,
    QgsRubberBand,
)

9. Utilisation du canevas de carte

Le widget de canevas de carte est probablement le widget le plus important dans QGIS car il affiche la carte composée de couches superposées et permet l’interaction avec la carte et les couches. Le canevas montre toujours une partie de la carte définie par l’étendue courante de la carte. L’interaction est réalisée grâce aux outils cartographiques : il existe des outils pour se déplacer, zoomer, identifier les couches, mesurer, éditer des vecteurs… Comme pour les autres programmes graphiques, il y a toujours un outil actif et l’utilisateur peut passer d’un outil disponible à l’autre.

Le canevas de carte est implémenté avec la classe QgsMapCanvas dans le module qgis.gui. L’implémentation est basée sur le framework Qt Graphics View. Ce cadre fournit généralement une surface et une vue où les éléments graphiques personnalisés sont placés et où l’utilisateur peut interagir avec eux. Nous supposerons que vous êtes suffisamment familier avec Qt pour comprendre les concepts de la scène graphique, de la vue et des éléments. Si ce n’est pas le cas, veuillez lire la aperçu du cadre.

A chaque fois que la carte a été déplacée, zoomée (ou toute autre action déclenchant un rafraîchissement), la carte est rendue de nouveau dans l’étendue courante. Les couches sont rendues sous forme d’image (en utilisant la classe QgsMapRendererJob) et cette image est affichée sur la canevas. La classe QgsMapCanvas contrôle aussi le rafraîchissement de la carte rendue. En plus de cet item qui joue le rôle d’arrière-plan, il peut y avoir d’autres items de canevas de carte.

Les éléments typiques d’un canevas de carte sont les élastiques (utilisés pour la mesure, l’édition vecteur, etc.) ou les marqueurs de sommet. Les éléments de canevas sont généralement utilisés pour donner un retour visuel aux outils cartographiques. Par exemple, lors de la création d’un nouveau polygone, l’outil cartographique crée un élément de canevas élastique qui montre la forme actuelle du polygone. Tous les éléments du canevas de carte sont des sous-classes de QgsMapCanvasItem qui ajoute quelques fonctionnalités supplémentaires aux objets de base de QGraphicsItem.

Pour résumer, l’architecture du canevas de carte repose sur trois concepts:

  • le canevas de carte — pour visualiser la carte

  • éléments du canevas de la carte — éléments supplémentaires pouvant être affichés sur le canevas de la carte

  • outils cartographiques — pour l’interaction avec le canevas de la carte

9.1. Intégrer un canevas de carte

Map canvas est un widget comme tous les autres widgets Qt, donc l’utiliser est aussi simple que de le créer et de le montrer.

canvas = QgsMapCanvas()
canvas.show()

On obtient ainsi une fenêtre autonome avec un canevas de carte. Elle peut également être intégrée dans un widget ou une fenêtre existante. Lorsque vous utilisez les fichiers .ui et Qt Designer, placez un QWidget sur le formulaire et promouvez-le dans une nouvelle classe : définissez QgsMapCanvas comme nom de classe et définissez qgis.gui comme fichier d’en-tête. L’utilitaire « pyuic5 » s’occupera de tout cela. C’est une façon très pratique d’intégrer le canevas. L’autre possibilité est d’écrire manuellement le code pour construire le canevas de la carte et d’autres widgets (comme les enfants d’une fenêtre principale ou d’un dialogue) et créer une mise en page.

Par défaut, le canevas de carte a un arrière-plan noir et n’utilise pas l’anticrénelage. Pour afficher un arrière-plan blanc et activer l’anticrénelage pour un rendu plus lisse:

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

(Au cas où vous vous poseriez la question, « Qt » vient du module « PyQt.QtCore » et « Qt.white » est l’une des instances prédéfinies de « QColor »).

Il est maintenant temps d’ajouter quelques couches cartographiques. Nous allons d’abord ouvrir une couche et l’ajouter au projet en cours. Ensuite, nous définirons l’étendue du canevas et la liste des couches pour le canevas.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
vlayer = QgsVectorLayer('testdata/airports.shp', "Airports layer", "ogr")
if not vlayer.isValid():
    print("Layer failed to load!")

# add layer to the registry
QgsProject.instance().addMapLayer(vlayer)

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

# set the map canvas layer set
canvas.setLayers([vlayer])

Après exécution de ces commandes, le canevas de carte devrait afficher la couche chargée.

9.2. Contour d’édition et symboles de sommets

Pour afficher des données supplémentaires en haut de la carte dans le canevas, utilisez les éléments du canevas de la carte. Il est possible de créer des classes d’éléments de canevas personnalisés (voir ci-dessous), mais il existe deux classes d’éléments de canevas utiles pour des raisons de commodité : QgsRubberBand pour dessiner des polylignes ou des polygones, et QgsVertexMarker pour dessiner des points. Ils fonctionnent tous les deux avec des coordonnées cartographiques, de sorte que la forme est déplacée ou mise à l’échelle automatiquement lorsque le canevas fait l’objet d’un panoramique ou d’un zoom.

Pour montrer une polyligne :

r = QgsRubberBand(canvas, False)  # False = not a polygon
points = [QgsPoint(-100, 45), QgsPoint(10, 60), QgsPoint(120, 45)]
r.setToGeometry(QgsGeometry.fromPolyline(points), None)

Pour afficher un polygone:

r = QgsRubberBand(canvas, True)  # True = a polygon
points = [[QgsPointXY(-100, 35), QgsPointXY(10, 50), QgsPointXY(120, 35)]]
r.setToGeometry(QgsGeometry.fromPolygonXY(points), None)

Veuillez noter que les points d’un polygone ne sont pas stockés dans une liste. En fait, il s’agit d’une liste d’anneaux contenants les anneaux linéaires du polygones: le premier anneau est la limite extérieure, les autres (optionnels) anneaux correspondent aux trous dans le polygone.

Les contours d’édition peut être personnalisés pour changer leur couleur ou la taille de la ligne:

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

Les éléments du canevas sont liés à la scène du canevas. Pour les cacher temporairement (et les montrer à nouveau), utilisez la combinaison hide() et show(). Pour supprimer complètement l’élément, vous devez le retirer de la scène du canevas

canvas.scene().removeItem(r)

(en C++, il est possible de juste supprimer l’objet mais sous Python del r détruira juste la référence et l’objet existera toujours étant donné qu’il appartient au canevas).

L’élastique peut également être utilisé pour dessiner des points, mais la classe QgsVertexMarker est mieux adaptée pour cela (QgsRubberBand ne dessinerait qu’un rectangle autour du point désiré).

Vous pouvez utiliser le marqueur de sommet comme ceci :

m = QgsVertexMarker(canvas)
m.setCenter(QgsPointXY(10,40))

Cela permettra de tracer une croix rouge sur la position [10,45]. Il est possible de personnaliser le type d’icône, la taille, la couleur et la largeur du stylo

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

Pour cacher temporairement les marqueurs de vertex et les retirer du canevas, utilisez les mêmes méthodes que pour les élastiques.

9.3. Utiliser les outils cartographiques avec le canevas

L’exemple suivant construit une fenêtre qui contient un canevas de carte et des outils cartographiques de base pour le panoramique et le zoom. Des actions sont créées pour l’activation de chaque outil : le panoramique est effectué avec une paire d’instances QgsMapToolPan, le zoom avant/arrière avec une paire d’instances QgsMapToolZoom. Les actions sont définies comme vérifiables et ensuite assignées aux outils pour permettre la gestion automatique de l’état vérifié/décoché des actions – quand un outil de carte est activé, son action est marquée comme sélectionnée et l’action de l’outil de carte précédent est désélectionnée. Les outils cartographiques sont activés en utilisant la méthode setMapTool().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
from qgis.gui import *
from qgis.PyQt.QtWidgets import QAction, QMainWindow
from qgis.PyQt.QtCore import Qt

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.setLayers([layer])

        self.setCentralWidget(self.canvas)

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

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

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

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

        # create the map tools
        self.toolPan = QgsMapToolPan(self.canvas)
        self.toolPan.setAction(self.actionPan)
        self.toolZoomIn = QgsMapToolZoom(self.canvas, False) # false = in
        self.toolZoomIn.setAction(self.actionZoomIn)
        self.toolZoomOut = QgsMapToolZoom(self.canvas, True) # true = out
        self.toolZoomOut.setAction(self.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)

Vous pouvez essayer le code ci-dessus dans l’éditeur de console Python. Pour invoquer la fenêtre de canevas, ajoutez les lignes suivantes pour instancier la classe « MyWnd ». Elles rendront la couche actuellement sélectionnée sur le canevas nouvellement créé

w = MyWnd(iface.activeLayer())
w.show()

9.3.1. Sélectionner les entités en utilisant QgsMapToolIdentifyFeature

Vous pouvez utiliser l’outil cartographique QgsMapToolIdentifyFeature pour demander à l’utilisateur de sélectionner une entité qui sera envoyée à une fonction de rappel.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
def callback(feature):
  """Code called when the feature is selected by the user"""
  print("You clicked on feature {}".format(feature.id()))

canvas = iface.mapCanvas()
feature_identifier = QgsMapToolIdentifyFeature(canvas)

# indicates the layer on which the selection will be done
feature_identifier.setLayer(vlayer)

# use the callback as a slot triggered when the user identifies a feature
feature_identifier.featureIdentified.connect(callback)

# activation of the map tool
canvas.setMapTool(feature_identifier)

9.4. Ecrire des outils cartographiques personnalisés

Vous pouvez écrire vos outils personnalisés, pour mettre en œuvre un comportement personnalisé aux actions effectuées par les utilisateurs sur le canevas.

Les outils cartographiques doivent hériter de la classe QgsMapTool, ou de toute classe dérivée, et être sélectionnés comme outils actifs dans le canevas en utilisant la méthode setMapTool() comme nous l’avons déjà vu.

Voici un exemple d’outil cartographique qui permet de définir une emprise rectangulaire en cliquant et en déplaçant la souris sur le canevas. Lorsque le rectangle est dessiné, il exporte les coordonnées de ses limites dans la console. On utilise des éléments de contour d’édition décrits auparavant pour afficher le rectangle sélectionné au fur et à mesure de son dessin.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
class RectangleMapTool(QgsMapToolEmitPoint):
  def __init__(self, canvas):
    self.canvas = canvas
    QgsMapToolEmitPoint.__init__(self, self.canvas)
    self.rubberBand = QgsRubberBand(self.canvas, True)
    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(True)

  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.deactivated.emit()

9.5. Ecrire des éléments de canevas de carte personnalisés

Voici un exemple d’un canevas personnalisé qui dessine un cercle :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class CircleCanvasItem(QgsMapCanvasItem):
  def __init__(self, canvas):
    super().__init__(canvas)
    self.center = QgsPoint(0, 0)
    self.size   = 100

  def setCenter(self, center):
    self.center = center

  def center(self):
    return self.center

  def setSize(self, size):
    self.size = size

  def size(self):
    return self.size

  def boundingRect(self):
    return QRectF(self.center.x() - self.size/2,
      self.center.y() - self.size/2,
      self.center.x() + self.size/2,
      self.center.y() + self.size/2)

  def paint(self, painter, option, widget):
    path = QPainterPath()
    path.moveTo(self.center.x(), self.center.y());
    path.arcTo(self.boundingRect(), 0.0, 360.0)
    painter.fillPath(path, QColor("red"))


# Using the custom item:
item = CircleCanvasItem(iface.mapCanvas())
item.setCenter(QgsPointXY(200,200))
item.setSize(80)