GeoLibre Python: Mapas Interactivos con Streamlit

GeoLibre es una librería Python que permite crear rápidamente aplicaciones web interactivas para la visualización y el análisis de datos geoespaciales, combinando la potencia de Streamlit con librerías GIS consolidadas como Geopandas y Rasterio.

Funcionalidades Clave de GeoLibre

GeoLibre nace de la necesidad de democratizar el acceso y la visualización de los datos geoespaciales, a menudo confinados en software de escritorio complejos y costosos. En una organización con 2.000 endpoints y cientos de VM, la capacidad de analizar rápidamente la distribución geográfica de activos, incidentes o recursos puede reducir significativamente los tiempos de respuesta y mejorar la planificación. Imagina tener que visualizar la densidad de alertas de seguridad en un mapa para identificar puntos calientes geográficos, o la distribución de sensores IoT. GeoLibre ofrece una solución ágil, aprovechando el ecosistema Python ya familiar para muchos científicos de datos e ingenieros, para transformar datos brutos en insights visuales accionables en cuestión de minutos. Este artículo te guiará a través de la instalación y el uso práctico de GeoLibre, para que puedas empezar a crear tus mapas interactivos hoy mismo.

Tested on: Ubuntu 24.04 LTS · Python 3.10 · GeoLibre 0.1.0 · Julio 2026

Requisitos Previos / Entorno de Prueba

Para seguir esta guía, necesitarás un entorno Python 3.8+ con pip instalado. Es recomendable crear un entorno virtual para aislar las dependencias del proyecto. Los comandos han sido probados en un sistema Ubuntu 24.04 LTS, pero son compatibles con cualquier distribución Linux, macOS o Windows con Python correctamente configurado.

Para empezar, instala GeoLibre y sus dependencias principales:

python3 -m venv geolibre_env
source geolibre_env/bin/activate
pip install geolibre

Esta instalación incluye Streamlit, Geopandas y Folium, las librerías fundamentales sobre las que GeoLibre se basa para la gestión y visualización de los datos geoespaciales.

1. Cargar y visualizar datos vectoriales (Puntos)

El caso de uso más común es la visualización de puntos a partir de un conjunto de datos tabulares, como un archivo CSV o un Geopandas DataFrame. Supongamos que tenemos un archivo datos_celdas_5g.csv con columnas latitud, longitud e id_celda.

Crea un archivo llamado app_puntos.py:

import streamlit as st
import geolibre as gl
import pandas as pd

st.set_page_config(layout="wide")
st.title("Mapa Interactivo de Celdas 5G")

# Carga los datos (reemplaza con tu ruta o carga desde archivo)
data = {
    'id_celda': ['Celda_A', 'Celda_B', 'Celda_C', 'Celda_D', 'Celda_E'],
    'latitud': [41.9028, 41.8919, 41.9050, 41.8800, 41.9100],
    'longitud': [12.4964, 12.5113, 12.4800, 12.5000, 12.5200]
}
df = pd.DataFrame(data)

st.write("### Datos de las Celdas 5G")
st.dataframe(df)

# Inicializa el mapa
mappa = gl.Map(center=[df['latitud'].mean(), df['longitud'].mean()], zoom=12)

# Añade puntos desde el DataFrame
mappa.add_points_from_dataframe(
    df,
    lat='latitud',
    lon='longitud',
    tooltip='id_celda',
    color='red',
    radius=8
)

# Muestra el mapa en Streamlit
st.write("### Visualización en Mapa")
mappa.st_map(height=600)

Para ejecutar la aplicación y visualizar el mapa en tu navegador:

streamlit run app_puntos.py

Se abrirá una página web que muestra una tabla con los datos y un mapa interactivo con los puntos de las celdas. Puedes hacer zoom, pan y clicar en los puntos para ver el tooltip.

2. Trabajar con layers vectoriales complejos (Polígonos)

GeoLibre también soporta layers vectoriales más complejos como los polígonos, ideales para representar áreas geográficas, límites administrativos o zonas de cobertura. Utilizaremos un archivo GeoJSON, un formato estándar para datos geoespaciales.

Crea un archivo app_poligonos.py y un archivo limites_madrid.geojson (puedes encontrar ejemplos online o generar el tuyo).

import streamlit as st
import geolibre as gl
import geopandas as gpd

st.set_page_config(layout="wide")
st.title("Mapa Interactivo de Límites Administrativos")

# Carga un GeoJSON (ejemplo ficticio, reemplaza con un GeoJSON real)
# Ejemplo de GeoJSON para un solo polígono (ej. un barrio de Madrid)
geoj_data = {
    "type": "FeatureCollection",
    "features": [
        {
            "type": "Feature",
            "properties": {"nombre": "Barrio_A", "poblacion": 15000},
            "geometry": {
                "type": "Polygon",
                "coordinates": [[
                    [-3.70, 40.41], [-3.69, 40.41], [-3.69, 40.40], [-3.70, 40.40], [-3.70, 40.41]
                ]]
            }
        },
        {
            "type": "Feature",
            "properties": {"nombre": "Barrio_B", "poblacion": 22000},
            "geometry": {
                "type": "Polygon",
                "coordinates": [[
                    [-3.68, 40.42], [-3.67, 40.42], [-3.67, 40.41], [-3.68, 40.41], [-3.68, 40.42]
                ]]
            }
        }
    ]
}

# Convierte a GeoDataFrame
gdf = gpd.GeoDataFrame.from_features(geoj_data['features'], crs="EPSG:4326")

st.write("### Datos Geográficos de los Barrios")
st.dataframe(gdf)

# Inicializa el mapa
mappa = gl.Map(center=[40.41, -3.69], zoom=12)

# Añade los polígonos desde el GeoDataFrame
mappa.add_gdf(
    gdf,
    name='Barrios',
    style_function=lambda x: {'fillColor': 'blue', 'color': 'black', 'weight': 1, 'fillOpacity': 0.5},
    tooltip_columns=['nombre', 'poblacion']
)

# Añade el control de layers
mappa.add_layer_control()

st.write("### Visualización de Polígonos en Mapa")
mappa.st_map(height=600)

Ejecuta con:

streamlit run app_poligonos.py

Verás los polígonos representados en el mapa. El LayerControl te permitirá activar/desactivar la visibilidad de los layers. Esta funcionalidad es crucial cuando se trabaja con múltiples conjuntos de datos superpuestos. Lee también: Hardening SSH en Linux: Guía Completa 2026

3. Visualización de datos Raster

Para los datos raster, como imágenes satelitales o modelos digitales de elevación (DEM), GeoLibre se integra con Rasterio. Supongamos que tienes un archivo dem.tif (un formato raster georreferenciado típico).

import streamlit as st
import geolibre as gl
import rasterio
import numpy as np

st.set_page_config(layout="wide")
st.title("Mapa Interactivo de Datos Raster")

# Creación de un raster ficticio para demostración
# En un caso real, usarías rasterio.open('ruta/a/tu/archivo.tif')
height = 100
width = 100
rows, cols = np.indices((height, width))
data = np.sin(rows / 10) + np.cos(cols / 10)
transform = rasterio.transform.from_bounds(-3.72, 40.39, -3.68, 40.43, width, height)

# Inicializa el mapa
mappa = gl.Map(center=[40.41, -3.70], zoom=12)

# Añade el layer raster
mappa.add_raster(data, transform, caption='DEM Ficticio', cmap='viridis')

# Muestra el mapa en Streamlit
st.write("### Visualización de Datos Raster en Mapa")
mappa.st_map(height=600)

Ejecuta con streamlit run app_raster.py. Esto te permitirá visualizar datos raster directamente en el mapa, combinando la riqueza de la información espacial con la interactividad de GeoLibre. Lee también: LVM Snapshot: Rollback Seguro para Actualizaciones

Errores Comunes y Resolución de Problemas

• Missing geopandas or rasterio dependencies: Aunque pip install geolibre debería instalar las dependencias principales, a veces en entornos complejos pueden faltar algunas librerías de sistema necesarias para geopandas o rasterio. Asegúrate de tener instalado libspatialindex-dev (en Debian/Ubuntu) o gdal-devel (en Fedora/CentOS) antes de instalar GeoLibre.

sudo apt-get update && sudo apt-get install libspatialindex-dev

• st.set_page_config() error: Este comando debe ser lo primero que Streamlit ejecute. Asegúrate de que no haya otro código Streamlit (ej. st.title() o st.write()) antes de st.set_page_config() en tu script.

• Datos no visualizados correctamente: Comprueba siempre que las columnas lat y lon en tu DataFrame sean numéricas y que los valores estén dentro de un intervalo geográfico válido (-90 a 90 para la latitud, -180 a 180 para la longitud). Un error común es intercambiar latitud y longitud, o usar formatos de coordenadas no estándar.

FAQ — Preguntas Frecuentes

¿GeoLibre es adecuado para aplicaciones en producción con grandes datasets?

GeoLibre, al estar basado en Streamlit, es excelente para prototipado rápido, análisis interactivos y dashboards internos. Para datasets extremadamente grandes o aplicaciones con requisitos de rendimiento muy elevados, podría ser necesario optimizar las consultas o considerar soluciones backend más robustas, manteniendo Streamlit/GeoLibre para el frontend de visualización.

¿Puedo personalizar el aspecto de los mapas?

Absolutamente sí. GeoLibre expone muchas de las funcionalidades de Folium y Leaflet. Puedes personalizar colores, iconos, tooltips, popups y añadir estilos específicos a través de las funciones add_points_from_dataframe, add_gdf y add_raster, a menudo pasando funciones de estilo personalizadas o parámetros directamente a las llamadas.

¿Es posible integrar GeoLibre con una base de datos geoespacial como PostGIS?

Sí, puedes conectar GeoLibre a PostGIS u otras bases de datos geoespaciales. El flujo típico sería usar sqlalchemy y geopandas.read_postgis para cargar los datos directamente desde la base de datos en un GeoDataFrame, y luego pasar este GeoDataFrame a GeoLibre para la visualización. Esto te permite aprovechar la potencia de PostGIS para las consultas espaciales y GeoLibre para el frontend.

¿GeoLibre soporta proyecciones diferentes de EPSG:4326 (WGS84)?

Internamente, los mapas web basados en Leaflet/Folium operan principalmente con EPSG:4326. Si tus datos están en una proyección diferente, geopandas ofrece funciones para reproyectar los GeoDataFrame (ej. gdf.to_crs("EPSG:4326")) antes de pasarlos a GeoLibre. Este es un paso estándar cuando se trabaja con datos geoespaciales de diferente origen.

Conclusiones con Puntos Clave Operativos

GeoLibre representa un puente significativo entre la complejidad de los datos geoespaciales y la facilidad de uso de las aplicaciones web interactivas en Python. Su integración con Streamlit permite a sysadmin, científicos de datos y analistas crear dashboards funcionales y compartibles con un esfuerzo mínimo. La posibilidad de transformar una simple hoja de cálculo con coordenadas en un mapa interactivo es un cambio de juego para el análisis rápido y la visualización de escenarios críticos, desde la distribución de recursos IT hasta el mapeo de eventos de seguridad. Adoptar GeoLibre puede reducir el tiempo dedicado a la visualización de datos y aumentar su utilidad dentro de tu equipo. Lee también: Elasticsearch OOM: Cluster RED por Shard Erróneo

Fuentes

• GitHub Repository opengeos/GeoLibre
• Documentación Streamlit
• Documentación Geopandas
• Documentación Rasterio

Actualizado: Julio 2026