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.

Überlagerungsoperationen sind ein grundlegender Bestandteil der Geodatenanalyse und ermöglichen den Vergleich, die Kombination und das Ableiten von Beziehungen zwischen verschiedenen räumlichen Datensätzen. Diese Operationen sind besonders nützlich, wenn Fragen wie „Wo überschneiden sich zwei Objekte?“, „Wie groß ist die kombinierte Fläche zweier Regionen?“ oder „Welche Teile einer Region werden von einer anderen nicht abgedeckt?“ beantwortet werden sollen. Die drei häufigsten Überlagerungsoperationen sind **Schnittmenge** (Intersection), **Vereinigung** (Union) und **Differenz** (Difference), die jeweils einen eigenen analytischen Zweck erfüllen.

Die **Schnittmenge**-Operation hilft dabei, den räumlichen Bereich zu finden, in dem sich zwei Datensätze überschneiden. Dies ist entscheidend, wenn gemeinsame Flächen identifiziert werden sollen, beispielsweise Regionen, in denen sich Naturschutzgebiete mit geplanten Entwicklungsflächen überschneiden. Die **Vereinigung**-Operation hingegen kombiniert alle Geometrien beider Datensätze und verschmilzt deren räumliche Ausdehnungen und Attribute. Dies ist nützlich, um einen Datensatz zu erstellen, der alle Flächen abbildet, die von einem der ursprünglichen Datensätze abgedeckt werden. Die **Differenz**-Operation ermöglicht es, die Fläche eines Datensatzes von einem anderen abzuziehen, sodass die ausschließlich dem ersten Datensatz zugehörigen Bereiche sichtbar werden. Dies wird häufig verwendet, um bestimmte Regionen aus der Analyse auszuschließen, zum Beispiel das Entfernen von Gewässern aus einer Landnutzungskarte.

Überlagerungsoperationen werden typischerweise mit der Methode `overlay()` in **geopandas** durchgeführt, die diese komplexen räumlichen Manipulationen vereinfacht und sicherstellt, dass Attributdaten während des Prozesses korrekt verwaltet werden.

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

Tauchen Sie ein in die Grundlagen der Geodatenanalyse mit Python. Dieser Kurs auf mittlerem Niveau führt Sie in die Kernkonzepte und praktischen Anwendungen der Geodatenanalyse ein, mit Fokus auf reale Datensätze und praxisorientierte Projekte. Sie lernen, räumliche Daten mit Python und beliebten Bibliotheken zu manipulieren, zu visualisieren und zu analysieren, mit besonderem Schwerpunkt auf geopandas. Der Kurs ist ansprechend gestaltet und bietet interaktive Raster, Videos und Quizze zur Vertiefung Ihres Lernens.

Erkunden Sie die Grundlagen von Geodaten, Koordinatensystemen und den wichtigsten Werkzeugen für die räumliche Analyse mit Python. Dieser Abschnitt legt das Fundament für die Arbeit mit räumlichen Datensätzen und führt ausführlich in geopandas ein, einschließlich seiner zentralen Datenstrukturen, Lese- und Schreibfunktionen sowie der Integration mit pandas und matplotlib.

Tauchen Sie ein in zentrale Techniken der räumlichen Analyse, einschließlich räumlicher Joins, Overlays und Aggregationen, unter Verwendung von geopandas und Visualisierungsbibliotheken. Dieser Abschnitt behandelt fortgeschrittene Methoden von geopandas zum Kombinieren, Vergleichen und Zusammenfassen räumlicher Datensätze sowie bewährte Verfahren für die Visualisierung räumlicher Daten.

Erwerben Sie ein fundiertes Verständnis realer geodatenbezogener Datensätze und Szenarien mit Schwerpunkt auf praktischen Analyse- und Visualisierungsherausforderungen. Dieser Abschnitt legt den Fokus auf projektbasiertes Lernen und die Synthese von Methoden der Geodatenanalyse.

Überlagerungsoperationen

Lösung