CARGANDO SHAPEFILES EN R

Un shapefile GIS es un formato de archivo para almacenar la ubicación, la

forma y los atributos de las características geográficas.
Los paquetes son:
• rgdal: enlaces para la biblioteca de abstracción de datos geoespaciales
• rgeos - Interfaz al motor de geometría - Código abierto

readOGR
Leer Mapas Vectoriales OGR En Objetos Espaciales

La función lee una fuente de datos OGR y la capa en un objeto vectorial espacial
adecuado. Solo puede manejar capas con características de geometría
conformables (no mezclas de puntos, líneas o polígonos en una sola
capa). Establecerá el sistema de referencia espacial si la capa tiene tales
metadatos.

Si lee un shapefile, el nombre de la fuente de datos ( dsn=argumento) es la carpeta

(directorio) donde está el shapefile, y la capa es el nombre del shapefile (sin la
extensión .shp). Por ejemplo, para leer bounds.shpde C:/Maps, hacerlo map <-
readOGR(dsn="C:/Maps", layer="bounds"). La lógica detrás de esto es que
normalmente uno mantiene todos los shapefiles de un proyecto en una carpeta
(directorio).

Merge para unir los shapes

Uniendo datos

Ahora necesitamos unir nuestro Census.Data al shapefile para que se puedan

mapear los atributos del censo. Como nuestro censo

Los datos contienen los nombres únicos de cada una de las áreas de salida, esto
se puede usar como clave para fusionar los datos con nuestro

archivo de área de salida (que también contiene nombres únicos de cada área de
salida). Usaremos la función merge () para

unir los datos.

Tenga en cuenta que esta vez los encabezados de columna para los nombres de
nuestras áreas de salida no son idénticos, a pesar de que

contienen los mismos datos. Por lo tanto, tenemos que usar by.xy by.ya para que
la función de combinación use el correcto

columnas para unir los datos.

Las funciones proj4string () y CRS () nos permiten establecer el sistema
de coordenadas de un shapefile a un predefinido
sistema de nuestra elección. La mayoría de los datos del Reino Unido se
proyectan utilizando British National Grid (EPSG: 27700)
producido por el Ordnance Survey, esto incluye la geografía estadística
estándar producida por la Oficina para Estadísticas nacionales.
proj4string (OA.Census) <- CRS ("+ init = EPSG: 27700")
Mapeo de datos en R
Mientras que la función de la trama es bastante limitada en su forma
básica. Varios paquetes nos permiten mapear datos relativamente
fácilmente. También proporcionan una serie de funciones que nos
permiten adaptar y modificar el gráfico. ggplot2, para
ejemplo, le permite mapear datos espaciales. Sin embargo,
probablemente las más fáciles de usar son las funciones dentro del
biblioteca tmap.
# cargas de paquetes
biblioteca (tmap)
biblioteca (folleto)
Creando un mapa rápido
Si solo desea crear un mapa con una leyenda rápidamente, puede usar la
función qtm ().
# esto producirá un mapa rápido de nuestra variable de calificación
qtm (OA.Census, fill = "Qualification")
 Creando mapas más avanzados con tmap
La creación de mapas en tmap implica vincular varias funciones que
comprenden diferentes aspectos de la gráfico. Por ejemplo:
polígono + simbología del polígono +fronteras +diseño
Ingresamos shapefiles (u objetos de datos espaciales R) seguidos de un
comando para establecer sus simbologías. Los objetos luego se colocan en
capas en la visualización en orden. El objeto ingresado primero aparece en
la parte inferior del gráfico.
Creando un mapa simple
Aquí cargamos en el shapefile con la función tm_shape () y luego
agregamos la función tm_fill () que es
donde podemos decidir cómo se rellenan los polígonos. Todo lo que
tenemos que hacer en la función tm_shape () es llamar
el shapefile. Luego agregamos (+) una nueva función separada (tm_fill ())
para ingresar el parámetro
Observará que el mapa es muy similar al mapa rápido producido al usar la
función qtm ().
Sin embargo, la ventaja de utilizar las funciones avanzadas de tmap es que
proporcionan una amplia gama de
opciones de personalización. Los siguientes pasos demostrarán esto.
Configurar la paleta de colores
tmap le permite utilizar rampas de color definidas por el usuario o un
conjunto de rampas de color predefinidas del
Función RColorBrewer ().
tm_shape(OA.Census) + tm_fill("Qualification", palette = "-Greens")
El paquete de sp proporciona clases y métodos para tratar con datos
espaciales en
1
(R y S-Plus ). Las estructuras de datos espaciales implementadas
incluyen puntos,
líneas, polígonos y cuadrículas; cada uno de ellos con o sin datos de
atributos

Asignación de datos de puntos en R

• Cree un shapefile de puntos a partir de un CSV usando coordenadas
• Mapear los puntos en tmap
• Crea un mapa de burbujas proporcional
Cargando datos de puntos en R
En esta práctica, manejaremos los datos del precio de la vivienda pagado
originalmente disponibles de forma gratuita por el Land
Registro. El conjunto de datos de muestra se puede descargar del sitio web del CDRC
aquí. Los datos tienen el formato
CSV donde cada fila es una venta de casa única, incluido el precio pagado en libras y el
código postal. Antes de
En esta práctica, el archivo de datos se unió a la tabla de búsqueda de códigos postales
de la Oficina de Estadísticas Nacionales (ONS) que
proporciona coordenadas de latitud y longitud para cada código postal.
# cargar el archivo csv de precios de la vivienda
casas <- read.csv ("CamdenHouseSales15.csv")
# solo necesitamos unas pocas columnas para esta práctica
casas <- casas [, c (1,2,8,9)]
Por lo tanto, necesitamos asignar atributos espaciales al CSV para que se pueda
mapear correctamente en R. Para hacer esto
necesitaremos cargar el paquete sp, este paquete proporciona clases y métodos para
manejar datos espaciales.
A continuación, convertiremos el CSV en un SpatialPointsDataFrame. Para hacer esto,
necesitaremos establecer cuáles son los datos a incluir, qué columnas contienen las
coordenadas x e y, y qué sistema de proyección estamos usando.biblioteca ("sp")
# crear un House.Points SpatialPointsDataFrame
House.Points <-SpatialPointsDataFrame (casas [, 3: 4], casas,
proj4string = CRS ("+ init = EPSG: 27700"))
Ahora podemos agregar los puntos como una capa tm_shape adicional en nuestro
mapa.
Para hacer esto, copiamos el mismo código para hacer el mapa base, agregamos un
símbolo más, luego ingresamos los detalles paralos datos de los puntos. Los
argumentos adicionales para los datos de puntos se pueden resumir como:
tm_shape(polygon file) + tm_borders(transparency = 40%) +tm_shape(our spatial
points data frame) + tm_dots(what variable is coloured,
la paleta de colores y el estilo de intervalo)
Que se ingresa en R así:
# crea un mapa de puntos de color
tm_shape(OA.Census) + tm_borders(alpha=.4) +tm_shape(House.Points) + tm_dots(col
= "Price", palette = "Reds", style = "quantile")

También podemos agregar más argumentos dentro de la función tm_dots () para

puntos como lo haríamos con tm_fill () para datos de polígono. Algunos argumentos
son exclusivos de tm_dots (), por ejemplo, la opción scale
tm_shape(OA.Census) + tm_borders(alpha=.4) + tm_shape(House.Points) +
tm_dots(col = "Price", scale = 1.5, palette = "Reds", style = "quantile", title = "Price Paid
(£)")
tmap_mode("view")-------Ver de manera interactiva
library(leaflet) # para mapas interactivos

Crear mapas de símbolos proporcionales

También podemos crear símbolos proporcionales en tmap. Para hacerlo en tmap,
reemplazamos la función tm_dots () con la función tm_bubbles (). En el siguiente
ejemplo, el tamaño y los colores se establecen como columna de precios.
# crea un mapa de símbolos proporcional
tm_shape(OA.Census) + tm_borders(alpha=.4) +tm_shape(House.Points) +
tm_bubbles(size = "Price", col = "Price",palette = "Blues", style =
"quantile",legend.size.show = FALSE,
title.col = "Price Paid (£)") +tm_layout(legend.text.size = 1.1, legend.title.size = 1.4,
frame = FALSE)
También podemos hacer que el shapefile poligonal muestre una de nuestras variables
del censo como un mapa de coropletas como se muestra
abajo. En este ejemplo también hemos agregado algunos parámetros más dentro de la
función tm_bubbles () para crear
bordes finos alrededor de las burbujas.

# crea un mapa de símbolos proporcional

tm_shape(OA.Census) + tm_fill("Qualification", palette = "Reds",
style = "quantile", title = "% Qualification") +
tm_borders(alpha=.4) +
tm_shape(House.Points) + tm_bubbles(size = "Price", col = "Price",
palette = "Blues", style = "quantile",
legend.size.show = FALSE,
title.col = "Price Paid (£)",
border.col = "black", border.lwd = 0.1,
border.alpha = 0.1) +
tm_layout(legend.text.size = 0.8, legend.title.size = 1.1, frame = FALSE)
 USANDO R COMO SIG
Esta práctica está destinada a proporcionar una demostración de algunas
de las funciones espaciales básicas de R tomando
usted a través de una pequeña cantidad de técnicas comúnmente
empleadas. Los datos de las prácticas se pueden descargar
de la página de inicio de Introducción al análisis y visualización de datos
espaciales en R.
En este tutorial vamos a:
• Ejecutar una operación de punto en polígono
• Crear búferes
• Agregar mapas de respaldo de Google
• Crea mapas interactivos con tmap PAG 61

sp : define clases (estructuras de datos) para puntos, líneas, polígonos,

rásteres y sus atributos, y funciones relacionadas para, por ejemplo, trazar. Las
clases principales son SpatialPoints, SpatialLines, SpatialPolygons, SpatialGrid
(todas también con 'DataFrame' agregado si las geometrías tienen atributos)

ráster : define clases alternativas para datos ráster (RasterLayer, RasterStack,

RasterBrick) que se pueden utilizar para conjuntos de datos muy grandes. El
paquete también proporciona muchas funciones para manipular datos
ráster. También se extiende a paquetes sp y rgeos para manipular datos de
tipo vectorial

rgdal : lee o escribe archivos de datos espaciales (el raster lo usa detrás de
escena).

rgeos : manipulación de geometría para datos vectoriales (por ejemplo,

intersección de polígonos) y asuntos relacionados.
Con las proyecciones configuradas, ahora es posible asignar a cada punto de la casa las
características del área de salida al polígono en el que cae

OVER : Superposición Espacial Consistente Para Puntos, Cuadrículas Y Polígonos

pip <- over (House.Points, oa.census)
House.Points@data <- cbind(House.Points@data, pip)
View(House.Points@data)
OA <- aggregate(House.Points@data$Price, by = list(House.Points@data$OA11CD),
mean)

Amortiguadores Una segunda técnica que demostraremos es el almacenamiento en

búfer. Este es un proceso GIS mediante el cual creamos lineales
captaciones para cada punto de datos en función de la distancia.
Esta sencilla técnica se usa comúnmente para determinar
qué áreas están próximas a ciertos objetos. Aquí usamos la función
gBuffer () del paquete rgeos.
# crear zonas de influencia de 200 m para cada punto de la casa
house_buffers <- gBuffer (House.Points, ancho = 200, byid = TRUE)
Podemos trazarlos en tmap.
# mapa en tmap
tm_shape (OA.Census) + tm_borders () +
tm_shape (house_buffers) + tm_borders (col = "azul") +
tm_shape (House.Points) + tm_dots (col = "rojo")

Esta práctica le presentará la ejecución de una estimación de densidad de kernel en R.

La estimación de densidad de kernel es una
medios comúnmente utilizados para representar densidades de puntos de datos
espaciales. La técnica produce un suave y
superficie continua donde cada píxel representa un valor de densidad basado en el
número de puntos dentro de un determinado
ancho de banda de distancia. También cubriremos algunas técnicas básicas en el
manejo y edición de shapefiles ráster. Datos
para la práctica se puede descargar de la Introducción al análisis y visualización de
datos espaciales
en la página de inicio de R.
En este tutorial vamos a:
• Ejecute una estimación de la densidad del kernel
• Crear un shapefile ráster
• Asignar un shapefile ráster en tmap
• Utilice una técnica de máscara para recortar un ráster
Primero debemos configurar el directorio de trabajo y cargar los datos prácticos.
# Establecer el directorio de trabajo
setwd ("C: / Users / Guy / Documents / Teaching / CDRC / Practicals")
También necesitaremos cargar los archivos de datos espaciales de las prácticas
anteriores.
# cargar las bibliotecas espaciales
biblioteca ("sp")
biblioteca ("rgdal")
biblioteca ("rgeos")
# Cargue los shapefiles del área de salida, esta vez no los uniremos a ningún dato
Output.Areas <- readOGR (".", "Camden_oa11")
## Fuente de datos OGR con controlador: ESRI Shapefile
## Fuente: ".", Capa: "Camden_oa11"
## con 749 funciones
## Tiene 1 campos
# cargar los archivos de puntos de las casas
House.Points <- readOGR (".", "Camden_house_sales")
## Fuente de datos OGR con controlador: ESRI Shapefile
## Fuente: ".", Capa: "Camden_house_sales"
## con 2547 funciones
## Tiene 4 campos
Ejecución de una estimación de densidad de kernel
Si bien es sencillo determinar la frecuencia de un fenómeno en el espacio con datos
poligonales, es
más complicado medir densidades de puntos de manera coherente. Un enfoque
relativamente simple sería utilizar
zonas de polígono para agregar espacialmente los datos (como hicimos en la práctica
7), y luego contar el número de
ocurrencias en cada área.
Sin embargo, las técnicas que se han ideado para representar las densidades de puntos
de datos en dos dimensiones
también existen. Uno de estos enfoques, conocido como estimación de la densidad del
núcleo, utiliza un cuadrante móvil para calcular
la densidad para cada área dentro de un umbral dado. Para obtener más información
sobre las estadísticas detrás del kernel
medidas de densidad, lea la página web de Análisis geoespacial (de Smith et al, 2015)
sobre densidad, núcleos
y ocupación
.....................
El siguiente código ejecutará una estimación de densidad de kernel para nuestros
datos de precios de vivienda del Registro de la Propiedad. Existen
Varias formas diferentes de ejecutar esto a través de R, usaremos las funciones
disponibles de adehabitatHR
paquete.
# cargar las bibliotecas espaciales
biblioteca (raster)
biblioteca (adehabitatHR)
# ejecuta la estimación de la densidad del kernel, busque los parámetros de la función
para obtener más opciones
kde.output <- kernelUD (House.Points, h = "href", grid = 1000)
trama (salida kde)

.....................
También podemos crear gráficos de contorno en R. Simplemente ingrese contorno
(kde) en R. Para mapear el ráster en tmap,
Primero es necesario asegurarse de que se haya proyectado correctamente.
# convierte a ráster
kde <- ráster (kde.output)
# establece la proyección en British National Grid
proyección (kde) <- CRS ("+ init = EPSG: 27700")
biblioteca (tmap)
# mapea el ráster en tmap, "ud" es la variable de densidad
tm_shape (kde) + tm_raster ("ud")
,,,,,,,,,,,,,,,,,,,,,,,,,
Casi podemos distinguir la forma de Camden. Sin embargo, en este caso, el ráster
incluye una gran cantidad de
espacio, podemos acercar Camden configurando el mapa en la extensión de un cuadro
delimitador.
# crea un cuadro delimitador basado en la extensión del polígono Output.Areas
cuadro_delimitado <- bb (Áreas de salida)
# mapea el ráster dentro del cuadro delimitador
tm_shape (kde, bbox = delimitador_box) + tm_raster ("ud")

También podemos enmascarar (o recortar) el ráster por el polígono de las áreas de

salida y ordenar el gráfico. Esta operacion
solo conserva las partes del ráster que están dentro de la extensión espacial del
polígono de enmascaramiento.
# enmascarar el ráster por el polígono del área de salida
masked_kde <- máscara (kde, Output.Areas)
# asigna el ráster enmascarado, también asigna los límites del área de salida en blanco
tm_shape (masked_kde, bbox = bounding_box) + tm_raster ("ud", style = "cuantil",
n = 100,
legend.show = FALSE,
paleta = "YlGnBu") +
tm_shape (Output.Areas) + tm_borders (alpha = .3, col = "white") +
tm_layout (marco = FALSO)
Identificar los rangos caseros
También podemos crear límites de captación a partir de las estimaciones de densidad
de kernel.
# calcular rangos de casa para el 75%, 50%, 25% de los puntos,
# los objetos se devuelven como marcos de datos poligonales espaciales
range75 <- getverticeshr (kde.output, porcentaje = 75)
range50 <- getverticeshr (kde.output, porcentaje = 50)
range25 <- getverticeshr (kde.output, porcentaje = 25)
Con los rangos calculados, podemos mapearlos juntos en tmap. Observe que este
tmap combina múltiples
capas. Recuerde que la capa al final de la lista es la última en imprimirse y, por lo tanto,
aparecerá
en la parte delantera del gráfico.
A primera vista, el código parece bastante complicado. Entonces, para resumir, cada
línea hace lo siguiente. . .
. Cree un fondo gris utilizando el polígono Output.Areas con bordes blancos