Uma parte considerável dos dados gerados todos os dias é, por natureza, espacial. De dados de observação da Terra e GPS a informações presentes em todo tipo de mapa, dados espaciais –também chamados de dados geoespaciais ou informações geográficas– são aqueles em que cada registro está associado a uma localização específica.
Todo ponto de dado espacial pode ser localizado em um mapa. Isso é feito usando um sistema de referência de coordenadas, por exemplo, coordenadas geográficas, baseadas nos pares latitude-longitude que usamos para indicar onde algo está no globo. Isso nos permite analisar relações espaciais entre os dados.
Mas o verdadeiro poder dos dados geoespaciais está em combinar os próprios dados com sua localização, abrindo várias oportunidades para análises avançadas. A chamada ciência de dados geoespacial é um subcampo da ciência de dados que foca em extrair informação de dados geoespaciais aproveitando o poder de algoritmos espaciais e técnicas analíticas, como machine learning e deep learning. Em outras palavras, a ciência de dados geoespacial ajuda você a entender onde as coisas acontecem e por que acontecem ali.
Há muitas ferramentas adequadas para ciência de dados geoespacial. Este tutorial vai focar no GeoPandas, um pacote open source para trabalhar com dados geoespaciais em Python.
O GeoPandas estende os tipos de dados usados pelo pandas – a ferramenta padrão para manipulação de dataframes em Python – para permitir operações espaciais em tipos geométricos. Como o GeoPandas é construído sobre o pandas – e também sobre outros pacotes populares de ciência de dados em Python, como o matplotlib –, é muito fácil para profissionais que usam Python se familiarizarem com a sintaxe do GeoPandas.
Instalando o GeoPandas no Python
Para usar o GeoPandas no Python, primeiro você precisa instalá-lo, como qualquer outra biblioteca.
É importante notar que o GeoPandas depende de um conjunto de bibliotecas geoespaciais open source para entregar todo o seu potencial espacial, incluindo shapely, fiona, pyproj e rtree. Você precisa garantir a instalação de todas essas dependências; caso contrário, o GeoPandas pode não funcionar como esperado.
Para evitar complexidade, o GeoPandas recomenda instalar a biblioteca usando o gerenciador de pacotes conda. Isso significa que você precisa instalar o Anaconda antes. Para um guia sobre como instalar e usar o Anaconda, confira nosso tutorial.
A vantagem de usar o conda é que ele oferece binários pré-compilados para todas as dependências obrigatórias e opcionais do GeoPandas em todos os sistemas operacionais (Windows, Mac, Linux). Para instalar o GeoPandas na linha de comando:
>>conda install geopandasComo alternativa, você pode instalar o GeoPandas usando o pip, o instalador padrão de pacotes do Python. Como já mencionado, será necessário instalar também as dependências exigidas. Se você não está familiarizado com o pip, recomendamos muito a leitura do nosso tutorial de pip para gerenciamento de pacotes. O comando para instalar o GeoPandas com pip é:
>>pip install geopandas Em qualquer caso, se você tiver problemas durante a instalação do GeoPandas, consulte a documentação para mais informações.
Depois de instalar o pacote, você já pode começar a usar o GeoPandas. Basta importá-lo no seu ambiente Python. Observe que é muito comum importar o GeoPandas com o alias gpd.
import geopandas as gpdOperações básicas com GeoPandas
Nesta seção, vamos cobrir as operações mais básicas que você pode fazer com o GeoPandas. Com isso, vamos apresentar alguns conceitos essenciais de análise geoespacial, incluindo tipos de dados espaciais, formatos de dados espaciais e sistemas de referência de coordenadas (CRS).
Lendo e escrevendo dados espaciais
Da mesma forma que o pandas precisa de dados de entrada para converter em um dataframe, o GeoPandas lê dados (espaciais) de entrada e os converte no chamado GeoDataFrame.
Antes de entrar nos vários tipos de arquivo espacial que o GeoPandas pode ler, é importante diferenciar os tipos de dados espaciais. O tipo de dado com que estamos lidando indica quais ferramentas devemos usar para analisar e depois visualizar os dados.
Basicamente, existem dois tipos principais de dados espaciais:
- Dados vetoriais. Descrevem características de locais geográficos na Terra por meio de geometrias discretas, a saber:
- Ponto. Localizações individuais, como um prédio ou um carro, com coordenadas X e Y.
- Linha. Uma série de pontos conectados descrevendo coisas como ruas ou rios.
- Polígono. Formado por uma linha fechada que envolve uma área, como os limites de um país. Além disso, quando uma feição é composta por múltiplas geometrias, chamamos de MultiPolygon.
- Dados raster. Codificam o mundo como uma superfície contínua representada por uma grade, como os pixels de uma imagem. Cada célula da grade pode ter um valor contínuo (como altitude) ou uma classificação categórica (como classes de uso do solo). Exemplos clássicos incluem dados de elevação ou imagens de satélite.
Fonte: Humboldt State University
Tanto dados vetoriais quanto raster geralmente vêm acompanhados de dados não espaciais, também chamados de atributos. Dados espaciais podem ter qualquer número de atributos adicionais além da informação de localização. Por exemplo, a localização de uma escola pode estar associada ao nome da escola, ao número de alunos ou ao endereço.
O GeoPandas foi projetado para trabalhar com dados vetoriais, embora possa se integrar facilmente a outros pacotes Python para lidar com dados raster, como o rasterio. Para ler dados espaciais, o GeoPandas oferece a função geopandas.read_file(). Essa função poderosa consegue ler automaticamente a maioria dos formatos vetoriais mais comuns.
Alguns dos formatos de dados vetoriais mais usados são:
- Shapefile. Por ser o padrão da indústria, shapefiles são o formato vetorial mais comum. Ele é composto por três arquivos que geralmente são fornecidos em um arquivo zip:
- O arquivo .shp contém a geometria.
- O arquivo .dbf guarda os atributos de cada geometria,
- O arquivo .shx, ou índice de formas, ajuda a vincular atributos às geometrias.
- GeoJSON. É um formato mais recente para dados geoespaciais, lançado em 2016. Diferente dos shapefiles, o GeoJSON é um único arquivo, o que facilita o trabalho.
Nos exemplos a seguir, vamos usar a função geopandas.read_file() para ler um arquivo GeoJSON hospedado no GitHub contendo dados geoespaciais dos diferentes distritos da cidade de Barcelona.
url = 'https://raw.githubusercontent.com/jcanalesluna/bcn-geodata/master/districtes/districtes.geojson'
districts = gpd.read_file(url)
districts
Voltaremos a este dataset em instantes, mas antes é importante saber como salvar um GeoDataFrame em arquivo. É bem simples. Basta usar GeoDataFrame.to_file() para criar um arquivo contendo os dados espaciais. Por padrão, o formato do novo documento será shapefile, mas você pode alterar usando o parâmetro “driver”.
Por exemplo, você pode salvar o GeoDataFrame de distritos em um arquivo GeoJSON:
districts.to_file("districts.geojson", driver="GeoJSON")Explorando GeoDataFrames
Você deve ter notado que o GeoDataFrame na seção anterior se parece com um dataframe do pandas tradicional. A semelhança faz sentido, já que GeoDataFrame é uma subclasse de pandas.DataFrame. Isso significa que ele herda muitos dos métodos e atributos do dataframe do pandas. A novidade no GeoDataFrame é que ele pode armazenar colunas de geometria (também chamadas de GeoSeries) e realizar operações espaciais.
A coluna de geometria pode conter qualquer tipo de dado vetorial, como pontos, linhas e polígonos. Além disso, é importante notar que, embora um GeoDataFrame possa ter várias GeoSeries, apenas uma coluna é considerada a geometria ativa, ou seja, todas as operações espaciais serão baseadas nessa coluna.
Fonte: GeoPandas
Outro recurso importante dos GeoDataFrames é que cada GeoSeries vem com informações de CRS associadas. Essas informações de CRS dizem ao GeoPandas onde as coordenadas estão na Terra. Isso é fundamental para a análise espacial. Por exemplo, se você precisa combinar dois datasets espaciais, é preciso garantir que ambos estejam no mesmo CRS. Caso contrário, o resultado não será o esperado.
Existem duas categorias principais de CRS:
- Coordenadas geográficas. Definem uma posição global em graus de latitude e longitude em relação ao equador e ao meridiano de Greenwich. Com esse sistema, podemos especificar facilmente qualquer localização no planeta. É amplamente usado, por exemplo, em GPS. O CRS mais popular é o EPSG:4326, também chamado de WGS84.
- Coordenadas projetadas. Embora a Terra seja esférica, geralmente a representamos em um mapa bidimensional. Coordenadas projetadas expressam localizações nas dimensões X e Y, permitindo trabalhar com uma unidade de comprimento, como metros, em vez de graus, o que torna a análise mais prática e eficiente. No entanto, transformar a Terra tridimensional em um mapa bidimensional inevitavelmente gera distorções. Por isso existem diferentes abordagens para criar coordenadas projetadas. Por exemplo, muitos países adotaram um CRS projetado padrão para sua geografia específica.
Há muito mais sobre CRS, mas isso foge ao escopo deste tutorial. Um ótimo recurso com informações adicionais e exemplos práticos é nosso curso Working with Geospatial Data in Python.
No GeoPandas, as informações de CRS ficam armazenadas no atributo crs:
districts.crs
O GeoDataFrame de distritos está associado a coordenadas geográficas (EPSG: 4326), mas queremos transformá-lo em coordenadas projetadas para fazermos alguns cálculos em metros. Vamos transformá-lo para EPSG:2062, o CRS projetado padrão da Espanha. Podemos fazer isso com o método Geopandas.to_crs().
districts.to_crs(epsg=2062, inplace=True)
districts.crs
Agora que definimos o CRS projetado correto, estamos prontos para explorar os atributos dos GeoDataFrames.
Explorando os atributos de um conjunto de dados espacial
O GeoPandas herda vários métodos e atributos úteis do pacote shapely. Vamos cobrir quatro deles.
Area
O atributo area retorna a área calculada de uma geometria. Podemos salvar a área resultante (convertida para km²) em uma nova coluna:
districts['area'] = districts.area / 1000000
districts
Centroid
O atributo centroid retorna o ponto central de uma geometria. Podemos adicioná-lo ao nosso dataset, criando assim uma nova coluna de geometria.
districts['centroid']=districts.centroid
districts
Boundary
O atributo boundary retorna o contorno de um polígono.
districts['boundary']=districts.boundaryDistance
O método distance fornece a distância mínima de uma geometria até um local. Digamos que queremos calcular a distância da famosa igreja Sagrada Família, localizada no distrito do Eixample, até os centróides de todos os distritos de Barcelona, e depois adicionar as distâncias (em quilômetros) em uma nova coluna.
A Sagrada Família. Fonte: Wikipedia
Primeiro, precisamos criar um ponto usando a função Point() do shapely com as coordenadas desejadas (você as encontra facilmente no Google Maps), convertê-lo em uma GeoSeries com o CRS correto e então usar o método GeoPandas.distance():
from shapely.geometry import Point
sagrada_fam = Point(2.1743680500855005, 41.403656946781304)
sagrada_fam = gpd.GeoSeries(sagrada_fam, crs=4326)
sagrada_fam= sagrada_fam.to_crs(epsg=2062)
districts['sagrada_fam_dist'] = [float(sagrada_fam.distance(centroid)) / 1000 for centroid in districts.centroid]O dataset resultante, após as operações espaciais anteriores, fica assim:
Plotando com GeoPandas
As operações espaciais que fizemos trazem insights valiosos para nosso estudo. No entanto, visualizar suas geometrias no espaço é uma ótima forma de enriquecer a análise. Felizmente, criar um gráfico com GeoPandas é super fácil. Basta chamar a função GeoDataFrame.plot(), construída sobre o matplotlib do Python.
Vamos começar com uma visualização básica dos distritos de Barcelona.
ax= districts.plot(figsize=(10,6))
Podemos deixar nosso gráfico do GeoPandas mais informativo colorindo cada distrito. Definir a legenda como 'True' cria uma legenda para ajudar a interpretar as cores.
ax= districts.plot(column=district_name', figsize=(10,6), edgecolor='black', legend=True)
Por fim, podemos adicionar os centróides dos distritos e a Sagrada Família ao nosso mapa, além de um título. Para deixar o gráfico mais atraente, podemos usar o ótimo pacote contextily para adicionar um mapa de base da própria cidade de Barcelona.
import contextily
ax= districts.plot(column='district_name', figsize=(12,6), alpha=0.5, legend=True)
districts["centroid"].plot(ax=ax, color="green")
sagrada_fam.plot(ax=ax,color='black', marker='+')
contextily.add_basemap(ax, crs=districts.crs.to_string())
plt.title('A Beautiful Map of Barcelona')
plt.axis('off')
plt.show()
Legal, né? Dá para fazer muito mais para criar visualizações espaciais incríveis. Nosso curso Visualizing Spatial Data With Python é um ótimo recurso para levar suas habilidades de visualização para o próximo nível.
Relações espaciais com GeoPandas
Um dos pontos-chave dos dados geoespaciais é como eles se relacionam no espaço. O GeoPandas aproveita o poder dos pacotes pandas e shapely para executar todo tipo de relação espacial entre conjuntos de dados. Nesta seção, vamos abordar algumas das operações mais comuns.
Junções por atributo
Existem duas maneiras de combinar datasets no pandas: junções por atributo e junções espaciais.
As junções por atributo permitem unir dois GeoDataFrames com base em variáveis não geométricas, como em um join comum no pandas. Na prática, a forma de realizar junções por atributo é com o método padrão pandas.merge(). Se você quiser saber mais sobre joins no pandas, confira nosso tutorial de junção de DataFrames no pandas.
Por exemplo, seria interessante enriquecer nosso GeoDataFrame com os dados de população de Barcelona em 2022.
pop =pd.read_csv('poblacion_barna_2022.csv', usecols=['Nom_Districte','Nombre'])
pop = pd.DataFrame(pop.groupby('Nom_Districte')['Nombre'].sum()).reset_index()
pop.columns=['district_name','population_22']
districts = districts.merge(pop)
districtsv
Junções espaciais
Já as junções espaciais permitem unir dois GeoDataFrames com base em seus relacionamentos espaciais.
Por exemplo, vamos identificar em quais distritos estão localizadas as ciclovias de Barcelona.
url = 'https://opendata-ajuntament.barcelona.cat/resources/bcn/CarrilsBici/CARRIL_BICI.geojson'
bike_lane = gpd.read_file(url)
bike_lane = bike_lane.loc[:,['ID','geometry']]
bike_lane.to_crs(epsg=2062, inplace=True)
No GeoPandas, a operação de junção espacial está disponível como a função sjoin(). O primeiro argumento é o GeoDataFrame ao qual queremos adicionar informação, e o segundo é o GeoDataFrame que contém a informação que será adicionada. Depois, precisamos especificar o tipo de join. Por fim, o parâmetro “predicate” diz ao GeoPandas qual relação espacial usar para combinar os dois datasets. Alguns dos relacionamentos mais comuns são “intersects”, “contains” e “within”.
No nosso exemplo, vamos usar o predicado “intersects”. Dois objetos geométricos se intersectam se tiverem qualquer ponto de contorno ou interior em comum.
lanes_districts = gpd.sjoin(districts, bike_lane, how='inner', predicate='intersects')
lanes_districts
Perceba que o GeoDataFrame resultante tem mais linhas do que o GeoDataFrame bike_lane. Isso porque uma ciclovia pode estar localizada em mais de um distrito.
Por fim, podemos agrupar nosso dataset para obter o número de ciclovias por distrito:
lanes_districts.groupby('district_name').size()
Operações de overlay no GeoPandas
Por fim, overlays espaciais permitem comparar dois GeoDataFrames com geometrias de polígono ou multipolígono e criar um novo GeoDataFrame com as novas geometrias que representam a combinação espacial e as propriedades mescladas. A imagem abaixo mostra as diferentes possibilidades:
Fonte: GeoPandas
Imagine que a prefeitura de Barcelona quer construir novos parques locais para combater a poluição e promover o bem-estar da comunidade. Uma ideia preliminar é criar parques grandes e circulares a 500 metros do centro de cada distrito. Podemos simular isso criando um buffer com base no centróide de cada distrito.
parks = gpd.GeoDataFrame(districts.centroid.buffer(500), geometry=0)
parks.plot()
Agora estamos prontos para realizar algumas operações de overlay. Por exemplo, se quisermos ver apenas as áreas dos distritos onde os parques ficariam, podemos usar o método GeoPandas.overlay():
parks_intersection = districts.overlay(parks, how='intersection')
ax = parks_intersection.plot(alpha=0.5, edgecolor='black', column='district_name')
Ou, se quisermos ver os distritos sem a área ocupada pelos parques projetados, podemos alterar o parâmetro “how” para executar outra operação de overlay.
parks_difference = districts.overlay(parks, how='difference')
ax = parks_difference.plot(alpha=0.5, edgecolor='black', column='district_name')
Conclusão
Esperamos que você tenha gostado deste tutorial de GeoPandas. A análise espacial é uma das áreas mais fascinantes da ciência de dados, oferecendo infinitas oportunidades para enriquecer sua análise com informações baseadas em localização. Existem muitas ferramentas para análise espacial, mas se você já está familiarizado com Python, o GeoPandas é um ótimo ponto de partida.
Quer continuar sua formação em geoespacial? A gente te ajuda! Confira os materiais abaixo e torne-se um mestre em geoespacial:
