Summary
This chapter covers overlay operations—intersection, union, and difference—that let you combine or compare geometric datasets by computing their overlapping, merged, or exclusive areas.

General domain of usage
geospatial analysis

**Video Description:**  
This video introduces overlay operations in geospatial analysis, focusing on the concepts of intersection, union, and difference. You will see how these operations are used to combine or compare spatial datasets, and why they are essential for spatial data analysis workflows.

Les opérations de superposition constituent une partie fondamentale de l'analyse géospatiale, permettant de comparer, combiner et extraire des relations entre différents jeux de données spatiaux. Ces opérations sont particulièrement utiles pour répondre à des questions telles que « Où deux entités se chevauchent-elles ? », « Quelle est la superficie combinée de deux régions ? » ou « Quelles parties d'une région ne sont pas couvertes par une autre ? » Les trois opérations de superposition les plus courantes sont **l'intersection**, **l'union** et **la différence**, chacune ayant un objectif analytique spécifique.

L'opération **d'intersection** permet d'identifier la zone spatiale où deux jeux de données se chevauchent. Ceci est essentiel pour repérer les zones partagées, comme les régions où des zones de protection de l'environnement croisent des sites de développement proposés. L'opération **d'union**, quant à elle, combine toutes les géométries des deux jeux de données, fusionnant leurs étendues spatiales et attributs. Cela permet de créer un jeu de données représentant toutes les zones couvertes par l'un ou l'autre des jeux de données d'origine. L'opération **de différence** permet de soustraire la zone d'un jeu de données à un autre, révélant les portions restant exclusives au premier jeu de données. Cette opération est souvent utilisée pour exclure certaines régions de l'analyse, comme retirer les plans d'eau d'une carte d'occupation des sols.

Les opérations de superposition sont généralement réalisées à l'aide de la méthode `overlay()` de **geopandas**, qui simplifie ces manipulations spatiales complexes et garantit une gestion correcte des données attributaires durant le processus.

import geopandas as gpd

# Create two simple GeoDataFrames with polygons
poly1 = gpd.GeoDataFrame({'id': [1]}, geometry=gpd.GeoSeries.from_wkt(['POLYGON((0 0, 2 0, 2 2, 0 2, 0 0))']))
poly2 = gpd.GeoDataFrame({'id': [2]}, geometry=gpd.GeoSeries.from_wkt(['POLYGON((1 1, 3 1, 3 3, 1 3, 1 1))']))

# Intersection: find overlapping area
intersection = gpd.overlay(poly1, poly2, how='intersection')
print("Intersection result:")
print(intersection)

# Union: combine all areas
union = gpd.overlay(poly1, poly2, how='union')
print("\nUnion result:")
print(union)


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import geopandas as gpd
from shapely import wkt

class TestTask(unittest.TestCase):
    def setUp(self):
        # Create two polygons
        self.poly1 = gpd.GeoDataFrame({'id': [1]}, geometry=gpd.GeoSeries.from_wkt(['POLYGON((0 0, 2 0, 2 2, 0 2, 0 0))']))
        self.poly2 = gpd.GeoDataFrame({'id': [2]}, geometry=gpd.GeoSeries.from_wkt(['POLYGON((1 1, 3 1, 3 3, 1 3, 1 1))']))

    def test_intersection(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.perform_overlay(self.poly1, self.poly2, "intersection")
        _dynamic_test(
            self,
            result is not None and len(result) == 1 and result.geometry.iloc[0].equals(wkt.loads('POLYGON ((2 1, 2 2, 1 2, 1 1, 2 1))')),
            "Intersection returns correct single polygon of overlap region.",
            f"Expected one intersected polygon covering (1,1)-(2,2), got: {result.geometry if result is not None else None}",
        )

    def test_union(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.perform_overlay(self.poly1, self.poly2, "union")
        _dynamic_test(
            self,
            result is not None and len(result) == 3,
            "Union returns three polygons as expected.",
            f"Expected three polygons in union result, got: {len(result) if result is not None else None}",
        )
        # Check that all three expected polygons are present
        expected_geoms = [
            wkt.loads('POLYGON ((2 1, 2 2, 1 2, 1 1, 2 1))'), # overlap
            wkt.loads('POLYGON ((0 0, 2 0, 2 1, 1 1, 1 2, 0 2, 0 0))'), # left outside
            wkt.loads('POLYGON ((2 1, 3 1, 3 3, 1 3, 1 2, 2 2, 2 1))'), # right outside
        ]
        found = [False, False, False]
        for geom in result.geometry:
            for i, exp in enumerate(expected_geoms):
                if geom.equals(exp):
                    found[i] = True
        _dynamic_test(
            self,
            all(found),
            "Union contains all expected polygons.",
            f"Union missing expected polygons: {found}",
        )

    def test_invalid_operation(self):
        import user_code
        importlib.reload(user_code)
        try:
            user_code.perform_overlay(self.poly1, self.poly2, "symmetric_difference")
        except ValueError as e:
            _dynamic_test(
                self,
                "Invalid operation" in str(e),
                "ValueError raised correctly for invalid operation.",
                f"Expected ValueError with 'Invalid operation', got: {e}",
            )
        else:
            _dynamic_test(
                self,
                False,
                "Should have raised ValueError for invalid operation.",
                "Did not raise ValueError for invalid operation.",
            )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str):
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Plongez dans les fondamentaux de l'analyse de données géospatiales avec Python. Ce cours intermédiaire vous présente les concepts clés et les applications pratiques de l'analyse géospatiale, en mettant l'accent sur des jeux de données réels et des projets pratiques. Vous apprendrez à manipuler, visualiser et analyser des données spatiales avec Python et des bibliothèques populaires, en mettant particulièrement l'accent sur geopandas. Le cours est conçu pour être engageant, avec des grilles interactives, des vidéos et des quiz pour renforcer votre apprentissage.

Explorez les bases des données géospatiales, des systèmes de coordonnées et des outils essentiels pour l'analyse spatiale en Python. Cette section pose les bases du travail avec des ensembles de données spatiales et présente en détail geopandas, y compris ses structures de données principales, ses capacités de lecture/écriture et son intégration avec pandas et matplotlib.

Explorez les techniques fondamentales d'analyse spatiale, y compris les jointures spatiales, les superpositions et les agrégations, en utilisant geopandas et des bibliothèques de visualisation. Cette section couvre des méthodes avancées de geopandas pour combiner, comparer et résumer des ensembles de données spatiales, ainsi que les meilleures pratiques pour la visualisation des données spatiales.

Acquérir une compréhension approfondie des ensembles de données géospatiales réels et des scénarios, en mettant l'accent sur les défis pratiques d'analyse et de visualisation. Cette section met l'accent sur l'apprentissage par projet et la synthèse des techniques d'analyse géospatiale.

Opérations de superposition

Solution