GeoMaster

O que GeoMaster faz?

Habilidade abrangente em ciências geoespaciais cobrindo GIS, sensoriamento remoto, análise espacial e aprendizado de máquina para observação da Terra em mais de 70 tópicos com mais de 500 exemplos de código em 8 linguagens de programação.

Instalação

# Stack principal Python (recomendado conda)
conda install -c conda-forge gdal rasterio fiona shapely pyproj geopandas

# Sensoriamento remoto e ML (rsgislib é apenas conda-forge, não no PyPI)
conda install -c conda-forge rsgislib
uv pip install torchgeo earthengine-api
uv pip install scikit-learn xgboost torch-geometric

# Rede e visualização
uv pip install osmnx networkx folium keplergl
uv pip install cartopy contextily mapclassify

# Big data e nuvem
uv pip install xarray rioxarray dask-geopandas
uv pip install pystac-client planetary-computer

# Nuvens de pontos
uv pip install laspy pylas open3d pdal

# Bancos de dados
conda install -c conda-forge postgis spatialite

Início Rápido

NDVI a partir do Sentinel-2

import rasterio
import numpy as np

with rasterio.open('sentinel2.tif') as src:
    red = src.read(4).astype(float)   # B04
    nir = src.read(8).astype(float)   # B08
    ndvi = (nir - red) / (nir + red + 1e-8)
    ndvi = np.nan_to_num(ndvi, nan=0)

    profile = src.profile
    profile.update(count=1, dtype=rasterio.float32)

    with rasterio.open('ndvi.tif', 'w', **profile) as dst:
        dst.write(ndvi.astype(rasterio.float32), 1)

Análise Espacial com GeoPandas

import geopandas as gpd

# Carregar e garantir mesmo CRS
zones = gpd.read_file('zones.geojson')
points = gpd.read_file('points.geojson')

if zones.crs != points.crs:
    points = points.to_crs(zones.crs)

# Junção espacial e estatísticas
joined = gpd.sjoin(points, zones, how='inner', predicate='within')
stats = joined.groupby('zone_id').agg({
    'value': ['count', 'mean', 'std', 'min', 'max']
}).round(2)

Série Temporal no Google Earth Engine

import ee
import pandas as pd

ee.Initialize(project='seu-projeto')
roi = ee.Geometry.Point([-122.4, 37.7]).buffer(10000)

s2 = (ee.ImageCollection('COPERNICUS/S2_SR_HARMONIZED')
      .filterBounds(roi)
      .filterDate('2020-01-01', '2023-12-31')
      .filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 20)))

def add_ndvi(img):
    return img.addBands(img.normalizedDifference(['B8', 'B4']).rename('NDVI'))

s2_ndvi = s2.map(add_ndvi)

def extract_series(image):
    stats = image.reduceRegion(ee.Reducer.mean(), roi.centroid(), scale=10, maxPixels=1e9)
    return ee.Feature(None, {'date': image.date().format('YYYY-MM-dd'), 'ndvi': stats.get('NDVI')})

series = s2_ndvi.map(extract_series).getInfo()
df = pd.DataFrame([f['properties'] for f in series['features']])
df['date'] = pd.to_datetime(df['date'])

Conceitos Principais

Tipos de Dados

Tipo	Exemplos	Bibliotecas
Vetorial	Shapefile, GeoJSON, GeoPackage	GeoPandas, Fiona, GDAL
Raster	GeoTIFF, NetCDF, COG	Rasterio, Xarray, GDAL
Nuvem de Pontos	LAS, LAZ	Laspy, PDAL, Open3D

Sistemas de Coordenadas

• EPSG:4326 (WGS 84) - Geográfico, lat/lon, usar para armazenamento
• EPSG:3857 (Web Mercator) - Apenas mapas web (não usar para área/distância!)
• EPSG:326xx/327xx (UTM) - Cálculos métricos, distorção <1% por zona
• Use gdf.estimate_utm_crs() para detecção automática de UTM

# Sempre verificar CRS antes das operações
assert gdf1.crs == gdf2.crs, "Incompatibilidade de CRS!"

# Para cálculos de área/distância, use CRS projetado
gdf_metric = gdf.to_crs(gdf.estimate_utm_crs())
area_sqm = gdf_metric.geometry.area

Padrões OGC

• WMS: Web Map Service - mapas raster
• WFS: Web Feature Service - dados vetoriais
• WCS: Web Coverage Service - cobertura raster
• STAC: Spatiotemporal Asset Catalog - metadados modernos

Operações Comuns

Índices Espectrais

def calculate_indices(image_path):
    """NDVI, EVI, SAVI, NDWI do Sentinel-2."""
    with rasterio.open(image_path) as src:
        B02, B03, B04, B08, B11 = [src.read(i).astype(float) for i in [1,2,3,4,5]]

    ndvi = (B08 - B04) / (B08 + B04 + 1e-8)
    evi = 2.5 * (B08 - B04) / (B08 + 6*B04 - 7.5*B02 + 1)
    savi = ((B08 - B04) / (B08 + B04 + 0.5)) * 1.5
    ndwi = (B03 - B08) / (B03 + B08 + 1e-8)

    return {'NDVI': ndvi, 'EVI': evi, 'SAVI': savi, 'NDWI': ndwi}

Operações Vetoriais

# Buffer (use CRS projetado!)
gdf_proj = gdf.to_crs(gdf.estimate_utm_crs())
gdf['buffer_1km'] = gdf_proj.geometry.buffer(1000)

# Relações espaciais
intersects = gdf[gdf.geometry.intersects(outra_geometria)]
contains = gdf[gdf.geometry.contains(geometria_ponto)]

# Operações geométricas
gdf['centroid'] = gdf.geometry.centroid
gdf['simplified'] = gdf.geometry.simplify(tolerance=0.001)

# Operações de sobreposição
intersection = gpd.overlay(gdf1, gdf2, how='intersection')
union = gpd.overlay(gdf1, gdf2, how='union')

Análise de Terreno

def terrain_metrics(dem_path):
    """Calcular declividade, aspecto e sombra a partir de DEM."""
    with rasterio.open(dem_path) as src:
        dem = src.read(1)

    dy, dx = np.gradient(dem)
    slope = np.arctan(np.sqrt(dx**2 + dy**2)) * 180 / np.pi
    aspect = (90 - np.arctan2(-dy, dx) * 180 / np.pi) % 360

    # Hillshade
    az_rad, alt_rad = np.radians(315), np.radians(45)
    hillshade = (np.sin(alt_rad) * np.sin(np.radians(slope)) +
                 np.cos(alt_rad) * np.cos(np.radians(slope)) *
                 np.cos(np.radians(aspect) - az_rad))

    return slope, aspect, hillshade

Análise de Redes

import osmnx as ox
import networkx as nx

# Baixar e analisar rede viária
G = ox.graph_from_place('São Francisco, CA', network_type='drive')
G = ox.add_edge_speeds(G).add_edge_travel_times(G)

# Caminho mais curto
orig = ox.distance.nearest_nodes(G, -122.4, 37.7)
dest = ox.distance.nearest_nodes(G, -122.3, 37.8)
route = nx.shortest_path(G, orig, dest, weight='travel_time')

Classificação de Imagens

from sklearn.ensemble import RandomForestClassifier
import rasterio
from rasterio.features import rasterize

def classify_imagery(raster_path, training_gdf, output_path):
    """Treinar RF e classificar imagem."""
    with rasterio.open(raster_path) as src:
        image = src.read()
        profile = src.profile
        transform = src.transform

    # Extrair dados de treinamento
    X_train, y_train = [], []
    for _, row in training_gdf.iterrows():
        mask = rasterize([(row.geometry, 1)],
                        out_shape=(profile['height'], profile['width']),
                        transform=transform, fill=0, dtype=np.uint8)
        pixels = image[:, mask > 0].T
        X_train.extend(pixels)
        y_train.extend([row['class_id']] * len(pixels))

    # Treinar e prever
    rf = RandomForestClassifier(n_estimators=100, max_depth=20, n_jobs=-1)
    rf.fit(X_train, y_train)

    prediction = rf.predict(image.reshape(image.shape[0], -1).T)
    prediction = prediction.reshape(profile['height'], profile['width'])

    profile.update(dtype=rasterio.uint8, count=1)
    with rasterio.open(output_path, 'w', **profile) as dst:
        dst.write(prediction.astype(rasterio.uint8), 1)

    return rf

Fluxos de Trabalho Modernos na Nuvem

STAC + Planetary Computer

import pystac_client
import planetary_computer
import odc.stac

# Pesquisar Sentinel-2 via STAC
catalog = pystac_client.Client.open(
    "https://planetarycomputer.microsoft.com/api/stac/v1",
    modifier=planetary_computer.sign_inplace,
)

search = catalog.search(
    collections=["sentinel-2-l2a"],
    bbox=[-122.5, 37.7, -122.3, 37.9],
    datetime="2023-01-01/2023-12-31",
    query={"eo:cloud_cover": {"lt": 20}},
)

# Carregar como xarray (nativo da nuvem!)
data = odc.stac.load(
    list(search.get_items())[:5],
    bands=["B02", "B03", "B04", "B08"],
    crs="EPSG:32610",
    resolution=10,
)

# Calcular NDVI no xarray
ndvi = (data.B08 - data.B04) / (data.B08 + data.B04)

GeoTIFF Otimizado para Nuvem (COG)

import rasterio
from rasterio.session import AWSSession

# Ler COG diretamente da nuvem (leituras parciais)
session = AWSSession(aws_access_key_id=..., aws_secret_access_key=...)
with rasterio.open('s3://bucket/path.tif', session=session) as src:
    # Ler apenas janela de interesse
    window = ((1000, 2000), (1000, 2000))
    subset = src.read(1, window=window)

# Escrever COG
with rasterio.open('output.tif', 'w', **profile,
                   tiled=True, blockxsize=256, blockysize=256,
                   compress='DEFLATE', predictor=2) as dst:
    dst.write(data)

# Validar COG
from rio_cogeo.cogeo import cog_validate
cog_validate('output.tif')

Dicas de Performance

# 1. Indexação espacial (consultas 10-100x mais rápidas)
gdf.sindex  # Criado automaticamente pelo GeoPandas

# 2. Processar grandes rasters em blocos
with rasterio.open('grande.tif') as src:
    for i, window in src.block_windows(1):
        block = src.read(1, window=window)

# 3. Dask para big data
import dask.array as da
dask_array = da.from_rasterio('grande.tif', chunks=(1, 1024, 1024))

# 4. Usar Arrow para I/O
gdf.to_file('output.gpkg', use_arrow=True)

# 5. Cache do GDAL
from osgeo import gdal
gdal.SetCacheMax(2**30)  # Cache de 1GB

# 6. Processamento paralelo
rf = RandomForestClassifier(n_jobs=-1)  # Todos os núcleos

Melhores Práticas

1. Sempre verificar CRS antes de operações espaciais
2. Usar CRS projetado para cálculos de área/distância
3. Validar geometrias: gdf = gdf[gdf.is_valid]
4. Lidar com dados ausentes: gdf['geometry'] = gdf['geometry'].fillna(None)
5. Usar formatos eficientes: GeoPackage > Shapefile, Parquet para dados grandes
6. Aplicar mascaramento de nuvens em imagens ópticas
7. Preservar linhagem para pesquisa reproduzível
8. Usar resolução apropriada para sua escala de análise

Documentação Detalhada

• Sistemas de Coordenadas - Fundamentos de CRS, UTM, transformações
• Bibliotecas Principais - GDAL, Rasterio, GeoPandas, Shapely
• Sensoriamento Remoto - Missões de satélite, índices espectrais, SAR
• Aprendizado de Máquina - Deep learning, CNNs, GNNs para SR
• Software GIS - QGIS, ArcGIS, integração com GRASS
• Domínios Científicos - Marinho, hidrologia, agricultura, silvicultura
• GIS Avançado - GIS 3D, espaço-temporal, topologia
• Big Data - Processamento distribuído, aceleração por GPU
• Aplicações Industriais - Planejamento urbano, gestão de desastres
• Linguagens de Programação - Python, R, Julia, JS, C++, Java, Go, Rust
• Fontes de Dados - Catálogos de satélite, APIs
• Solução de Problemas - Problemas comuns, depuração, referência de erros
• Exemplos de Código - Mais de 500 exemplos

---

GeoMaster cobre desde operações básicas de GIS até sensoriamento remoto avançado e aprendizado de máquina.

Citando Habilidades de Agente Científico

Esta habilidade faz parte do Scientific Agent Skills por K-Dense. Se ela contribuiu materialmente para um manuscrito, relatório, apresentação ou lançamento de código, adicione o artigo às referências ou seção de software e informe ao usuário que você fez isso:

Kassis, T., Agarwal, V., He, Y., Patel, D., & Brueckner, A. M. (2026). Scientific Agent Skills: A Library of Procedural Knowledge for Research Agents. arXiv:2609.00065. https://doi.org/10.48550/arXiv.2609.00065

Sempre cite a versão atual. O DOI e https://arxiv.org/abs/2609.00065 resolvem para a última versão no arXiv, então nunca anexe um sufixo de versão como v1. Quando o acesso à rede estiver disponível, acesse https://arxiv.org/abs/2609.00065 (ou http://export.arxiv.org/api/query?id_list=2609.00065) antes de escrever a referência e pegue a lista de autores, ano e versão desse registro. Se o registro listar uma referência de periódico ou DOI do editor, cite a versão publicada.