Last week, we started talking about spatial operations. This week, we will work on geometry operations: these are spatial operations that require us to transform the geometry of our data. As you’ll see, many of these operations perform similar tasks as the functions we learned last week. Topic 5 and topic 6 are intended to help you build your toolkit of spatial operations; next class, we will practice those skills.

#load in packages
library(sf)     
library(dplyr)   
library(spData) 
library(urbnmapr)
library(ggplot2)
#Load in our rivers data
setwd("~/Binghamton/geog380/rivers")
Warning: The working directory was changed to C:/Users/mhaller/Documents/Binghamton/geog380/rivers inside a notebook chunk. The working directory will be reset when the chunk is finished running. Use the knitr root.dir option in the setup chunk to change the working directory for notebook chunks.

#That map is pretty hard to see - let's focus on Broome county
broome <- counties %>% filter(county_name == "Broome County")
broome_hydro <- river_shape[broome,]

ggplot() +
  geom_sf(data = broome,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = broome_hydro,
          mapping = aes(), color = "blue")+
  theme_minimal()

Our first geometry operation involves simplification - sometimes, we won’t need a large degree of geographic detail in order to effectively convey spatial information. Simplified map layers may be easier to visualize and more efficient to work with than larger, more complex shape files.

#Let's simplify those lines!

river_simp = st_simplify(broome_hydro, dTolerance = 10000)

ggplot() +
  geom_sf(data = broome,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = river_simp,
          mapping = aes(), color = "blue")+
  theme_minimal()

Now, let’s compare the two!


a <- ggplot() +
  geom_sf(data = broome,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = broome_hydro,
          mapping = aes(), color = "blue")+
  theme_minimal()

b <- ggplot() +
  geom_sf(data = broome,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = river_simp,
          mapping = aes(), color = "blue")+
  theme_minimal()

library(cowplot)

plot_grid(a, b)

Last week, we also learned how to find the centroid of a spatial unit (e.g. polygon) using st_centroid(). One thing to note is that the most central point on a polygon doesn’t always fall within that polygon - here we’ll learn another function that we can use to ensure that our centroids are within the polygons.


#Create centroids
points <- st_point_on_surface(counties)
Warning: st_point_on_surface assumes attributes are constant over geometries of x
 ggplot() +
  geom_sf(data = counties,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = points,
          mapping = aes(), color = "blue")+
  theme_minimal()

NA
NA

This is what a centroid actually looks like! Again, these become most useful for calculating distances.

Let’s compare the two methods:


centroids <- st_centroid(counties)
Warning: st_centroid assumes attributes are constant over geometries of x
ggplot() +
  geom_sf(data = counties,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = points,
          mapping = aes(color = "Point on Surface"))+
  geom_sf(data = centroids, mapping = aes(color = "Centroids"))+
  theme_minimal()+
  scale_color_manual(labels = c("Point on Surface", "Centroids"),
                     values = c("blue", "red"))+
  labs(color = "Point Type")

Next, we’ll move on to buffers! I’ll show you what it is, and then we’ll talk about the ways that you might use a buffer. Buffering creates a new polygon that is within a certain distance of the original, and it looks like this:

river_buff_500 = st_buffer(broome_hydro, dist = 500)


ggplot() +
  geom_sf(data = broome,
    mapping = aes(), color = "lightgray")+
    geom_sf(data = river_buff_500,
          mapping = aes(), color = "yellow")+
  geom_sf(data = broome_hydro,
          mapping = aes(), color = "blue")+
  theme_minimal()

How or why would you use this? Let’s say I am trying to figure out the location for a new building. I don’t want it to be too close to any rivers, or flooding would be a risk - I can use a buffer to visualize locations that are a certain distance (e.g. 1 km) away.

Next, we’ll move on to spatial clipping.

With spatial clipping, I can create a new map layer with its own geometry based on the intersection of two existing layers. In order to technically use spatial clipping, we need somewhat complex geometry types (e.g. lines and polygons - points technically don’t work here). In this line example, the road lines will be cut off to only retain the road segments that intersected with rivers.

What makes this a geometry operation? I’m not just selecting features based on the intersection of two spatial layers - I am creating a new object with its own unique geometry. That is technically what sets geometry operations apart from other kinds of spatial operations (don’t worry though, I won’t quiz you on that).

So, this is helpful, but what if I wanted the actual points where the bridges are located? This is not technically clipping, but we can do that, too!

Finally, we’ll look at geometry unions! This will typically involve aggregating/summarising spatial information at one level (e.g. the county level) up to a higher scale (e.g. the regional level). For example, using our NYS data:

Resources

Lovelace, R., Nowosad, J., Muenchow. J. (2019). Geocomputation with R. Retrieved from: https://geocompr.robinlovelace.net/.

New York State (2022). New York State Statewide Covid-19 Testing. [Data Set]. Retreived from: https://health.data.ny.gov/Health/New-York-State-Statewide-COVID-19-Testing/xdss-u53e.

NYS GIS Clearinghouse (2022). NYS Streets. [Data Set]. Retrieved from: http://gis.ny.gov/gisdata/.

NYS GIS Clearinghouse (2022). NYS Hydrography. [Data Set]. Retrieved from: http://gis.ny.gov/gisdata/.

---
title: "Geog 380A Topic 6: Geometry Operations"
output: html_notebook
---
Last week, we started talking about spatial operations. This week, we will work on geometry operations: these are spatial operations that require us to transform the geometry of our data. As you'll see, many of these operations perform similar tasks as the functions we learned last week. Topic 5 and topic 6 are intended to help you build your toolkit of spatial operations; next class, we will practice those skills. 


```{r}
#load in packages
library(sf)     
library(dplyr)   
library(spData) 
library(urbnmapr)
library(ggplot2)
```

```{r}
#Load in our rivers data
setwd("~/Binghamton/geog380/rivers")
river_shape <- st_read("LinearHydrography.shp")

river_shape <- river_shape %>% st_transform("EPSG:32116")
```
```{r}
#Map it!

#load in NYS county shape file and set crs
counties <- get_urbn_map("counties", sf = TRUE)

#filter the data to get just NYS
counties <- counties %>% 
  filter(state_abbv == "NY") %>% 
  st_transform("EPSG:32116")

#Let's map them now!
ggplot() +
  geom_sf(data = counties,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = river_shape,
          mapping = aes(), color = "blue")+
  theme_minimal()
```

```{r}
#That map is pretty hard to see - let's focus on Broome county
broome <- counties %>% filter(county_name == "Broome County")
broome_hydro <- river_shape[broome,]

ggplot() +
  geom_sf(data = broome,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = broome_hydro,
          mapping = aes(), color = "blue")+
  theme_minimal()
```

Our first geometry operation involves simplification - sometimes, we won't need a large degree of geographic detail in order to effectively convey spatial information. Simplified map layers may be easier to visualize and more efficient to work with than larger, more complex shape files. 
```{r}
#Let's simplify those lines!

river_simp = st_simplify(broome_hydro, dTolerance = 10000)

ggplot() +
  geom_sf(data = broome,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = river_simp,
          mapping = aes(), color = "blue")+
  theme_minimal()
```

Now, let's compare the two!

```{r}

a <- ggplot() +
  geom_sf(data = broome,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = broome_hydro,
          mapping = aes(), color = "blue")+
  theme_minimal()

b <- ggplot() +
  geom_sf(data = broome,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = river_simp,
          mapping = aes(), color = "blue")+
  theme_minimal()

library(cowplot)

plot_grid(a, b)

```
Last week, we also learned how to find the centroid of a spatial unit (e.g. polygon) using st_centroid(). One thing to note is that the most central point on a polygon doesn't always fall within that polygon - here we'll learn another function that we can use to ensure that our centroids are within the polygons.
```{r}

#Create centroids
points <- st_point_on_surface(counties)

 ggplot() +
  geom_sf(data = counties,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = points,
          mapping = aes(), color = "blue")+
  theme_minimal()


```
This is what a centroid actually looks like! Again, these become most useful for calculating distances. 

Let's compare the two methods:

```{r}

centroids <- st_centroid(counties)

ggplot() +
  geom_sf(data = counties,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = points,
          mapping = aes(color = "Point on Surface"))+
  geom_sf(data = centroids, mapping = aes(color = "Centroids"))+
  theme_minimal()+
  scale_color_manual(labels = c("Point on Surface", "Centroids"),
                     values = c("blue", "red"))+
  labs(color = "Point Type")
```


Next, we'll move on to buffers! I'll show you what it is, and then we'll talk about the ways that you might use a buffer. Buffering creates a new polygon that is within a certain distance of the original, and it looks like this:

```{r}
river_buff_500 = st_buffer(broome_hydro, dist = 500)


ggplot() +
  geom_sf(data = broome,
    mapping = aes(), color = "lightgray")+
    geom_sf(data = river_buff_500,
          mapping = aes(), color = "yellow")+
  geom_sf(data = broome_hydro,
          mapping = aes(), color = "blue")+
  theme_minimal()
```
How or why would you use this? Let's say I am trying to figure out the location for a new building. I don't want it to be too close to any rivers, or flooding would be a risk - I can use a buffer to visualize locations that are a certain distance (e.g. 1 km) away. 

Next, we'll move on to spatial clipping. 

```{r}
setwd("~/Binghamton/geog380/SimplifiedStreets_SHP")
street_shape <- st_read("SimplifiedStreetSegmentQrt.shp")

street_shape <- street_shape %>% st_transform("EPSG:32116")
broome_streets <- street_shape[broome, , op = st_within]
broome_streets1 <- street_shape[broome, , op = st_intersects]

ggplot() +
  geom_sf(data = broome,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = broome_streets,
          mapping = aes(), color = "gray10")+
  theme_minimal()
```
With spatial clipping, I can create a new map layer with its own geometry based on the intersection of two existing layers. In order to technically use spatial clipping, we need somewhat complex geometry types (e.g. lines and polygons - points technically don't work here). In this line example, the road lines will be cut off to only retain the road segments that intersected with rivers.

What makes this a geometry operation? I'm not just selecting features based on the intersection of two spatial layers - I am creating a new object with its own unique geometry. That is technically what sets geometry operations apart from other kinds of spatial operations (don't worry though, I won't quiz you on that).

```{r}
#Let's get bridges in Broome county
bridges = lengths(st_intersects(broome_hydro, broome_streets)) > 0

broome_bridges <- broome_hydro[bridges,]

ggplot() +
  geom_sf(data = broome,
    mapping = aes(), color = "lightgray")+
  geom_sf(data = broome_streets, mapping = aes(), color = "gray")+
    geom_sf(data = broome_hydro,
          mapping = aes(), color = "blue")+
    geom_sf(data = broome_bridges,
          mapping = aes(), color = "brown", size = 1.2)+
  theme_minimal()
```

So, this is helpful, but what if I wanted the actual points where the bridges are located? This is not technically clipping, but we can do that, too!

```{r}
#First, I need to convert my river layer from lines to points - we'll use the intersection of these points to find bridge locations
river_points = st_cast(broome_hydro, "POINT")

ggplot() +
  geom_sf(data = broome,
    mapping = aes(), color = "lightgray")+
    geom_sf(data = river_points,
          mapping = aes(), color = "blue", size = 0.2)+
  theme_minimal()
```
```{r}
#Create a logical vector to subset our river points layer by - this is equal to TRUE if the points layer and broome streets intersect, and FALSE otherwise
#Here we are finding all the points that intersect with broome streets - if a point intersects, in the result it will have a length > 0
#Create a logical vector based on whether the lenghths are greater than 0
bridges = lengths(st_intersects(river_points, broome_streets)) > 0

bridges_new <- river_points[bridges,]

ggplot() +
  geom_sf(data = broome,
    mapping = aes(), color = "lightgray")+
    geom_sf(data = bridges_new,
          mapping = aes(), color = "brown", size = 1.2)+
  theme_minimal()
```

Finally, we'll look at geometry unions! This will typically involve aggregating/summarising spatial information at one level (e.g. the county level) up to a higher scale (e.g. the regional level). For example, using our NYS data:

```{r}
#Load in Covid data with region information
setwd("~/Binghamton/geog380")
covid <- read.csv("covid_data_ny.csv")

library(tidyr)
counties1 <- counties %>% 
  separate(county_name, c("county_name", "county"), sep = " County") %>% 
  select(-county)

counties1 <- counties1 %>%
  left_join(covid, by = c("county_name" = "County"))

#I don't actually care about Covid cases - summarise covid cases to get our spatial data grouped by region
regions <- counties1 %>% group_by(region) %>%
  summarize(cases = sum(new_positive, na.rm = TRUE))

#now we'll map it!
ggplot() +
  geom_sf(data = regions,
    mapping = aes(fill = region))+
  geom_sf(data = counties, mapping = aes(), fill = "transparent", color = "white")+
  theme_minimal()+
  labs(fill = "Region", title = "Regions of NYS")+
  theme(plot.title = element_text(hjust = 0.5))

```
Resources 

Lovelace, R., Nowosad, J., Muenchow. J. (2019). Geocomputation with R. Retrieved from: https://geocompr.robinlovelace.net/.

New York State (2022). New York State Statewide Covid-19 Testing. [Data Set]. Retreived from: https://health.data.ny.gov/Health/New-York-State-Statewide-COVID-19-Testing/xdss-u53e. 

NYS GIS Clearinghouse (2022). NYS Streets. [Data Set]. Retrieved from: http://gis.ny.gov/gisdata/. 

NYS GIS Clearinghouse (2022). NYS Hydrography. [Data Set]. Retrieved from: http://gis.ny.gov/gisdata/. 
