Comprendre les différentes formes d’union en SIG

L’union spatiale est une des opérations fondamentales en géomatique. Elle permet de combiner plusieurs couches ou entités pour produire de nouvelles géométries ou enrichir les attributs. Pourtant, derrière ce terme apparemment simple, se cachent plusieurs variantes selon l’outil ou la bibliothèque utilisée.

Dans cet article, nous allons détailler :

• les principaux types d’union (ST_Union, Union, Union spatial d’ArcGIS, etc.)
• leurs différences conceptuelles et pratiques
• des exemples d’implémentation en SQL (PostGIS) et en Python (QGIS/Processing).

Pourquoi c’est souvent confus ?

Le mot union recouvre plusieurs opérations différentes selon l’outil utilisé :

• Union (overlay) comme dans QGIS/ArcGIS : découpe + concaténation d’attributs.
• ST_Union (PostGIS) : fusion géométrique (dissolve global ou par groupe).
• ST_UnaryUnion (PostGIS) : fusion topologique rapide/robuste (topology-preserving).
• Dissolve par attribut : agréger des entités partageant une même valeur.

Bien choisir l’opération évite des surprises… et des SQL XXL.

1) Union (overlay) – le “vrai” Union façon QGIS/ArcGIS

Ce que ça fait

• Garde tous les morceaux géométriques résultant des superpositions et des non-superpositions.
• Concatène les attributs des deux couches (avec NULL côté manquant).
• Idéal pour des analyses multicritères (zonages qui se recoupent partiellement).

À retenir

• C’est une opération d’overlay, pas une fusion de géométries.
• Le résultat peut contenir beaucoup d’objets (chaque intersection crée des morceaux).

Exemple Python (QGIS Processing)

import processing
from qgis.core import QgsProject

# Deux couches chargées dans QGIS (QgsVectorLayer) : layer_a, layer_b
result = processing.run("qgis:union", {
    "INPUT": layer_a,
    "OVERLAY": layer_b,
    "OUTPUT": "memory:"  # ou un GPKG/PG
})

union_layer = result["OUTPUT"]
QgsProject.instance().addMapLayer(union_layer)

Exemple PostGIS (pattern SQL “overlay union”)

Version compacte sans attributs (juste l’ID des paires + géom).

WITH pairs AS (
  SELECT a.gid AS ida, b.gid AS idb, ST_Intersection(a.geom, b.geom) AS geom
  FROM plugin.communes a
  JOIN plugin.logements b ON ST_Intersects(a.geom, b.geom)
  WHERE NOT ST_IsEmpty(ST_Intersection(a.geom, b.geom))
),
inter_union AS (
  SELECT ST_UnaryUnion(geom) AS geom FROM pairs
),
a_only AS (
  SELECT a.gid AS ida, NULL::integer AS idb,
         ST_Difference(a.geom, (SELECT geom FROM inter_union)) AS geom
  FROM plugin.communes a
  WHERE NOT ST_IsEmpty(ST_Difference(a.geom, (SELECT geom FROM inter_union)))
),
b_only AS (
  SELECT NULL::integer AS ida, b.gid AS idb,
         ST_Difference(b.geom, (SELECT geom FROM inter_union)) AS geom
  FROM plugin.logements b
  WHERE NOT ST_IsEmpty(ST_Difference(b.geom, (SELECT geom FROM inter_union)))
)
SELECT * FROM pairs
UNION ALL
SELECT * FROM a_only
UNION ALL
SELECT * FROM b_only;

2) ST_Union – fusion géométrique (dissolve global)

Ce que ça fait

• Fusionne un ensemble de géométries en une seule (Multi*) sans conserver les attributs.
• Par défaut, gère la topologie, mais ST_UnaryUnion est en général plus robuste/rapide.

Quand l’utiliser

• Pour dissoudre des polygones mitoyens (ex. créer l’emprise globale).
• Pour pré-agréger avant un buffer ou un calcul surfacique.

Exemple SQL : fusionner deux tables en une seule géométrie

CREATE TABLE plugin.emprise_globale AS
SELECT ST_UnaryUnion(geom) AS geom
FROM (
  SELECT geom FROM plugin.communes
  UNION ALL
  SELECT geom FROM plugin.logements
) s;

Exemple Python (psycopg2)

import psycopg2
conn = psycopg2.connect("dbname=... user=... password=... host=... port=...")
cur = conn.cursor()
cur.execute("""
  DROP TABLE IF EXISTS plugin.emprise_globale;
  CREATE TABLE plugin.emprise_globale AS
  SELECT ST_UnaryUnion(geom) AS geom
  FROM (
    SELECT geom FROM plugin.communes
    UNION ALL
    SELECT geom FROM plugin.logements
  ) s;
""")
conn.commit()
cur.close()
conn.close()

3) ST_UnaryUnion – fusion topologique (plus robuste)

Ce que ça fait

• Comme ST_Union, mais topology-preserving et souvent plus rapide.
• Corrige mieux les multi-overlaps, anneaux partagés, petites erreurs de topologie.

Quand l’utiliser

• Toujours pour les grandes couches ou celles avec des géométries imparfaites.
• Comme brique à l’intérieur d’autres requêtes (ex. overlay union).

Exemple Python (GeoPandas)

import geopandas as gpd

gdf = gpd.read_file("commun.es.gpkg")
geom_unary = gdf.unary_union  # équivalent à ST_UnaryUnion
# -> geom_unary est un (Multi)Polygon shapely

4) Dissolve par attribut (ST_Union + GROUP BY)

Ce que ça fait

• Regroupe les entités par une clé et fusionne la géométrie à l’intérieur de chaque groupe.
• Les attributs ne sont pas automatiquement agrégés (sauf la clé) → ajouter vos agrégats.

Exemple SQL : dissoudre les communes par EPCI

CREATE TABLE plugin.communes_par_epci AS
SELECT epci,
       ST_UnaryUnion(geom) AS geom
FROM plugin.communes
GROUP BY epci;

Exemple Python (QGIS Processing – Dissolve)

import processing

res = processing.run("native:dissolve", {
    "INPUT": layer_communes,
    "FIELD": ["epci"],
    "SEPARATE_DISJOINT": False,
    "OUTPUT": "memory:"
})
dissolved = res["OUTPUT"]

5) Bonus : GeoPandas – overlay(…, how= »union »)

Ce que ça fait

• Equivalent de l’Union overlay QGIS/ArcGIS côté Python scientifique.

import geopandas as gpd

a = gpd.read_file("plugin_communes.gpkg")
b = gpd.read_file("plugin_logements.gpkg")

u = gpd.overlay(a, b, how="union")
u.to_file("union_overlay.gpkg")

Comment choisir ?

• Vous voulez conserver les attributs des 2 couches + garder les zones non superposées ?
  → Union (overlay).
• Vous voulez une seule géométrie fusionnée (pour une emprise, un masque) ?
  → ST_UnaryUnion (ou ST_Union à défaut).
• Vous voulez dissoudre par une clé (départements, EPCI…) ?
  → GROUP BY + ST_UnaryUnion.
• Vous voulez tout faire en Python QGIS sans SQL ?
  → qgis:union (overlay) ou native:dissolve (dissolve par attribut).

Résumé comparatif

Pièges & bonnes pratiques

• Attributs vs géométrie : ST_Union ne collez pas les attributs ⇒ pas d’overlay.
• Types d’attributs : en overlay SQL maison, alignez les types (ou castez en text) avant UNION ALL.
• Topologie : préfèrez ST_UnaryUnion pour des jeux volumineux ou un peu “sales”.
• SRID : assurez-vous que les deux couches partagent le même SRID ; sinon reprojectez avant.
• Polygone vs Multi : forcez éventuellement ST_Multi(...) si vous avez besoin d’un type homogène.

Récap’ des snippets Python (à copier-coller)

A) Overlay Union (QGIS)

import processing
from qgis.core import QgsProject

result = processing.run("qgis:union", {
    "INPUT": layer_a,
    "OVERLAY": layer_b,
    "OUTPUT": "memory:"
})
QgsProject.instance().addMapLayer(result["OUTPUT"])

B) Fusion globale (PostGIS)

import psycopg2
conn = psycopg2.connect("dbname=... user=... password=... host=... port=...")
cur = conn.cursor()
cur.execute("""
  DROP TABLE IF EXISTS plugin.emprise_globale;
  CREATE TABLE plugin.emprise_globale AS
  SELECT ST_UnaryUnion(geom) AS geom
  FROM (
    SELECT geom FROM plugin.communes
    UNION ALL
    SELECT geom FROM plugin.logements
  ) s;
""")
conn.commit(); cur.close(); conn.close()

C) Dissolve par attribut (QGIS)

import processing

res = processing.run("native:dissolve", {
    "INPUT": layer_communes,
    "FIELD": ["epci"],
    "OUTPUT": "memory:"
})

D) Overlay Union (GeoPandas)

import geopandas as gpd
u = gpd.overlay(gpd.read_file("a.gpkg"), gpd.read_file("b.gpkg"), how="union")
u.to_file("union_overlay.gpkg")

Conclusion

Le terme union recouvre en réalité deux logiques différentes :

• fusion géométrique (ST_Union, Dissolve) → pour simplifier les contours.
• superposition avec combinaison d’attributs (UNION, ArcGIS Union) → pour l’analyse multicritères.

Le choix dépend donc de l’objectif : simplifier ou analyser.

Dans un prochain article, nous pourrons explorer en détail les performances de ces différentes approches, car les unions peuvent vite devenir coûteuses en temps de calcul lorsqu’on manipule des millions de géométries.

Si cet article vous a intéressé et que vous pensez qu'il pourrait bénéficier à d'autres personnes, n'hésitez pas à le partager sur vos réseaux sociaux en utilisant les boutons ci-dessous. Votre partage est apprécié !

Atilio Francois