Mapas en R
Diego López Tamayo 1
¿Por qué usar mapas?
Los mapas se utilizan en una variedad de campos de investigación para expresar datos de una manera atractiva e intuitiva. Los datos pueden expresarse de modo simplificado, y esta interpretación de datos generalmente se pierde si los datos solo se ven a través de una hoja de cálculo. Los mapas pueden agregar un contexto visual al incorporar muchas variables en un contexto fácil de leer y aplicable. Los mapas también son muy importantes en la difusión porque pueden permitir rápidamente al público obtener una mejor visión de los datos.
Los elementos básicos de un mapa que deben considerarse son polígonos, puntos, líneas y texto. (polygon, points, lines, and text.)
- Los polígonos, en un mapa, son formas cerradas, como las fronteras de los países.
- Las líneas se consideran patrones que no se rellenan con ningún aspecto, como carreteras, arroyos o carreteras.
- Finalmente, los puntos se utilizan para especificar posiciones específicas, como la ciudad o lugares.
Usar R para crear mapas trae muchos beneficios. Los elementos de un mapa se pueden agregar o quitar con facilidad: el código R se puede ajustar para realizar mejoras importantes con solo una lína de código. También es fácil reproducir los mismos mapas para diferentes conjuntos de datos.
El paquete tmap y ggplot2 implementan una “gramática” de los gráficos en R, una forma de crear código que tenga sentido para el usuario: la gramática de los gráficos es un término utilizado para dividir los gráficos en componentes semánticos, como geometrías y capas. Hablando en términos prácticos, permite (y obliga) Al usuario a enfocarse en elementos gráficos en un nivel más alto de abstracción, y cómo los datos deben estructurarse para lograr el resultado esperado.
Recientemente, el paquete ggplot2 ha permitido el uso de funciones simples del paquete sf como capas en un gráfico. La combinación de ggplot2 y sf, por lo tanto, permite crear mapas mediante programación, utilizando la gramática de los gráficos.
Introducción a tmap
Con el paquete tmap, se pueden generar mapas temáticos con gran flexibilidad. La sintaxis para crear gráficos es similar a la de ggplot2, pero adaptada a los mapas.
Primeros pasos
Un buen lugar para comenzar es crear un mapa del mundo.
El objeto Mundo es un objeto espacial de clase sf del paquete sf; Es un dataframe con una columna especial que contiene una geometría (geometry) para cada fila, en este caso polígonos. Para trazar un mapa en tmap, primero debemos especificarlo con tm_shape. Se pueden agregar capas con el operador +, en este caso tm_polygons. Hay muchas funciones de capa en tmap, que se pueden encontrar fácilmente en la documentación por su prefijo tm_.
## [1] "sf" "data.frame"El dataframe “World” incluye información sobre población, economía y otros datos de todos los países del mundo.
Después de instalar tmap, las siguientes líneas de código deberían crear el mapa del mundo coloreando los diferentes niveles del Happy Planet Index HPI:
# Usamos el modo plot de tmap
tmap_mode("plot")
# La shape principal es el dataframe con datos geométricos
tm_shape(World) +
tm_polygons("HPI") #Agregámos un atributo de polígonos basado en la columna HPI
Formas y capas
Una forma (shape) es un objeto espacial (con una clase de sf, sp, stars o raster). Se pueden trazar múltiples formas y también múltiples capas por forma.
Echemos un vistazo al dataframe Metro. Muestra la población de las regiones metropolitanas del mundo, por ejemplo, todas las regiones metropolitanas de México:
Veamos a toda la población mundial en 1950 y 2010.
# Shape principal: dataframe metro
# Atributo de burbuja (población_año)
m1<-tm_shape(metro)+tm_bubbles("pop1950")
m2<-tm_shape(metro)+tm_bubbles("pop2010")
# Podemos crear objetos y mostrarlos en un arreglo por filas
tmap_arrange(m1,m2,nrow=1)
En el ejemplo anterior, utilizamos los datos de Metro, este un excelente ejemplo para darnos cuenta que las coordenadas que contiene la base de datos Metro ubican las poblaciones en su respectivo lugar, sin embargo el dataframe Metro no tiene las geometrías necesarias para dibujar las fronteras de los países. Para lograrlo, creamos otra capa basada en las geometrías de World incorporando datos ambos dataframes en un mismo mapa.
tm_shape(World) + # La shape principal será World
tm_borders("gray", lwd = .5) + # Dibujamos las fronteras de gris con ancho 0.5
tm_text("iso_a3", size = "AREA") + # Agregamos texto (nombre del país) de tamaño proporcional al país
tm_shape(metro) + # Agregamos una capa encima con una shape principal de metro
tm_symbols(col = "red", size = "pop2020", scale = .5) + # Usamos la población para el tamaño de los círculos
tm_legend(show = T) #Agregamos la leyenda de la población
Se puede obtener un mapa más informativo si los datos sobre la población se complementan con una tasa de crecimiento de las cifras de población.
# Agregamos la columna de crecimiento al dataframe Metro
metro$growth <- (metro$pop2020 - metro$pop2010) / (metro$pop2010 * 10) * 10
# Shape principal Metro con burbujas de color basado en crecimiento
tm_shape(metro) +
tm_bubbles("pop2010", col = "growth",
breaks=c(-Inf, seq(0, 6, by=2), Inf), #Agregamos breaks para crecimiento, simplificando las tasas
# en números redondos de 2 en 2.
palette="-RdYlBu", contrast=1, #Usamos la paleta RdYlBu de forma inversa (amarillo menos,rojo más)
title.size="Metro population",
title.col="Growth rate (%)", id="name")+
tm_layout(legend.outside = T) # Colocamos la leyenda afuera de la gráfica
Ahora podemos simplemente poner los dos mapas (el mapa mundial del índice de felicidad y las burbujas de crecimiento de la población) uno encima del otro y obtener un mapa simple pero informativo.
# Definimos estilo y formato global para el mapa con tmap_style() y tmap_format()
tmap_style("gray")
tmap_format("World_wide")## $inner.margins
## [1] 0.000 0.200 0.025 0.010
##
## $legend.position
## [1] "left" "bottom"
##
## $attr.position
## [1] "right" "bottom"
##
## $scale
## [1] 0.8# Creamos un objeto tmap llamado mapWorld
mapWorld <- tm_shape(World) + # Shape principal World con polígonos agrupados por Clasificación OCDE
tm_polygons("income_grp", palette="-Blues", contrast=.7, id="name", title="OCDE") +
tm_shape(metro) +
tm_bubbles("pop2010", col = "growth",
border.col = "black", border.alpha = .5,
style="fixed", breaks=c(-Inf, seq(0, 6, by=2), Inf),
palette="-RdYlBu", contrast=1,
title.size="Población Metropolitana",
title.col="Tasa crecimiento (%)", id="name")
# Agregamos algunos ajustes para la leyenda con tm_layout
mapWorld + tm_layout(legend.position = c("left","bottom"),legend.stack = "vertical", legend.text.size = 0.6)
Este es nuestro primer mapa estático. Notemos que no podemos “acercanos”, pero ya puede ver muchas cosas desde un punto de vista general. Pero si se desea ver los detalles de regiones o metrópolis individuales, se necesita algo más, es decir, una versión interactiva, que le permita acercarse a su punto de interés.
Esto es muy fácil con el paquete tmap. Lo único que debe hacer es cambiar del modo de trazado al modo de vista (view mode) usando el objeto tmap que acbamos de crear. Vea más sobre esto en la sección Mapas interactivos (#mapas-interactivos).
Mapas estáticos rápidos con plot ()
Los mapas estáticos son el tipo más común de salida visual de la geocomputación. Los formatos estándar incluyen .png y .pdf para salidas ráster y vectoriales respectivamente.
La función plot () genérica es a menudo la forma más rápida de crear mapas estáticos a partir de objetos espaciales vectoriales y ráster. A veces, la simplicidad y la velocidad son prioridades, especialmente durante la fase de desarrollo de un proyecto, y aquí es donde sobresale plot () que ofrece muchos de argumentos utilizando la base de R.
Los atributos se agregan como capas a las imágenes existentes configurando add = TRUE.
El siguiente código combina países de Asia. La función st_union () combina o une geometrías de características (feature geometries).
world_asia = World[World$continent == "Asia", ] # Filtrando todas las filas del continente asiático
asia = st_union(world_asia)
# Combinando características de world_asia en una sola geometría con límites definidos.Ahora podemos trazar el continente asiático con sus propias características sobre un mapa del mundo. Es importante tener en cuenta que el primer plot() solo debe tener una faceta para que add = TRUE funcione.
# Necesitamos ejecutar ambas líneas para que funcione el "add"
plot(World["continent"], reset = FALSE)
plot(asia, add = TRUE, col = "red")
Agregar capas de esta manera puede usarse para verificar la correspondencia geográfica entre capas: la función plot () es rápida de ejecutar y requiere pocas líneas de código, pero no crea mapas interactivos con muchas opciones.
Hay varias formas de modificar mapas con el método plot () de sf. Debido a que sf extiende los métodos de trazado base R, los argumentos de plot () como main = (que especifica el título del mapa) funcionan con objetos sf.
Esta figura ilustra esta flexibilidad mediante la superposición de círculos, cuyos diámetros (establecidos con cex =) representan poblaciones de países.
plot(World["continent"], reset = FALSE)
cex = sqrt(World$pop_est) / 10000
world_cents = st_centroid(World, of_largest = TRUE)
plot(st_geometry(world_cents), add = TRUE, cex = cex)
La función tmap en profundidad
Agregar capas a los mapas
Al igual que ggplot2, tmap se basa en la idea de una “gramática de gráficos”. Consulte sección ggplot en R Basics. Esto implica una separación entre los datos (dataframe) y la estética (aesthetics) que indica cómo se visualizan los datos. cada conjunto de datos de entrada se puede ‘mapear’ en una variedad de formas diferentes, incluida la ubicación en el mapa (definida por la geometría de los datos), el color y otras variables visuales .
La función básica es tm_shape () (que define datos de entrada (dataframe) con datos ráster y/o objetos vectoriales), seguido de uno o más elementos de capa como tm_fill () y tm_dots ().
tmap_mode("plot")
library(spData) # Utilizamos estas dos librerías.
library(spDataLarge) # devtools::install_github("robinlovelace/geocompr")
library(raster)
# Añadir capa de relleno (fill) a la forma (shape) nz
m1<-tm_shape(nz) +
tm_fill()
# Añadir capa de contorno (border) a la forma (shape) nz
m2<-tm_shape(nz) +
tm_borders()
# Añadir ambas capa de contorno y relleno
m3<-tm_shape(nz) +
tm_fill() +
tm_borders()
tmap_arrange(m1,m2,m3,nrow=1)
El objeto dentro de tm_shape () en este caso es nz, un objeto sf que representa las regiones de Nueva Zelanda. Las capas se agregan para representar nz visualmente, con tm_fill () y tm_borders () creando áreas sombreadas (panel izquierdo) y contornos/bordes (panel central).
Este es un enfoque intuitivo para la creación de mapas: la tarea común de agregar nuevas capas la realiza el operador de adición +, seguido de tm _*(). El asterisco (*) se refiere a una amplia gama de tipos de capas que tienen nombres que se explican por sí mismos, incluidos relleno, bordes (mostrados anteriormente), burbujas, texto y ráster. (bubbles, text and raster.)
Pro tip: qtm () es una función útil para crear mapas temáticos rápidos (quick thematic maps, de ahí el nombre). Es una método rápido y proporciona una buena visualización predeterminada en muchos casos: qtm (nz), por ejemplo, es equivalente a tm_shape (nz) + tm_fill () + tm_borders (). La desventaja es que hace que la estética de las capas individuales sea más difícil de controlar. Otra función rápida es tm_polygons () que agrupa tm_fill () + tm_borders ()
Natar que al almacenar los mapas en objetos en R, creamos un objeto tmap, que puede usarse más tarde o agregar capas.
## [1] "tmap"Se pueden agregar nuevas formas con + tm_shape (new_obj). En este caso, new_obj representa un nuevo objeto espacial que se trazará en la parte superior de las capas anteriores. Cuando se agrega una nueva figura (shape) de esta manera, todas las funciones estéticas que le sigan se refieren a la principal, hasta que se agrega otra nueva figura (shape). Esta sintaxis permite la creación de mapas con múltiples formas y capas.
Ejemplo: la función tm_raster () para trazar una capa ráster (con alfa establecido para hacer que la capa sea semitransparente).
En este caso la capa ráster es la cartografía de Nueva Zelanda, con datos sobre la elevación de las montañas.
Partiendo del objeto map_nz creado anteriormente, el código anterior crea un nuevo objeto map_nz1 que contiene otra forma (nz_elev) que representa la elevación promedio en Nueva Zelanda.
Aesthetics (Estética)
Los gráficos en la sección anterior demuestran la configuración estética predeterminada de tmap:
- Los tonos grises se usan para las capas tm_fill () y tm_bubbles ()
- La línea negra continua se usa para representar líneas creadas con tm_lines ().
Hay dos tipos principales de estética de mapas: los que cambian con los datos y los que son constantes. A diferencia de ggplot2, que utiliza la función auxiliar aes () para representar la estética de variables, tmap acepta argumentos estéticos que son variables (nombres de variables de un dataframe por ejemplo) o valores constantes. (colores fijos “red”, “blue”)
Las aesthetics más utilizadas para color interno y de contorno inclyen: color, transparency, line width and line type, establecidos con col, alpha, lwd, and lty arguments, respectivamente. A continuación un ejemplo de cada una de estas estéticas:
m1 = tm_shape(nz) + tm_fill(col = "red")
m2 = tm_shape(nz) + tm_fill(col = "red", alpha = 0.3)
m3 = tm_shape(nz) + tm_borders(col = "blue")
m4 = tm_shape(nz) + tm_borders(lwd = 3)
m5 = tm_shape(nz) + tm_borders(lty = 2)
m6 = tm_shape(nz) + tm_fill(col = "red", alpha = 0.3) +
tm_borders(col = "blue", lwd = 3, lty = 2)
tmap_arrange(m1, m2, m3, m4, m5, m6)
Tenga en cuenta que, al igual que las gráficas de base R, los argumentos que definen la estética también pueden recibir variables. Pero a diferencia de los argumentos estéticos de R base, los argumentos estéticos de tmap no aceptan vectores numéricos:
# plot(st_geometry(nz), col = nz$Land_area)
# Este comando funciona porque utiliza R base
# tm_shape(nz) + tm_fill(col = nz$Land_area)
# Este comando NO funciona porque usamos un vector variable dentro de tm_fill()
# Error: Fill argument neither colors nor valid variable name(s)En cambio, col() y otras estéticas que pueden variar, como lwd() para capas de línea y size() para capas de puntos, requieren una cadena (string) que nombre un atributo asociado con la geometría que se trazará.
Un argumento importante en las funciones que definen capas estéticas como tm_fill () es title, que establece el título de la leyenda asociada. El siguiente código muestra esta funcionalidad al proporcionar un nombre más atractivo que “Land_area” (tenga en cuenta el uso de expresión () para crear texto de superíndice):
legend_title = expression("Área (km"^2*")") #Creamos un objeto con la expresión que queremos
map_nza = tm_shape(nz) +
tm_fill(col = "Land_area", title = legend_title) + tm_borders() #Lo usamos en col dentro de ""
map_nza 
Configuraciones de color
- La configuración predeterminada utiliza ‘pretty’ breaks
- La función breaks nos permite configurar manualmente los breaks
- n establece el número de categorías en los que se clasifican las variables numéricas.
- La paleta (pallete) define el esquema de color, por ejemplo BuGn
m1<-tm_shape(nz) + tm_polygons(col = "Median_income") # default
breaks = c(0, 3, 4, 5) * 10000
m2<-tm_shape(nz) + tm_polygons(col = "Median_income", breaks = breaks) # breaks
m3<-tm_shape(nz) + tm_polygons(col = "Median_income", n = 10) # n
m4<-tm_shape(nz) + tm_polygons(col = "Median_income", palette = "BuGn") # pallette
tmap_arrange(m1, m2, m3, m4)
Otra forma de cambiar la configuración de color es alterando la configuración de color break (o bin). Además de establecer breaks manualmente, tmap permite a los usuarios especificar algoritmos para crear automáticamente interrupciones con el argumento de estilo. Aquí hay seis de los estilos de breaks más útiles:
style = “pretty”, la configuración predeterminada, redondea los breaks en números enteros cuando sea posible y los espacia de manera uniforme;
style = “equal” divide los valores de entrada en categorías de igual rango y es apropiado para variables con una distribución uniforme (no se recomienda para variables con una distribución sesgada ya que el mapa resultante puede terminar teniendo poca diversidad de color);
style = “quantile” asegura el mismo número de observaciones dentro de cada categoría (con la desventaja de que los rangos de categoría pueden variar ampliamente)
style = “jenks” identifica grupos de valores similares en los datos y maximiza las diferencias entre categorías;
style = “cont” (y “order”) presentan una gran cantidad de colores sobre campos de color continuos (degradados) y son adecuados para rásteres continuos (el “orden” puede ayudar a visualizar distribuciones sesgadas);
style = “cat” fue diseñado para representar valores categóricos y asegura que cada categoría reciba un color único.
m1<-tm_shape(nz) + tm_polygons(col = "Median_income",style="pretty")
m2<-tm_shape(nz) + tm_polygons(col = "Median_income",style="equal")
m3<-tm_shape(nz) + tm_polygons(col = "Median_income",style="quantile")
m4<-tm_shape(nz) + tm_polygons(col = "Median_income",style="jenks")
m5<-tm_shape(nz_elev) + tm_raster(col = "elevation",style="cont")
m6<-tm_shape(nz) + tm_polygons(col = "Island",style="cat")
tmap_arrange(m1, m2, m3, m4,m5,m6,nrow=2)
Sobre las paletas de color
Las paletas definen los rangos de color asociados con las categorías y determinados por los breaks (saltos) descritos anteriormente. La paleta de colores predeterminada se especifica en tm_layout (), sin embargo, se puede cambiar rápidamente utilizando el argumento pallete() con un vector de colores o un nuevo nombre de paleta de colores, que puede seleccionarse interactivamente con tmaptools :: palette_explorer () que es una aplicación interactiva para establecer paletas.
Puede agregar un - como prefijo para invertir el orden de la paleta.
Hay tres grupos principales de paletas de colores:
Categóricas Consisten en colores fácilmente distinguibles y son los más apropiados para datos categóricos sin ningún orden en particular, como nombres de estados o tipos de suelo.
Secuenciales Estas siguen un gradiente, por ejemplo, de colores claros a oscuros (los colores claros tienden a representar valores más bajos) y son apropiados para variables continuas (numéricas).
Divergentes Por lo general, varían entre tres colores distintos y generalmente se crean uniendo dos paletas secuenciales de un solo color con los colores más oscuros en cada extremo.
Las paletas de colores también deben ser fáciles de entender para transmitir información de manera efectiva. Debe quedar claro qué valores son más bajos y cuáles son más altos, y los colores deben cambiar gradualmente.
Layouts (disposición)
El layout del mapa se refiere a la combinación de todos los elementos del mapa en un mapa coherente. Los elementos del mapa incluyen, entre otros, los objetos a mapear, el título, la barra de escala, los márgenes y las relaciones de aspecto, mientras que los ajustes de color de la sección anterior se relacionan con la paleta y los breaks utilizados para afectar el aspecto del mapa.
Elementos adicionales como las flechas cardianles y las barras de escala tienen sus propias funciones: tm_compass () y tm_scale_bar ().
map_nz +
tm_compass(type = "8star", position = c("left", "top")) +
tm_scale_bar(breaks = c(0, 100, 200), text.size = 1)
Algunos ejemplos de layouts:
m1<- map_nz + tm_layout(title = "New Zealand")
m2<- map_nz + tm_layout(scale = 5)
m3<- map_nz + tm_layout(bg.color = "lightblue")
m4<- map_nz + tm_layout(frame = FALSE)
tmap_arrange(m1, m2, m3, m4)
Aquí hay algunas configuraciones de layout útiles:
Ancho del marco (frame.lwd) y una opción para permitir líneas dobles (frame.double.line)
Configuración de margen, como external.margin y inner.margin
Configuración de fuente controlada por fontface y fontfamily
Configuración de leyenda que incluye opciones binarias como legend.show (mostrar o no la leyenda) legend.only (omitir el mapa) y legend.outside (la leyenda sale del mapa), así como configuraciones de opción múltiple como legend. posición
Colores predeterminados de capas estéticas (aes.color), atributos del mapa como el marco (attr.color)
Configuración de color que controla la sepia.intensity (cuán amarillento se ve el mapa) y la saturation (una escala de grises de color)
m1 <- tm_shape(nz) + tm_polygons(col = "Median_income")
m2 <- m1 + tm_layout(inner.margins = 0.2)
m2 <- m1 + tm_layout(legend.show = F)
m3 <- m1 + tm_layout(legend.position = c("right","bottom"))
m4 <- m1 + tm_layout(frame.lwd = 5)
m5 <- m1 + tm_layout(sepia.intensity = 2)
tmap_arrange(m2, m3, m4, m5)
Además de los controles básics sobre diseños y colores, tmap también ofrece estilos de alto nivel, utilizando la función tm_style (). Algunos estilos como tm_style(“cobalt”) dan como resultado mapas estilizados, mientras que otros como tm_style(“gray”) hacen cambios más sutiles.
m1 <- map_nza + tm_style("bw")
m2 <- map_nza + tm_style("classic")
m3 <- map_nza + tm_style("cobalt")
m4 <- map_nza + tm_style("col_blind")
tmap_arrange(m1, m2, m3, m4)
se puede generar una vista previa de estilos predefinidos ejecutando tmap_style_catalogue (). Esto crea una carpeta llamada tmap_style_previews que contiene nueve imágenes. Toma algo de tiempo en cargar.
Mapas en facetas
Los mapas facetados, también conocidos como “pequeños múltiplos”, se componen de muchos mapas dispuestos uno al lado del otro y, a veces, apilados verticalmente. Las facetas permiten visualizar cómo cambian las relaciones espaciales con respecto a otra variable, como el tiempo.
Por lo general, todas las facetas individuales en un mapa facetado contienen los mismos datos de geometría repetidos varias veces, una para cada columna en los datos de atributos. Sin embargo, las facetas también pueden representar geometrías cambiantes, como la evolución de las fronteras de una ciudad o país, por ejemplo.
El conjunto de datos urban_agglomerations incluye las 30 áreas más grandes por población a intervalos de 5 años.
Usamos el operador %n% para identificar si un elemento pertenece a un vector y agrupamos para 4 años.
urb_1970_2030 = urban_agglomerations %>%
filter(year %in% c(1970, 1990, 2010, 2030))
head(urb_1970_2030)
# Agregamos a la shape principal una segunda shape con los datos de urb_1970_2030
tm_shape(world) +
tm_polygons() +
tm_shape(urb_1970_2030) + # Utilizamos symbols que varían de acuerdo a la población.
tm_symbols(col = "black", border.col = "white", size = "population_millions")
tm_shape(world) +
tm_polygons() +
tm_shape(urb_1970_2030) +
tm_symbols(col = "black", border.col = "white", size = "population_millions") +
tm_facets(by = "year", nrow = 2, free.coords = F) 
# Utilizamos tm_facets para repetir todo lo anterior a través de una variable: el tiempo, en este caso "year".
# Notar que como hay 4 valores distintos para year se generan 4 mapas.El código anterior muestra las características clave de los mapas facetados creados con tmap:
Se repiten las formas (shapes) que no tienen una variable de faceta (los países del mundo en este caso)
El argumento by determina la variable que va cambiando (year en este caso).
La configuración nrow / ncol que especifica el número de filas y columnas en las que se deben organizar las facetas
El parámetro free.coords que especifica si cada mapa tiene su propio cuadro delimitador
Además de su utilidad para mostrar relaciones espaciales cambiantes, los mapas facetados también son útiles como base para mapas animados.
Mapas animados
Las facetas se vuelven pequeñas cuando hay muchas de ellas. Además, el hecho de que cada faceta esté físicamente separada en la pantalla o página significa que las diferencias sutiles entre facetas pueden ser difíciles de detectar.
Los mapas animados resuelven estos problemas. Aunque se requiere de una publicación digital (html), esto se está volviendo menos problemático a medida que más y más contenido está en línea.
Hay varias formas de generar animaciones en R, incluso con paquetes de animación como gganimate, que se basa en ggplot2. Esta sección se centra en la creación de mapas animados con tmap porque su sintaxis le resultará familiar de las secciones anteriores.
Se requiere tener instalado ImageMagick que es una aplicación externa a R para crear y modificar imágenes en distintos formatos. Para una guía rápida de instalación ver: En Windows En Mac
urb_anim = tm_shape(world) + tm_polygons() +
tm_shape(urban_agglomerations) + tm_dots(size = "population_millions") +
tm_facets(along = "year", free.coords = FALSE)Sin embargo, notar hay dos diferencias relacionadas con los argumentos en tm_facets ():
- along = “year” se usa en lugar de by = “year”.
- free.coords = FALSE, que mantiene la extensión del mapa para cada iteración del mapa.
El objeto urb_anim resultante representa un conjunto de mapas separados para cada año. La etapa final es combinarlos y guardar el resultado como un archivo .gif con tmap_animation ().
Notar que esto crea un archivo gif en el directorio de trabajo. Se muestra a continuación para fines de visualización.
Mapas interactivos
Mientras que los mapas estáticos y gifs pueden animar los conjuntos de datos geográficos, los mapas interactivos pueden llevarlos a un nuevo nivel. La interactividad puede tomar muchas formas, la más común y útil es la capacidad de desplazarse y acercarse a cualquier parte de un conjunto de datos geográficos superpuestos en un “mapa web”.
Un nivel de interactividad menos avanzado incluye “ventanas emergentes”popups" que aparecen cuando uno hace clic en diferentes funciones, una especie de etiqueta interactiva. Por el momento nos limitamos a este tipo de interactividad.
El lanzamiento del paquete leaflet revolucionó la creación de mapas web interactivos desde R y varios paquetes se han construido sobre estas bases añadiendo nuevas características (por ejemplo, leaflet.extras) y haciendo la creación de mapas web tan simples como crear mapas estáticos (por ejemplo, tmap).
Una característica única de tmap es su capacidad para crear mapas estáticos e interactivos utilizando el mismo código. Los mapas se pueden ver de forma interactiva en cualquier punto cambiando al modo de vista, utilizando el comando tmap_mode (“view”)
Las características notables de este modo interactivo incluyen la capacidad de especificar el mapa base con tm_basemap() (o tmap_options ()). El mapa base se refiere a mapas creados por instituciones con características como urbanismo, clima, vialidades o topografía como se demuestra a continuación:
Una característica impresionante y poco conocida del modo de vista de tmap es que también funciona con mapas en facetas El argumento sync en tm_facets () se puede usar en este caso para producir múltiples mapas con ajustes sincronizados de zoom y vista panorámica. A continuación un ejempo:
El dataset coffee_data contiene datos sobre la producción mundial de café:
Notemos que la columna de nombre de país name_long es la misma que en el dataset World:
Entonces podemos usar los mapas poligonales de World para mapear la evolución de la producción mundial de café.
# Unimos ambos datasets con left_join() manteniendo todas las observaciones en el conjunto de datos izquierdo (World)
world_coffee = left_join(world, coffee_data, by = "name_long")
# Creamos dos facetas: 2016 y 2017
facets = c("coffee_production_2016", "coffee_production_2017")
tm_shape(world_coffee) + tm_polygons(facets) +
tm_facets(nrow = 1, sync = TRUE)Cambie tmap nuevamente al modo de trazado con la misma función: tmap_mode (“plot”)
Mapas interactivos rápidos con mapview ()
Si aún es complicado la gramática de tmap, la forma más rápida de crear mapas interactivos puede ser con mapview. El siguiente “one liner” es una forma confiable de explorar interactivamente una amplia gama de formatos de datos geográficos:
mapview tiene una sintaxis concisa pero es poderosa. Por defecto, proporciona algunos estándares de GIS como información de posición del mouse, consultas de atributos (mediante ventanas emergentes), barra de escala y botones de zoom entre capas.
Ofrece controles avanzados que incluyen la capacidad de “reventar” conjuntos de datos en varias capas y la adición de varias capas con + seguido del nombre de un objeto geográfico. Además, proporciona coloración automática de atributos a través del argumento zcol()
Dado que mapview siempre espera un objeto espacial (sf, Spatial,Raster) como primer argumento, funciona bien con pipes. Considere el siguiente ejemplo donde usamos pipes en un obejto sf (nz):
Una cosa importante a tener en cuenta es que las capas de mapview se agregan a través del operador + (similar a ggplot2 o tmap). Para obtener más información sobre mapview, consulte el sitio web de mapview
Leaflet
Por último, pero no menos importante, Leaflet, que es el paquete de mapeo interactivo más maduro y ampliamente utilizado en R. Leaflet proporciona una interfaz de nivel relativamente bajo para la biblioteca Leaflet JavaScript y muchos de sus argumentos pueden entenderse leyendo la documentación de librería JavaScript original
Los mapas Leaflet se crean con la función leaflet(), el resultado es un objeto leaflet_map que puede usarse en conjunto (con pipes) con otras funciones de leaflet.
Esto permite agregar múltiples capas de mapas y configuraciones de control de forma interactiva, como se demuestra en el siguiente ejemplo:
- El dataset cycle_hire son datos espaciales (sf dataframe) que contiene los puntos de alquiler de bicicletas en Londres.
id Identificación del punto de alquiler
name Nombre del punto de alquiler
area Área en la que se ubica
nbikes El número de bicicletas actualmente estacionadas en el punto de alquiler
nempty El número de lugares vacíos.
geometry sfc_POINT Los datos geoespaciales.
pal = colorNumeric("RdYlBu", domain = cycle_hire$nbikes)
# Esto es solo una paleta de colores con rango basado en nbikes.
# Usamos pipes %>% para ir agregando las capas:
leaflet(data = cycle_hire) %>%
addProviderTiles(providers$CartoDB.Positron) %>% # Agregamos una capa de fondo de un provedor externo (vías de Londres)
addCircles(col = ~pal(nbikes), opacity = 0.9) %>% # Círculos con paleta según nbikes
addLegend(pal = pal, values = ~nbikes) %>% # Leyenda superior derecha usando la paleta pal
setView(lng = -0.1, 51.5, zoom = 12) %>% # Vista inicial (posición y zoom)
addMiniMap() # Agrega el minimapa en la esquina inferior derecha (posición predeterminada)Otros paquetes de mapeo
ggplot
Desde la versión 2.3.0, el paquete de trazado tidyverse ggplot2 ha soportado objetos sf con geom_sf (). La sintaxis es similar a la utilizada por tmap: una llamada inicial a ggplot () es seguida por una o más capas, que se agregan con + geom_*(), donde * representa un tipo de capa como geom_sf () (para sf objetos) o geom_points () (para puntos).
ggplot2 traza las retículas de forma predeterminada. La configuración predeterminada para las retículas se puede anular mediante scale_x_continuous (), scale_y_continuous () o coord_sf (datum = NA).
Otras características notables incluyen el uso de nombres de variables sin comillas encapsulados en aes () para indicar qué estética varía y cambiar las fuentes de datos utilizando el argumento “data=”, como se demuestra en el fragmento de código a continuación:
library(ggplot2)
g1 = ggplot() + geom_sf(data = nz, aes(fill = Median_income)) +
scale_x_continuous(breaks = c(170, 175))
g1
Una ventaja de ggplot2 es que tiene una fuerte comunidad de usuarios y muchos paquetes adicionales. Se pueden encontrar buenos recursos adicionales en ggplot2 book y en las descripciones de la multitud de “paquetes gg” como ggrepel y tidygraph.
Otro beneficio de los mapas basados en ggplot2 es que se les puede dar fácilmente un nivel de interactividad cuando se imprimen usando la función ggplotly () del paquete plotly
Al mismo tiempo, ggplot2 tiene algunos inconvenientes. La función geom_sf () no siempre puede crear una leyenda deseada para usar a partir de los datos espaciales. Los objetos ráster tampoco son compatibles de forma nativa en ggplot2 y deben convertirse en un dataframe antes de trazar.
Mapas geográficos de INEGI
Para conocer más sobre los datos espaciales creados por INEGI y el manejo de la ENIGH recomiendo el tutorial realizado por Emmanuel Maruri
# Mapas a nivel Estado
mapa_mex_edos <- st_read("mg_sep2019_integrado/conjunto_de_datos/00ent.shp",
options = "ENCODING=WINDOWS-1252")## options: ENCODING=WINDOWS-1252
## Reading layer `00ent' from data source `/Users/Soporte/Desktop/Code/R Pro/Maps/mg_sep2019_integrado/conjunto_de_datos/00ent.shp' using driver `ESRI Shapefile'
## Simple feature collection with 32 features and 3 fields
## geometry type: MULTIPOLYGON
## dimension: XY
## bbox: xmin: 911292 ymin: 319149.1 xmax: 4082997 ymax: 2349615
## projected CRS: MEXICO_ITRF_2008_LCC# Mapas a nivel Municipal
mapa_mex_mun <- st_read("mg_sep2019_integrado/conjunto_de_datos/00mun.shp",
options = "ENCODING=WINDOWS-1252")## options: ENCODING=WINDOWS-1252
## Reading layer `00mun' from data source `/Users/Soporte/Desktop/Code/R Pro/Maps/mg_sep2019_integrado/conjunto_de_datos/00mun.shp' using driver `ESRI Shapefile'
## Simple feature collection with 2465 features and 4 fields
## geometry type: MULTIPOLYGON
## dimension: XY
## bbox: xmin: 911292 ymin: 319149.1 xmax: 4082997 ymax: 2349615
## projected CRS: MEXICO_ITRF_2008_LCC# ENIGH 2018 Concentrado Hogar
ENIGH <- read_csv(
"https://raw.githubusercontent.com/diego-eco/diego-eco.github.io/master/downloads/ENIGH_concentradohogar_2018.csv")# Paste the data from "ENIGH_edos" to the dataframe "mapping_edos" with the inner_join function
mapeo_edos <- inner_join(mapa_mex_edos, ENIGH_edos,
by = "CVE_ENT")
# Paste the ENIGH_muni data to the mapping_mun dataframe with the left_join function
mapeo_mun <- left_join(mapa_mex_mun, ENIGH_muni,
by = "CVEGEO")Ingresos promedio de la Ciudad de México con mapview
Población de la Ciudad de México con mapview
Población e ingreso promedio de la Ciudad de México con mapview
mapa_cdmx %>% mapview(color = "white", lwd = 3, layer.name = "CDMX") +
mapview(mapa_cdmx, zcol = "Poblacion") + mapview(mapa_cdmx, zcol = "Ing_prom") # pal = colorNumeric("RdYlBu", domain = mapa_cdmx$Ing_prom)
# leaflet(data = mapa_cdmx) %>%
# addProviderTiles(providers$CartoDB.Positron) %>%
# addCircles(col = ~pal(Ing_prom), opacity = 0.9) %>%
# addLegend(pal = pal, values = ~Ing_prom) %>%
# setView(lng = -0.1, 51.5, zoom = 12) %>%
# addMiniMap()El Colegio de México, diego.lopez@colmex.mx↩︎