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.

Operações de sobreposição são uma parte fundamental da análise geoespacial, permitindo comparar, combinar e extrair relações entre diferentes conjuntos de dados espaciais. Essas operações são especialmente úteis quando é necessário responder a perguntas como "Onde duas feições se sobrepõem?", "Qual é a área combinada de duas regiões?" ou "Quais partes de uma região não são cobertas por outra?" As três operações de sobreposição mais comuns são **interseção**, **união** e **diferença**, cada uma com um propósito analítico específico.

A operação de **interseção** permite identificar a área espacial onde dois conjuntos de dados se sobrepõem. Isso é essencial para identificar áreas compartilhadas, como regiões onde zonas de proteção ambiental se cruzam com locais de desenvolvimento propostos. A operação de **união**, por sua vez, combina todas as geometrias de ambos os conjuntos de dados, unindo suas extensões espaciais e atributos. Isso é útil para criar um conjunto de dados que representa todas as áreas cobertas por qualquer um dos conjuntos originais. A operação de **diferença** possibilita subtrair a área de um conjunto de dados de outro, revelando quais porções permanecem exclusivas ao primeiro conjunto. Isso é frequentemente utilizado quando se deseja excluir certas regiões da análise, como remover corpos d'água de um mapa de uso do solo.

As operações de sobreposição são normalmente realizadas utilizando o método `overlay()` do **geopandas**, que simplifica essas manipulações espaciais complexas e garante que os dados de atributos sejam devidamente gerenciados durante o processo.

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

Mergulhe nos fundamentos da análise de dados geoespaciais utilizando Python. Este curso intermediário apresenta os conceitos centrais e aplicações práticas da análise geoespacial, com foco em conjuntos de dados do mundo real e projetos práticos. Você aprenderá a manipular, visualizar e analisar dados espaciais com Python e bibliotecas populares, com ênfase especial em geopandas. O curso foi desenvolvido para ser envolvente, apresentando grades interativas, vídeos e questionários para reforçar o aprendizado.

Explore os conceitos essenciais de dados geoespaciais, sistemas de coordenadas e as ferramentas fundamentais para análise espacial em Python. Esta seção estabelece a base para trabalhar com conjuntos de dados espaciais e apresenta o geopandas em detalhes, incluindo suas principais estruturas de dados, capacidades de leitura/escrita e integração com pandas e matplotlib.

Aprofunde-se nas principais técnicas de análise espacial, incluindo junções espaciais, sobreposições e agregações, utilizando geopandas e bibliotecas de visualização. Esta seção aborda métodos avançados do geopandas para combinar, comparar e resumir conjuntos de dados espaciais, além de melhores práticas para visualização de dados espaciais.

Adquira uma compreensão sólida de conjuntos de dados geoespaciais do mundo real e cenários, com foco em desafios práticos de análise e visualização. Esta seção enfatiza o aprendizado baseado em projetos e a síntese de técnicas de análise geoespacial.

Operações de Sobreposição

Solução