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.

Overlay-bewerkingen vormen een fundamenteel onderdeel van geospatiale analyse, waarmee het mogelijk is om relaties tussen verschillende ruimtelijke datasets te vergelijken, combineren en extraheren. Deze bewerkingen zijn vooral nuttig bij het beantwoorden van vragen zoals "Waar overlappen twee objecten?", "Wat is het gecombineerde oppervlak van twee gebieden?" of "Welke delen van een gebied worden niet door een ander gebied bedekt?" De drie meest voorkomende overlay-bewerkingen zijn **intersection** (doorsnede), **union** (unie) en **difference** (verschil), elk met een eigen analytisch doel.

De **intersection**-bewerking helpt bij het vinden van het ruimtelijke gebied waar twee datasets elkaar overlappen. Dit is essentieel wanneer gedeelde gebieden moeten worden geïdentificeerd, zoals regio's waar milieubeschermingszones overlappen met voorgestelde ontwikkelingslocaties. De **union**-bewerking daarentegen combineert alle geometrieën uit beide datasets, waarbij de ruimtelijke omvang en attributen worden samengevoegd. Dit is nuttig voor het creëren van een dataset die alle gebieden vertegenwoordigt die door een van de oorspronkelijke datasets worden bedekt. Met de **difference**-bewerking kan het gebied van de ene dataset van de andere worden afgetrokken, waardoor zichtbaar wordt welke delen exclusief voor de eerste dataset zijn. Dit wordt vaak gebruikt om bepaalde gebieden uit de analyse te verwijderen, zoals het uitsluiten van wateroppervlakken uit een landgebruikkaart.

Overlay-bewerkingen worden doorgaans uitgevoerd met de `overlay()`-methode in **geopandas**, waarmee deze complexe ruimtelijke bewerkingen worden vereenvoudigd en ervoor wordt gezorgd dat attribuutgegevens tijdens het proces correct worden beheerd.

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

Verdiep je in de basisprincipes van georuimtelijke data-analyse met Python. Deze cursus op gemiddeld niveau introduceert de kernconcepten en praktische toepassingen van georuimtelijke analyse, met de nadruk op datasets uit de praktijk en praktijkgerichte projecten. Je leert ruimtelijke data te manipuleren, visualiseren en analyseren met Python en populaire libraries, met speciale aandacht voor geopandas. De cursus is ontworpen om boeiend te zijn, met interactieve rasters, video's en quizzen ter versterking van het leerproces.

Verken de basisprincipes van geospatiale data, coördinatensystemen en de essentiële tools voor ruimtelijke analyse in Python. Deze sectie legt de basis voor het werken met ruimtelijke datasets en introduceert geopandas in detail, inclusief de kern datastructuren, lees- en schrijfmogelijkheden, en integratie met pandas en matplotlib.

Verdiep u in kerntechnieken voor ruimtelijke analyse, waaronder ruimtelijke joins, overlays en aggregaties, met gebruik van geopandas en visualisatielibraries. Deze sectie behandelt geavanceerde geopandas-methoden voor het combineren, vergelijken en samenvatten van ruimtelijke datasets, evenals best practices voor de visualisatie van ruimtelijke data.

Verkrijg een grondig begrip van echte georuimtelijke datasets en scenario's, met de nadruk op praktische analyse- en visualisatie-uitdagingen. Deze sectie legt de nadruk op projectmatig leren en het samenbrengen van georuimtelijke analysetechnieken.

Overlay-bewerkingen

Oplossing