Creación de mapas con Mapbox y R

Ya hemos visto en numerosas ocasiones la estrecha relación entre R y los SIG y las grandes posibilidades de este lenguaje de programación, que cada día avanza más posiciones entre los principales lenguajes de tratamiento de datos espaciales. En este artículo, os mostramos otra forma de crear y gestionar mapas web: mediante la librería mapboxer, este paquete se nos brinda la posibilidad de fusionar Mapbox y R.

Esta fusión nos permite publicar nuestros datos geográficos utilizados en R en:

• Un visor web.
• En la consola de R.
• Incrustados en documentos R Markdown.
• En aplicaciones Shiny.

Estructura de datos en mapboxer

De manera muy resumida, en el paquete mapboxer nos encontramos con los siguientes elementos que nos permitirán generar un mapa web interactivo:

• Mapa: componente principal de visualización al que luego se le debe agregar otros componentes como capas, controles o fuentes. La función para generar mapas es mapboxer().
  
• Fuentes: datos que van a mostrarse en el mapa. Podemos convertir datos R a fuentes que entienda la librería mapboxer con la función as_mapbox_source() o utilizar directamente el argumento add_source() dentro de la función mapboxer().
  
• Capas: el estilo de una capa define cómo se muestra una fuente en el mapa. La función para añadir capas es add_layer().
  

Además, podemos aumentar la funcionalidad con:

• Controles: permiten añadir herramientas para interactuar con el mapa. Un ejemplo muy común son los controles de navegación como el zoom o la rotación.
  
• Expresiones: nos permiten diseñar estilos basados en datos o filtrar nuestros datos.
• Funciones de exportación: nos permiten extraer los mapas interactivos generados e incrustarlos en aplicaciones R Markdown, en aplicaciones Shiny o en nuestras propias aplicaciones. 
  

Creación de un mapa con Mapbox y R

El primer paso para adentrarnos en el mundo de Mapbox y R es instalar y cargar el paquete mapboxer (con R y RStudio previamente instalados):

# Instalamos y cargamos Mapboxer 
install.packages("mapboxer") 
library(mapboxer)

mapboxer() es la función que nos permite generar un objeto de tipo mapa. A continuación, se muestra una porción de código dónde hemos generado un mapa muy sencillo, con centro en la ciudad de Logroño:

## Generación de un mapa básico con zoom, centro y mapa base
mapa1 <- mapboxer(
  center = c(-2.449, 42.4658),
  style = basemaps$Carto$positron,
  zoom = 9
)
mapa1

A esta función le hemos pasado los siguientes argumentos:

• center: vector con las coordinadas Longitud y Latitud del punto en el que deseamos centrar el mapa.
• style: nos permite definir el mapa base. Si no se pasa ninguno, mapboxer utiliza el mapa Dark Matter de Carto por defecto. Nosotro, en el código anterior, hemos empleado el mapa positron de Carto. El argumento style también permite asignar como mapa base mosaicos ráster, colores de fondo o estilos de Mapbox. Si nos decantamos por esta última opción, será necesario almacenar el token de API en una variable de entorno denominada MAPBOX_API_TOKEN.
• zoom: nivel de zoom inicial del mapa.

Además de los argumentos anteriores, la función mapboxer() contiene muchos otros. Con ellos, podemos emplear métodos y propiedades para cambiar el mapa mediante programación y que se desencadenen eventos a medida que un usuario interactúe con él.  Pueden consultarse aquí.

Adicción de fuentes y capas al mapa

Las fuentes son los datos que queremos que se vean en nuestro mapa. Para añadir una fuente al mapa, la debemos vincular con una capa en la que configuremos el estilo de dicha fuente. Para entenderlo mejor, vamos a generar un nuevo mapa que contenga los parques de bomberos de la Comunidad Autónoma de La Rioja.

• Estos parques los hemos obtenido del fichero emergencias_parques_bomberos.json que puede descargarse de la Base de Datos Geográfica del Gobierno de La Rioja.

emergencias_parques_bomberos.json es nuestra fuente de datos original. Cuando plasmemos esta información en el mapa podemos diseñar los parques con distintos colores y grosores. Esa configuración de nuestra fuente se almacena en un objeto al que denominamos capa. Podemos tener diversas capas de una única fuente. Es decir, podemos disponer de una capa donde los parques de bomberos sean rojos, otra capa en la que sean verdes… etc.

La función que se utiliza para crear una fuente a partir de objetos de R es as_mapbox_source(). Esta función admite objetos de la clase sf y data.frames. Se pueden ver más ejemplos del uso del paquete sf en otros artículos de R.

# Lectura del fichero carreteras.json con el paquete sf
library(sf)
bomberos_sf <- st_read("emergencias_parques_bomberos.json")

# Conversión a fuente mapboxer
bomberos_source <- as_mapbox_source(bomberos_sf)

Una vez generado nuestro objeto con la fuente, debemos crear capas con la configuración de los estilos que deseemos para nuestras fuentes. Para generar capas podemos utilizar la función estándar add_layer() y o directamente emplear funciones específicas como add_circle_layer(), add_raster_layer()… etc. Puedes consultarse todos los tipos disponibles en e API de capas de Mapbox.

## Creación de una capa con la fuente anterior
bomberos_capa <- add_circle_layer(
  map = mapa1,
  source = bomberos_source,
  circle_color = "red",
  circle_radius = 5)
bomberos_capa

Inserción de controles

Los controles son superposiciones en la parte superior del mapa que permiten la interacción entre el usuario y el mapa. En el siguiente código se muestra cómo añadir un control de navegación en la esquina superior izquierda y un control de escala en la esquina inferior izquierda a nuestro mapa generado anteriormente.

## Control de navegación
bomberos_capa <- add_navigation_control(
    mapa = bomberos_capa,
    pos = "top-left",
    showCompass = FALSE) 

## Control de escala
bomberos_capa <-  add_scale_control(
    mapa = bomberos_capa,
    pos = "bottom-left",
    unit = "metric"
)
bomberos_capa

Cada control tiene sus argumentos específicos y a su vez, existen multitud de controles que pueden añadirse a nuestros mapas para aumentar las interacciones del usuario con el mapa. Pueden consultarse en la documentación de Mapbox GL JS, en el apartado Markers and controls.

mapboxer, al igual que otras librerías de R, permite el uso del operador de tubería %>% (conocido también como operador pipe o piperline en inglés), para concatenar múltiples operaciones y reducir el tamaño del código. A continuación, se muestra todo el código con el que hemos trabajado resumido en una única sentencia de código:

## Generación de mapa interactivo mapboxer con el operador de tuberías
mapa_final <- 
  mapboxer(
    source =  as_mapbox_source(bomberos_sf),
    center = c(-2.449, 42.4658),
    style = basemaps$Carto$positron,
    zoom = 9
  ) %>% add_circle_layer(
    circle_color = "red",
    circle_radius = 5
    ) %>% add_navigation_control(
      pos = "top-left",
      showCompass = FALSE
      ) %>% add_scale_control(
        pos = "bottom-left",
        unit = "metric"
      )
mapa_final

Y para los más curiosos, otro fragmento de código representando los centros educativos (centros_educativos.json de la Base de Datos Geográfica del Gobierno de La Rioja), empleando otros argumentos para lograr un mapa más complejo:

centros_sf <- st_read("centros_educativos.json")
mapa_centros <- 
  mapboxer(
    style = basemaps$Carto$positron,
    source =  as_mapbox_source(centros_sf),
    center = c(-2.449, 42.4658),
    zoom = 9
  ) %>% add_circle_layer(
    circle_color = "yellow",
    circle_radius = 5,
    circle_blur = 1,
    circle_stroke_color = "red",
    circle_stroke_width = 1,
    popup = "<p>Colegio <b> {{T205_077_NOMBRE}} </b> </p>"
    ) %>% add_navigation_control(
      pos = "top-left",
      showCompass = FALSE
      ) %>% add_scale_control(
        pos = "bottom-left",
        unit = "metric"
      )
mapa_centros