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.

Överläggningsoperationer är en grundläggande del av geospatial analys och möjliggör jämförelse, kombination och extraktion av relationer mellan olika rumsliga datamängder. Dessa operationer är särskilt användbara när du behöver besvara frågor som "Var överlappar två objekt?", "Vad är den sammanlagda ytan av två regioner?" eller "Vilka delar av en region täcks inte av en annan?" De tre vanligaste överläggningsoperationerna är **intersection** (skärning), **union** (union) och **difference** (differens), där varje operation har ett unikt analytiskt syfte.

Operationen **intersection** hjälper till att hitta det rumsliga område där två datamängder överlappar. Detta är avgörande när du vill identifiera gemensamma områden, till exempel där miljöskyddszoner överlappar med föreslagna utvecklingsområden. Operationen **union** kombinerar däremot alla geometrier från båda datamängderna och slår samman deras rumsliga utbredning och attribut. Detta är användbart för att skapa en datamängd som representerar alla områden som täcks av någon av de ursprungliga datamängderna. Operationen **difference** gör det möjligt att subtrahera ett områdes yta från ett annat, vilket visar vilka delar som är exklusiva för den första datamängden. Detta används ofta när du vill exkludera vissa områden från din analys, till exempel att ta bort vattenområden från en markanvändningskarta.

Överläggningsoperationer utförs vanligtvis med metoden `overlay()` i **geopandas**, vilket förenklar dessa komplexa rumsliga manipulationer och säkerställer att attributdata hanteras 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

Fördjupa dig i grunderna för geospatial dataanalys med Python. Denna kurs på mellannivå introducerar dig till kärnkoncept och praktiska tillämpningar av geospatial analys, med fokus på verkliga dataset och praktiska projekt. Du lär dig att manipulera, visualisera och analysera rumsliga data med Python och populära bibliotek, med särskild tonvikt på geopandas. Kursen är utformad för att vara engagerande och innehåller interaktiva rutnät, videor och quiz för att förstärka ditt lärande.

Utforska grunderna i geospatial data, koordinatsystem och de viktigaste verktygen för rumslig analys i Python. Denna sektion lägger grunden för arbete med rumsliga dataset och introducerar geopandas i detalj, inklusive dess centrala datastrukturer, läs- och skrivfunktioner samt integration med pandas och matplotlib.

Fördjupa dig i centrala tekniker för rumslig analys, inklusive rumsliga joins, överlägg och aggregeringar, med hjälp av geopandas och visualiseringsbibliotek. Detta avsnitt täcker avancerade geopandas-metoder för att kombinera, jämföra och sammanfatta rumsliga dataset, samt bästa praxis för visualisering av rumsliga data.

Få en gedigen förståelse för verkliga geospatiala dataset och scenarier, med fokus på praktiska analys- och visualiseringsutmaningar. Detta avsnitt betonar projektbaserat lärande och syntes av geospatiala analystekniker.

Överlappningsoperationer

Lösning