03-acceso_a_info_urbana.Rmd

# Acceso a información urbana georeferenciada en repositorios _online_

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE, message = FALSE, warning = FALSE)

# Para que no fallen azarosamente las consultas API 
httr::set_config(httr::config(http_version = 0))
```


[OpenStreetMap](openstreetmap.org) es un servicio de mapas online que publica información contribuida en forma libre por más de un millón de voluntarios, que benefician a los 5,5 millones de usuarios de la plataforma. 

Los contribuidores más entusiastas mapean barrios completos utilizando herramientas GPS para enviar información local completa, actualizada y precisa a OpenStreetMap. Varias empresas y entidades públicas que producen información geográfica también contribuyen al permitir que sus datos sean incluidos. Existen equipos profesionales de contribuidores que que se coordinan para agregar y mantener actualizada información georeferenciada de límites políticos, calles, edificios, negocios y otros puntos de interés; en ocasiones empleados por compañías que dependen de OpenStreetMap para el "mapa base" de sus productos, como mapbox.com y carto.com. 

Toda la información disponible en OpenStreetMap puede ser descargada y reutilizada por cualquier persona, ya sea accediendo al mapa online, obteniendo una copia completa de la base de datos, o accediendo a los datos vía API.

## OpenStreetMap desde R

Utilizaremos [`osmdata`](https://raw.githubusercontent.com/ropensci/osmdata/master/man/figures/title.png), un paquete de R que permite acceder a los datos de OpenStreetMap (OSM de aquí en más) con sus atributos, geometría y posición. 

![](https://raw.githubusercontent.com/ropensci/osmdata/master/man/figures/title.png)

Como siempre, si no tenemos aún el paquete lo instalamos:

```{r eval=FALSE}
install.packages("osmdata")
```

También vamos a hacer uso del paquete `leaflet`, que nos va a permitir generar de forma muy rápida mapas interactivos. 

```{r eval=FALSE}
install.packages("leaflet")
```

Y los activamos junto a otros paquetes que vamos a utilizar:

```{r eval=FALSE}
library(osmdata)
library(leaflet)
library(tidyverse) # nuestra navaja suiza para manipulación y visualización de datos
library(sf) # para procesar info espacial
```

```{r echo=FALSE}
library(osmdata)
library(leaflet)

# Estos paquetes ya fueron activados para el capitulo anterior
# library(tidyverse) # nuestra navaja suiza para manipulación y visualización de datos
# library(sf) # para procesar info espacial
```


### Definiendo el lugar 

Antes de descargar información, definimos el lugar que queremos consultar. Éste puede ser un barrio, un municipio, un país, un continente... en este caso, lo intentaremos con la ciudad de Rosario.

Las funciones de `osmdata` nos permiten realizar consultas a Overpass (http://overpass-api.de/), una interfaz que permite extraer información de la base de datos global de OpenStreetMap. Overpass requiere que se especifique una "bounding box", es decir las coordenadas de un rectángulo que abarque la zona de interés.

Podemos obtener la bounding box de cualquier lugar con la función `getbb()`:


```{r}
bbox <- getbb("Rosario, Santa Fe")
bbox
```


Con `getbb()` también podemos obtener un polígono con los límites políticos, las fronteras exactas, de un lugar. Esto es muy útil para realizar mapas, o para filtrar la información que obtendremos luego para quedarnos sólo con la que corresponda a nuestra ciudad de interés, descartando la de áreas aledañas:


```{r}
bbox_poly <- getbb("Municipio de Rosario, Santa Fe", format_out = "sf_polygon")
```

Para asegurarnos de que tenemos el lugar que queremos, y no otro de nombre similar en alguna otra parte del mundo, lo verificamos en un mapa rápido provisto vía `leaflet`:


```{r eval=FALSE}
leaflet(bbox_poly) %>%
    addTiles() %>% 
    addPolygons()
```


```{r echo=FALSE}
leaflet(bbox_poly) %>% 
    addProviderTiles(provider = "OpenStreetMap") %>% 
    addPolygons()
```

Luce bien, así que continuamos.

### Extrayendo información de OpenStreetMap

El siguiente paso es utilizar la función `add_osm_feature()` para especificar los datos que queremos descargar. Esto requiere conocer las palabras clave con las que se identifican los registras en la base de OSM, que permiten indicar con gran detalle el tipo de datos georeferenciados que queremos: ya sean áreas de parques públicos, posición de oficinas de correo o cajeros automáticos, vías de ferrocarril... u otro, en un larguísimo etcétera que se puede consultar en https://wiki.openstreetmap.org/wiki/Map_Features   
En este caso vamos a solicitar todas las vías de circulación (calles, avenidas, autopistas, etc) de la ciudad. En la base de datos de OSM todas aparecen con la clave _"highway"_.

```{r}
rosario <- opq(bbox) %>% 
    add_osm_feature(key = "highway")
```

Observemos que lo único que hemos obtenido hasta ahora es la definición de una consulta (qué y en dónde), pero aun no descargamos ningún dato:

```{r}
rosario
```


Es sólo la definición de una consulta a la base de datos de OpenStreetMap: "Todas las calles (objetos con clave "highway") dentro de éste rectángulo (que sabemos, corresponde a Rosario)". Para hacer efectiva la consulta y descargar los datos, la pasamos por la función `osmdata_sf()` que recolecta lo que buscamos y lo entrega en forma de dataset espacial: 


```{r}
rosario <- rosario %>% 
    osmdata_sf()
```

La descarga de información para una ciudad grande puede tomar varios minutos, y más aún la de un área metropolitana (o país, o continente, etc) así que es normal esperar un poco en ésta parte.

En cuanto se completa, ya tenemos calles:

```{r}
rosario
```

La consulta devolvió toda la información de puntos, líneas y polígonos disponibles en la base de OSM. A nos otros nos interesan las líneas, _"osm_lines"_, que demarcan la traza de las calles. Los registros con otras geometrías, como polígonos, pueden representar elementos asociados a las calles como bulevares o áreas de vereda que no vamos a usar por el momento.

Del conjunto de datos disponibles, extraemos el dataframe con líneas, y chequeamos los atributos disponibles. Todos han sido recopilados por la comunidad de OpenStreetMap.

```{r}
calles <- rosario$osm_lines

# mostramos sólo las primeras 10 columnas... porque tiene montones!
head(calles[1:10,]) 
```

### Visualizando los resultados

Dado que las calles han sido descargadas en formato `sf`, podemos visualizarlas con `ggplot:` y `geom_sf`:


```{r}
ggplot() +
    geom_sf(data = calles)
```

Las calles exceden los límites de Rosario, ya que tenemos todos los datos encontrados dentro del rectángulo de la _bounding box_. Para "recortar" los datos conservando solo las calles de la ciudad, podemos extraer su intersección con el polígono de límites que obtuvimos antes.

```{r}
calles <- st_intersection(calles, bbox_poly)
```

Ahora si!

```{r}
ggplot() +
    geom_sf(data = calles)
```


Podemos visualizar atributos de las calles, por ejemplo el de la velocidad máxima permitida, que está presente para casi todas. Pero antes va a ser necesario limpiar un poco los datos... como es usual.

Los _dataframes_ en formato `sf` que crea `osmdata` tienen todos los valores en formato texto, incluso aquellos que son números como _maxspeed_ (la velocidad máxima), o _lanes_, la cantidad de carriles. Lo arreglamos:


```{r}
calles <- calles %>% 
  mutate(maxspeed = as.numeric(maxspeed),
         lanes = ifelse(is.na(lanes), 1, as.numeric(lanes)))
```

Con eso tenemos limpias las variables de velocidad máxima y ancho en carriles. Listos para visualizar.

```{r}
ggplot(calles) +
    geom_sf(aes(color = maxspeed), alpha = 0.5) +
    scale_color_viridis_c() +
      theme_void() +
    labs(title = "Rosario",
         subtitle = "Vías de circulación",
         caption = "fuente: OpenStreetMap",
         color = "velocidad máxima")
```

O podemos revisar la posición de las avenidas:

```{r}
ggplot() +
    geom_sf(data = calles,
             color = "gray40", alpha = .5) +
    geom_sf(data = filter(calles, str_detect(name, "Avenida")), 
            color = "salmon") +
    theme_void() +
      labs(title = "Rosario",
         subtitle = "Avenidas",
         caption = "fuente: OpenStreetMap")
```


## Un ejercicio más: ¡Bares en el barrio!


Imaginemos que estamos interesados en identificar y caracterizas los bares presentes en un barrio determinado, como San Telmo en la Ciudad de Buenos Aires. Como punto de partida, podemos consultar la base de OSM a ver que encontramos.

Comenzamos por definir nuestra área de interés

```{r eval=FALSE}
bbox_st <- getbb('San Telmo, Ciudad Autonoma de Buenos Aires')

bbox_st_poly = getbb('San Telmo, Ciudad Autonoma de Buenos Aires', format_out = "sf_polygon")

leaflet(bbox_st_poly) %>% 
  addTiles() %>% 
  addPolygons()

```


```{r echo=FALSE}
bbox_st <- getbb('San Telmo, Ciudad Autonoma de Buenos Aires')

bbox_st_poly <- getbb('San Telmo, Ciudad Autonoma de Buenos Aires', format_out = "sf_polygon")

leaflet(bbox_st_poly) %>% 
  addProviderTiles(provider = "OpenStreetMap") %>% 
  addPolygons()
```

Habiendo verificado que tenemos el área correcta, armamos una consulta por la grilla de calles, y la ejecutamos.

```{r}
SanTelmo_calles <- opq(bbox_st) %>% 
    add_osm_feature(key = "highway") %>% 
    osmdata_sf()
```

Y también descargamos información sobre la posición de bares. Habiendo revisado https://wiki.openstreetmap.org/wiki/Map_Features, sabemos que para obtener bares necesitamos la categoría "amenity", y el subtipo "bar". En términos de OSM, `key = "amenity", value = "bar"`:

```{r}
SanTelmo_bares <- opq(bbox_st) %>% 
  add_osm_feature(key = "amenity", value = "bar") %>% 
  osmdata_sf() 
```


Extraemos la información dentro de los límites exactos del barrio. 

A diferencia de las calles, que aparecen en la geometría de líneas, para los bares nos interesan los puntos.

```{r}
SanTelmo_calles <- st_intersection(SanTelmo_calles$osm_lines, bbox_st_poly)
SanTelmo_bares <- st_intersection(SanTelmo_bares$osm_points, bbox_st_poly)
```

Y listos para mapear! De paso, resaltamos aquellos donde se baila tango, al colorear según el atributo "dance.style", incluido en los datos.

```{r}
ggplot() +
  geom_sf(data = SanTelmo_calles, 
            color = "darkslateblue") +
  geom_sf(data = SanTelmo_bares, 
            aes(color = dance.style)) +
  geom_sf_label(data = SanTelmo_bares, 
                  aes(label = name), size = 2) +
  theme_void() +
  labs(title = "San Telmo",
       subtitle = "Bares",
       caption = "fuente: OpenStreetMap",
       color = "Ofrecen baile")
```

Casi listo. Antes de darnos por satisfechos, tenemos que mejorar la ubicación de las etiquetas, que se superponen por la proximidad de los lugares.

Por el momento geom_sf_label() -la geometría de ggplot que permite graficar etiquetas de datos _sf_- no incluye la útil opción de correr la posición de las etiquetas en forma automática para que no se solapen. Por suerte, existe un pequeño paquete, `ggsflabel`, que provee la funcionalidad que necesitamos.

Podemos instalar el paquete directo desde el repositorio de su autor:

```{r eval=FALSE}
install.packages("devtools")
devtools::install_github("yutannihilation/ggsflabel")
```

```{r}
library(ggsflabel)
```


Y ahora, usamos `geom_sf_label_repel()` para la versión final de nuestro mapa de bares en San Telmo:

```{r}
ggplot() +
  geom_sf(data = SanTelmo_calles, 
            color = "darkslateblue") +
  geom_sf(data = SanTelmo_bares, 
            aes(color = dance.style)) +
  geom_sf_label_repel(data = SanTelmo_bares, 
                  aes(label = name), size = 2) +
  theme_void() +
  labs(title = "San Telmo",
       subtitle = "Bares",
       caption = "fuente: OpenStreetMap",
       color = "Ofrecen baile")
```


## Ejercicios

**Explorando y mapeando información georreferenciada de OpenStreetMap**

I. Descargar de OpenStreetMap la grilla de calles para la Ciudad elegida en el capítulo 2 (Geoprocesamiento) y mapearla por uno de sus atributos (velocidad mínima, velocidad máxima, cantidad de carriles, etc).

II. Descargar de OpenStreetMap una (o más) capas de datos de tipo puntos o polígonos. Ver catálogo de categorías en [este link](https://wiki.openstreetmap.org/wiki/Map_Features)
a. Proyectar los datos descargados en un mapa y comentar los resultados: ¿Cómo se distribuyen en la Ciudad?
b. Hacer un conteo de los ítems de la capa descargada por barrio, mapearlo y compararlo con el conteo de los ítems descargados en el ejercicio anterior: ¿La distribución es similar o hay diferencias? ¿A qué se puede deber?