Géotraitements courants dans QGIS : tampon, intersection, regroupement

Quelles habitations sont à moins de 300 m d'une ligne à haute tension ? Quelle surface de forêt chaque commune possède-t-elle ? Comment fusionner des parcelles en îlots de propriété ? Ces questions se résolvent avec une poignée d'opérations, les géotraitements : tampon, intersection, découpage, différence, union et regroupement. Ce tutoriel explique ce que fait chacune dans QGIS, comment les enchaîner et les pièges à éviter.

Où les trouver dans QGIS

• Vecteur › Outils de géotraitement : les plus courantes (Tampon, Intersection, Découper, Différence, Union, Regrouper…).
• La boîte à outils de traitement (Ctrl + Alt + T) : tous les algorithmes de QGIS, GDAL et GRASS, avec une barre de recherche. Chaque algorithme peut se lancer en mode de traitement par lot (clic droit), sur plusieurs couches d'un coup.
• L'historique des traitements garde les paramètres de chaque exécution : pratique pour refaire un calcul ou copier sa commande Python.
• Le modeleur graphique enchaîne plusieurs algorithmes en un seul, réutilisable.

Deux vérifications avant de commencer

Vérifiez aussi que les géométries sont valides : une auto-intersection fait échouer une intersection ou produit des résultats faux. L'algorithme Vérifier la validité les détecte et Réparer les géométries les corrige (voir Géométries invalides et topologie). Dans Options › Traitements, le réglage « Filtrage des entités invalides » décide si QGIS s'arrête, ignore ou traite quand même ces objets.

Le tampon

L'algorithme Tampon (native:buffer) dessine autour de chaque objet la zone située à moins d'une distance donnée : un disque autour d'un point, un couloir autour d'une ligne, un polygone élargi.

• Distance : fixe, ou lue dans un champ grâce au bouton de paramètre défini par les données (par exemple "largeur" / 2 pour une route). Une distance négative rétrécit un polygone.
• Segments : nombre de segments par quart de cercle (5 par défaut). Montez à 16 ou plus pour des cercles réguliers.
• Style d'extrémité : rond, plat ou carré, pour les lignes.
• Regrouper le résultat : fusionne les tampons qui se chevauchent en une seule zone, au prix des attributs.

Le tampon répond à « à moins de X mètres » ; pour un temps de parcours (à pied, en voiture), utilisez plutôt des isochrones.

Superposer deux couches

Ces opérations combinent une couche d'entrée et une couche de superposition. Elles se distinguent par ce qu'elles gardent de chaque couche :

Exemple classique : la surface de forêt par commune. Intersection entre les communes et la couche des forêts donne des morceaux de forêt qui portent le nom de leur commune ; il reste à calculer leur surface et à les additionner par commune.

Regrouper

Regrouper (native:dissolve, « dissolve » en anglais) fusionne les objets qui ont la même valeur dans un ou plusieurs champs : des communes en départements, des parcelles en îlots d'un même propriétaire, des zones de PLU par type (U, AU, A, N). Sans champ choisi, tout est fusionné en un seul objet.

• Les limites intérieures disparaissent ; un objet multiple est créé si les morceaux ne se touchent pas (depuis QGIS 3.30, une option du traitement les garde en objets séparés).
• Les autres attributs sont ceux du premier objet de chaque groupe : pour des sommes ou des moyennes, utilisez Agréger (native:aggregate), qui regroupe et calcule en même temps, par exemple sum("population").

Enchaîner les traitements

Question : quelle surface d'espaces verts se trouve à moins de 500 m de chaque école ?

1. Tampon de 500 m autour des écoles (couches en Lambert 93).
2. Intersection entre les tampons et les espaces verts.
3. Calculatrice de champs : $area sur les morceaux.
4. Agréger par identifiant d'école, avec la somme des surfaces.

Le même enchaînement en Python, dans la console de QGIS. Les noms des paramètres s'affichent avec processing.algorithmHelp("native:buffer") :

import processing

tampons = processing.run("native:buffer", {
    "INPUT": "ecoles", "DISTANCE": 500, "SEGMENTS": 16, "DISSOLVE": False, "OUTPUT": "memory:"
})["OUTPUT"]

morceaux = processing.run("native:intersection", {
    "INPUT": tampons, "OVERLAY": "espaces_verts", "OUTPUT": "memory:"
})["OUTPUT"]

par_ecole = processing.run("native:aggregate", {
    "INPUT": morceaux, "GROUP_BY": '"id_ecole"',
    "AGGREGATES": [
        {"aggregate": "first_value", "input": '"id_ecole"', "name": "id_ecole", "type": 10, "length": 0, "precision": 0},
        {"aggregate": "sum", "input": "$area", "name": "surface_verte_m2", "type": 6, "length": 0, "precision": 0},
    ],
    "OUTPUT": "TEMPORARY_OUTPUT"
})["OUTPUT"]
QgsProject.instance().addMapLayer(par_ecole)

En SQL, avec PostGIS, la même question tient en une requête : ST_Buffer, ST_Intersection, puis sum(ST_Area(…)) avec GROUP BY. Et ST_Union(geom) avec GROUP BY fait le regroupement.

Les pièges courants

• Systèmes différents : QGIS reprojette à la volée à l'affichage, mais les traitements comparent des couches qui devraient être dans le même système. Harmonisez-les avant.
• Polygones résiduels (« slivers ») : deux couches dont les limites devraient coïncider mais diffèrent de quelques centimètres donnent de minuscules polygones parasites. Filtrez-les par leur surface, ou accrochez les géométries entre elles (Accrocher les géométries à la couche).
• Couches temporaires : un résultat « couche temporaire » disparaît à la fermeture du projet. Enregistrez ce qui doit durer dans un GeoPackage.
• Gros volumes : créez un index spatial sur les couches (Créer un index spatial), ou passez à PostGIS au-delà de quelques centaines de milliers d'objets.

Démonstration

Les communes de la Métropole de Lyon et trois géotraitements calculés dans votre navigateur avec la bibliothèque Turf.js, qui reproduit les algorithmes de QGIS.

À essayer : en mode « Tampon et intersection », cliquez une commune puis faites varier la distance : la liste donne la surface du tampon tombée dans chaque commune voisine. Passez en mode « Regrouper » et comparez le regroupement par classe de densité avec la fusion complète en un seul objet, la Métropole.