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.

Päällekkäisyysoperaatiot ovat olennainen osa paikkatietoanalyysiä, ja niiden avulla voidaan vertailla, yhdistää ja tunnistaa suhteita eri spatiaalisten aineistojen välillä. Näitä operaatioita käytetään erityisesti silloin, kun halutaan vastata kysymyksiin kuten "Missä kaksi kohdetta menevät päällekkäin?", "Mikä on kahden alueen yhteenlaskettu pinta-ala?" tai "Mitkä osat yhdestä alueesta eivät kuulu toisen alueen piiriin?" Kolme yleisintä päällekkäisyysoperaatiota ovat **leikkaus** (intersection), **yhdistys** (union) ja **erotus** (difference), joilla jokaisella on oma analyyttinen käyttötarkoituksensa.

**Leikkaus**-operaatiolla löydetään alue, jossa kaksi aineistoa menevät päällekkäin. Tämä on tärkeää esimerkiksi silloin, kun halutaan tunnistaa yhteiset alueet, kuten ympäristönsuojelualueiden ja suunniteltujen rakennuskohteiden risteyskohdat. **Yhdistys**-operaatio puolestaan yhdistää molempien aineistojen kaikki geometriat, jolloin niiden spatiaalinen laajuus ja attribuutit yhdistyvät. Tämä on hyödyllistä, kun halutaan muodostaa aineisto, joka kattaa kaikki alkuperäisten aineistojen alueet. **Erotus**-operaatiolla voidaan vähentää toisen aineiston alue ensimmäisestä, jolloin jäljelle jää vain ensimmäiselle aineistolle ominaiset osat. Tätä käytetään usein esimerkiksi silloin, kun halutaan rajata analyysistä pois tietyt alueet, kuten vesistöt maankäyttökartasta.

Päällekkäisyysoperaatiot suoritetaan tyypillisesti **geopandas**-kirjaston `overlay()`-metodilla, joka helpottaa monimutkaisia spatiaalisia käsittelyjä ja varmistaa, että attribuuttitiedot säilyvät oikein prosessin aikana.

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

Sukella paikkatietoanalyysin perusteisiin Pythonilla. Tämä keskitason kurssi esittelee paikkatietoanalyysin ydinkäsitteet ja käytännön sovellukset, keskittyen todellisiin aineistoihin ja käytännön projekteihin. Opit käsittelemään, visualisoimaan ja analysoimaan paikkatietoa Pythonilla ja suosituilla kirjastoilla, erityisesti geopandasilla. Kurssi on suunniteltu mukaansatempaavaksi, sisältäen interaktiivisia taulukoita, videoita ja tietovisoja oppimisen tukemiseksi.

Tutustu paikkatietoaineistojen perusteisiin, koordinaattijärjestelmiin ja keskeisiin työkaluihin spatiaalisen analyysin toteuttamiseksi Pythonilla. Tämä osio luo perustan paikkatietoaineistojen käsittelylle ja esittelee geopandas-kirjaston yksityiskohtaisesti, mukaan lukien sen ydintietorakenteet, luku- ja kirjoitusominaisuudet sekä integraation pandas- ja matplotlib-kirjastojen kanssa.

Syvenny keskeisiin spatiaalisen analyysin tekniikoihin, kuten spatiaalisiin liitoksiin, päällekkäisyyksiin ja aggregointeihin, hyödyntäen geopandasia ja visualisointikirjastoja. Tässä osiossa käsitellään edistyneitä geopandas-menetelmiä spatiaalisten aineistojen yhdistämiseen, vertailuun ja tiivistämiseen sekä parhaisiin käytäntöihin spatiaalisen datan visualisoinnissa.

Hanki vankka ymmärrys todellisten paikkatietoaineistojen ja -tilanteiden käsittelystä, keskittyen käytännön analyysi- ja visualisointihaasteisiin. Tässä osiossa painotetaan projektipohjaista oppimista ja paikkatietoanalyyttisten menetelmien yhdistämistä.

Päällekkäisyystoiminnot

Ratkaisu