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-operationer er en grundlæggende del af geospatiel analyse, der gør det muligt at sammenligne, kombinere og udtrække relationer mellem forskellige spatiale datasæt. Disse operationer er særligt nyttige, når der skal besvares spørgsmål som "Hvor overlapper to objekter?", "Hvad er det samlede areal af to regioner?" eller "Hvilke dele af én region er ikke dækket af en anden?" De tre mest almindelige overlay-operationer er **intersection**, **union** og **difference**, som hver især har et unikt analytisk formål.

**Intersection**-operationen bruges til at finde det spatiale område, hvor to datasæt overlapper. Dette er afgørende, når der skal identificeres fælles områder, såsom regioner hvor miljøbeskyttelseszoner overlapper med foreslåede udviklingsområder. **Union**-operationen kombinerer derimod alle geometrier fra begge datasæt og samler deres spatiale udstrækning og attributter. Dette er nyttigt til at oprette et datasæt, der repræsenterer alle områder dækket af et af de oprindelige datasæt. **Difference**-operationen gør det muligt at trække arealet af det ene datasæt fra det andet, hvilket viser hvilke områder der forbliver eksklusive for det første datasæt. Dette bruges ofte, når visse regioner skal udelukkes fra analysen, for eksempel ved at fjerne vandområder fra et arealanvendelseskort.

Overlay-operationer udføres typisk ved hjælp af `overlay()`-metoden i **geopandas**, som forenkler disse komplekse spatiale manipulationer og sikrer, at attributdata håndteres korrekt under processen.

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

Dyk ned i grundlæggende geospatiel dataanalyse med Python. Dette mellemniveaukursus introducerer dig til kernekoncepter og praktiske anvendelser af geospatiel analyse med fokus på virkelige datasæt og praktiske projekter. Du lærer at manipulere, visualisere og analysere spatiale data ved hjælp af Python og populære biblioteker, med særlig vægt på geopandas. Kurset er designet til at være engagerende og indeholder interaktive gittere, videoer og quizzer for at styrke din læring.

Udforsk det grundlæggende inden for geospatiale data, koordinatsystemer og de væsentlige værktøjer til rumlig analyse i Python. Dette afsnit danner grundlaget for at arbejde med spatiale datasæt og introducerer geopandas i detaljer, herunder dets kerne-datastrukturer, læse-/skrivefunktioner og integration med pandas og matplotlib.

Dyk ned i centrale rumlige analyseteknikker, herunder rumlige joins, overlays og aggregeringer, ved brug af geopandas og visualiseringsbiblioteker. Dette afsnit dækker avancerede geopandas-metoder til at kombinere, sammenligne og opsummere rumlige datasæt samt bedste praksis for visualisering af rumlige data.

Opnå en solid forståelse af geospatiale datasæt og scenarier fra den virkelige verden med fokus på praktiske analyse- og visualiseringsudfordringer. Dette afsnit lægger vægt på projektbaseret læring og syntese af geospatiale analyseteknikker.

Overlejringsoperationer

Løsning