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.

Overlagringsoperasjoner er en grunnleggende del av geografisk analyse, og gjør det mulig å sammenligne, kombinere og trekke ut relasjoner mellom ulike romlige datasett. Disse operasjonene er spesielt nyttige når du skal besvare spørsmål som «Hvor overlapper to objekter?», «Hva er det samlede arealet av to regioner?» eller «Hvilke deler av én region er ikke dekket av en annen?». De tre vanligste overlagringsoperasjonene er **interseksjon**, **union** og **differanse**, som hver har sitt unike analytiske formål.

**Interseksjon**-operasjonen hjelper deg å finne det geografiske området hvor to datasett overlapper. Dette er avgjørende når du vil identifisere felles områder, for eksempel regioner hvor verneområder overlapper med foreslåtte utbyggingsområder. **Union**-operasjonen kombinerer derimot alle geometrier fra begge datasett, og slår sammen deres utstrekning og attributter. Dette er nyttig for å lage et datasett som representerer alle områder dekket av ett eller begge de opprinnelige datasettene. **Differanse**-operasjonen lar deg trekke fra arealet til ett datasett fra et annet, slik at du ser hvilke deler som kun tilhører det første datasettet. Dette brukes ofte når du vil utelate bestemte områder fra analysen, for eksempel å fjerne vannområder fra et arealbruks-kart.

Overlagringsoperasjoner utføres vanligvis med `overlay()`-metoden i **geopandas**, som forenkler disse komplekse romlige manipuleringene og sikrer at attributtdata håndteres korrekt gjennom prosessen.

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

Fordyp deg i grunnleggende geodataanalyse med Python. Dette mellomnivåkurset introduserer deg for kjernebegreper og praktiske anvendelser av geospatial analyse, med fokus på virkelige datasett og praktiske prosjekter. Du lærer å manipulere, visualisere og analysere romlige data ved hjelp av Python og populære biblioteker, med særlig vekt på geopandas. Kurset er utformet for å være engasjerende, med interaktive rutenett, videoer og quizer for å styrke læringen.

Utforsk det grunnleggende innen geodata, koordinatsystemer og de viktigste verktøyene for romlig analyse i Python. Denne delen legger grunnlaget for arbeid med romlige datasett og introduserer geopandas i detalj, inkludert dets kjerne datastrukturer, lese- og skrivefunksjoner, samt integrasjon med pandas og matplotlib.

Fordyp deg i sentrale romlige analyseteknikker, inkludert romlige sammenføyninger, overlegg og aggregeringer, ved bruk av geopandas og visualiseringsbiblioteker. Denne delen dekker avanserte geopandas-metoder for å kombinere, sammenligne og oppsummere romlige datasett, samt beste praksis for visualisering av romlige data.

Få en solid forståelse av geospatiale datasett og scenarier fra virkeligheten, med fokus på praktiske analyse- og visualiseringsutfordringer. Denne delen legger vekt på prosjektbasert læring og syntese av geospatiale analyseteknikker.

Overlagringsoperasjoner

Løsning