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.

Las operaciones de superposición son una parte fundamental del análisis geoespacial, ya que permiten comparar, combinar y extraer relaciones entre diferentes conjuntos de datos espaciales. Estas operaciones son especialmente útiles cuando se necesita responder preguntas como "¿Dónde se superponen dos entidades?", "¿Cuál es el área combinada de dos regiones?" o "¿Qué partes de una región no están cubiertas por otra?" Las tres operaciones de superposición más comunes son **intersección**, **unión** y **diferencia**, cada una con un propósito analítico específico.

La operación de **intersección** permite identificar el área espacial donde dos conjuntos de datos se superponen. Esto es crucial cuando se desea localizar áreas compartidas, como regiones donde las zonas de protección ambiental se cruzan con sitios de desarrollo propuestos. Por otro lado, la operación de **unión** combina todas las geometrías de ambos conjuntos de datos, fusionando sus extensiones espaciales y atributos. Esto resulta útil para crear un conjunto de datos que represente todas las áreas cubiertas por cualquiera de los conjuntos originales. La operación de **diferencia** permite restar el área de un conjunto de datos de otro, mostrando qué porciones permanecen exclusivas del primer conjunto. Esto se utiliza a menudo cuando se desea excluir ciertas regiones del análisis, como eliminar cuerpos de agua de un mapa de uso del suelo.

Las operaciones de superposición se realizan típicamente utilizando el método `overlay()` en **geopandas**, que simplifica estas manipulaciones espaciales complejas y garantiza que los datos de atributos se gestionen correctamente durante el proceso.

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

Sumérgete en los fundamentos del análisis de datos geoespaciales utilizando Python. Este curso intermedio te introduce a los conceptos clave y aplicaciones prácticas del análisis geoespacial, enfocándose en conjuntos de datos reales y proyectos prácticos. Aprenderás a manipular, visualizar y analizar datos espaciales usando Python y bibliotecas populares, con un énfasis especial en geopandas. El curso está diseñado para ser interactivo, con cuadrículas, videos y cuestionarios que refuerzan tu aprendizaje.

Explora los conceptos esenciales de los datos geoespaciales, los sistemas de coordenadas y las herramientas fundamentales para el análisis espacial en Python. Esta sección establece las bases para trabajar con conjuntos de datos espaciales e introduce geopandas en detalle, incluyendo sus estructuras de datos principales, capacidades de lectura/escritura e integración con pandas y matplotlib.

Profundiza en las técnicas fundamentales de análisis espacial, incluyendo uniones espaciales, superposiciones y agregaciones, utilizando geopandas y bibliotecas de visualización. Esta sección abarca métodos avanzados de geopandas para combinar, comparar y resumir conjuntos de datos espaciales, así como las mejores prácticas para la visualización de datos espaciales.

Adquiera una comprensión sólida de conjuntos de datos geoespaciales del mundo real y escenarios, enfocándose en desafíos prácticos de análisis y visualización. Esta sección enfatiza el aprendizaje basado en proyectos y la síntesis de técnicas de análisis geoespacial.

Operaciones de Superposición

Solución