index.qmd

---
format:
  html:
    theme: [source/custom.scss, none]
editor: source
execute:
  echo: false
  output: false
  cache: true
---

::: setup
{{< include source/scrollytelling.qmd >}}

```{r}
#| include: false
# Read functions & packages
# Only the github version of leaflet supports terra, in place of raster, which is now required as sp (on which raster depends) is being deprecated
# devtools::install_github('rstudio/leaflet')
source("source/fns.R")
source("source/helpers.R")

city_dir <- file.path("mnt/", readLines("city-dir.txt"))
user_input_dir <- file.path(city_dir, "01-user-input/")
process_output_dir <- file.path(city_dir, "02-process-output/")
spatial_dir <- file.path(process_output_dir, "spatial/")
output_dir <- file.path(city_dir, "03-render-output/")
styled_maps_dir <- "generated/styled-maps/"

# City parameters
city_params <- read_yaml(file.path(user_input_dir, "city_inputs.yml"))
# cities <- list.files("cities")
city <- city_params$city_name
city_string <- tolower(city) %>% stringr::str_replace_all(" ", "-")
country <- city_params$country_name

# Load map layer parameters
layer_params_file <- 'source/layers.yml' # Also used by fns.R
layer_params <- read_yaml('source/layers.yml')
```

```{r}
#| freeze: auto
#| label: prerender
# source('_pre-render.R')
```

```{r}
#| include: false
#| label: visualization_parameters
# Visualization parameters (Am I using all of them?)
# Interactivve Plots (Leaflet)
basemap_opacity <- 0.3
legend_opacity <- 0.8
vwidth <- 900
vheight <- vwidth

# Static map
layer_alpha <- 0.8
map_width <- 6.9
map_height <- 5.9
aspect_ratio <- map_width / map_height

# this is to enable fractional zoom in mapshot
useragent <- 'Mozilla/5.0 (compatible; MSIE 10.6; Windows NT 6.1; Trident/5.0; InfoPath.2; SLCC1; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729; .NET CLR 2.0.50727) 3gpp-gba UNTRUSTED/1.0'
```

---
title: "`r paste(city, country, sep = ', ')`, City Scan"
---

```{r}
# Get text
city_text <- read_md(file.path(user_input_dir, "text-files/manual-text.md"))
generic_text <- read_yaml("source/generic-text.yml") %>% rapply(double_space, how = "replace") # Do I only want this for print?
slide_texts <- merge_lists(city_text, generic_text)
```

```{r}
#| include: false

# Define the AOI
aoi <- st_zm(st_read(file.path(user_input_dir, "AOI")))
aoi_bounds <- st_bbox(aoi)
static_map_bounds <- aspect_buffer(aoi, aspect_ratio, buffer_percent = 0.05)

# Create basemaps
## Interactive: Inititate the map here, will build on it in each "slide"
all_maps <- plot_basemap("vector")
## Static:
zoom <- round(14.6 + -0.00015 * units::drop_units(sqrt(st_area(aoi))))
tiles <- annotation_map_tile(type = "cartolight", zoom = zoom)

# Keep track of added layers
added_layers <- c()
```
:::

::: topbar
# {{< meta title >}}

::: navigation
```{r}
#| output: asis
# Dynamically add sections to table of contents ... there's probably a better way?
sections <- readLines("index.qmd") %>%
  subset(str_detect(., "^##")) %>% str_replace("# ", "- ") %>% str_replace_all("#", "  ")

anchors <- sections %>% str_extract("^\\s*- (.*$)", group = T) %>% tolower() %>% str_replace_all(c("[^a-z\\s]" = "", "\\s+" = "-")) %>%
  str_replace("(.*)", "(#\\1)")

paste0(str_replace(sections, "(^\\s*- )(.+$)", "\\1[\\2]"), anchors) %>% { cat("- <span id='dynamic-header'>City Scan</span>  &or;", ., sep = "\n") }
```

[Inputs version](https://bennotkin.quarto.pub/gagarin-city-scan-form/)

:::
:::

::: text-column

# {{< meta title >}}

## Executive Summary
```{r}
#| output: asis
print_slide_text(slide_texts$executive_summary$executive_summary)
```

## Setting the Context

### Basic City Information

```{r}
# Add a map layer? But it's just the AOI
```

```{r}
#| output: asis
print_slide_text(slide_texts$setting_the_context$basic_city_info)
```

### The State of Urban Infrastructure and Service Delivery
```{r}
#| output: asis
print_slide_text(slide_texts$setting_the_context$infrastructure_and_service_delivery)
```

## Population and Demographic Trends

### Population Growth

```{r}
#| output: asis
# include_html_chart(file.path(output_dir, "plots/html/---.html"))
```

```{r}
#| output: asis
print_slide_text(slide_texts$demographics$population_growth)
```

### Population Density (chart)

```{r}
#| output: asis
# include_html_chart(file.path(output_dir, "plots/html/---.html"))
```

```{r}
#| output: asis
print_slide_text(slide_texts$demographics$population_density_chart)
```

### Population Distribution by Age & Sex

```{r}
#| output: asis
# Necessary to remove leading white space because it triggers codeblock formatting
include_html_chart(file.path(output_dir, "plots/html/age_stats.html"))
```

```{r}
#| output: asis
print_slide_text(slide_texts$demographics$population_distribution_age_sex)
```

### Population Density

```{r}
#| include: false
#| label: pop
# Read population data
# Eventually, move fuzzy_read inside of create_layer_function
pop <- fuzzy_read(spatial_dir, "population", rast)

# Interactive Plot (Leaflet)
add_pop_layer <- create_layer_function(data = rast_as_vect(pop), yaml_key = "population")
all_maps <- add_pop_layer(all_maps)
  # This could be put into the add_*_layer() functions themselves
  # hideGroup("population-density")
added_layers <- c(added_layers, "population-density")

# Static plot (PNG)
plot_pop <- plot_static(data = pop, yaml_key = "population")
save_plot(plot = plot_pop, filename = "pop.png", directory = styled_maps_dir)
```

![](generated/styled-maps/pop.png)

```{r}
#| output: asis
print_slide_text(slide_texts$demographics$population_density)
```

### Relative Wealth Index

```{r}
#| include: false
#| label: rwi
# Read RWI
# (Don't need to include ["rwi"] because layers.yml includes data_variable)
rwi <- fuzzy_read(spatial_dir, "rwi", FUN = vect)

# Interactive Plot (Leaflet)
add_rwi_layer <- create_layer_function(
  data = rwi, yaml_key = "rwi",
  labFormat = labelFormat(digits = 1))
all_maps <- add_rwi_layer(all_maps)
  # This could be put into the add_*_layer() functions themselves
  # hideGroup("relative-wealth-index")
added_layers <- c(added_layers, layer_params[["rwi"]]$group)

# Static plot (PNG)
plot_rwi <- plot_static(data = rwi, yaml_key = "rwi") #+ theme(legend.position = "none")
save_plot(plot = plot_rwi, filename = "rwi.png", directory = styled_maps_dir)
```

![](generated/styled-maps/rwi.png)

```{r}
#| output: asis
print_slide_text(slide_texts$demographics$relative_wealth)
```

## Economic Activity

### Economic Hotspots

```{r}
#| include: false
#| label: economic_activity
economic_activity <- fuzzy_read(spatial_dir, "avg_rad_sum", rast)

# Interactive Plot (Leaflet)
add_economic_activity_layer <- create_layer_function(
  data = rast_as_vect(economic_activity), yaml_key = "economic_activity",
  labFormat = labelFormat(digits = 2))
all_maps <- add_economic_activity_layer(all_maps)
added_layers <- c(added_layers, layer_params[["economic_activity"]]$group_id)

# Static plot (PNG)
plot_economic_activity <- plot_static(data = economic_activity, yaml_key = "economic_activity")
save_plot(plot = plot_economic_activity, filename = "economic_activity.png", directory = styled_maps_dir)
```

![](generated/styled-maps/economic_activity.png)

```{r}
#| output: asis
print_slide_text(slide_texts$economic_activity$economic_hotspots)
```

### Change in Economic Hotspots

```{r}
#| include: false
#| label: economic_change
economic_change <- fuzzy_read(spatial_dir, "linfit", rast)

# Interactive Plot (Leaflet)
add_economic_change_layer <- create_layer_function(data = rast_as_vect(economic_change), yaml_key = "economic_change")
all_maps <- add_economic_change_layer(all_maps)
added_layers <- c(added_layers, layer_params[["economic_change"]]$group_id)

# Static plot (PNG)
plot_economic_change <- plot_static(data = economic_change, yaml_key = "economic_change")
save_plot(plot = plot_economic_change, filename = "economic_change.png", directory = styled_maps_dir)
```

![](generated/styled-maps/economic_change.png)

```{r}
#| output: asis
print_slide_text(slide_texts$economic_activity$economic_change)
```

### Social Distancing
*(Need sample data)*

```{r}
#| output: asis
# print_slide_text(slide_texts$demographics$social_distancing)
```

## Built Form

### Urban Extent and Change

```{r}
#| include: false
#| label: wsf
wsf <- fuzzy_read(spatial_dir, "wsf.*4326.tif$", rast)
values(wsf)[values(wsf) == 0] <- NA

# Interactive Plot (Leaflet)
add_wsf_layer <- create_layer_function(data = rast_as_vect(wsf), yaml_key = "wsf")
all_maps <- add_wsf_layer(all_maps)
added_layers <- c(added_layers, layer_params[["wsf"]]$group_id)

# Static plot (PNG)
plot_wsf <- plot_static(data = wsf, yaml_key = "wsf")
save_plot(plot = plot_wsf, filename = "wsf.png", directory = styled_maps_dir)
```

![](generated/styled-maps/wsf.png)

```{r}
#| output: asis
include_html_chart(file.path(output_dir, "plots/html/urban_built_up_area.html"))
```

```{r}
#| output: asis
print_slide_text(slide_texts$built_form$wsf)
```

### Built-up Density

```{r}
#| include: false
# impervious <- fuzzy_read(spatial_dir, "???")
# add_impervious_layer <- create_layer_function(data = impervious, yaml_key = "impervious")

# all_maps <- add_impervious_layer(all_maps)
# added_layers <- c(added_layers, "built-up-density")
```

```{r}
#| output: asis
print_slide_text(slide_texts$built_form$builtup_density)
```

### Land Cover

```{r}
#| include: false
#| label: land_cover
land_cover <- fuzzy_read(spatial_dir, "lc.tif", rast)
values(land_cover)[values(land_cover) == 0] <- NA

# Interactive Plot (Leaflet)
add_land_cover_layer <- create_layer_function(data = rast_as_vect(land_cover), yaml_key = "land_cover")
all_maps <- add_land_cover_layer(all_maps)
added_layers <- c(added_layers, "land-cover")

# Static plot (PNG)
plot_land_cover <- plot_static(data = land_cover, yaml_key = "land_cover")
save_plot(plot = plot_land_cover, filename = "land_cover.png", directory = styled_maps_dir)
```

![](generated/styled-maps/land_cover.png)

```{r}
#| output: asis
include_html_chart(file.path(output_dir, "plots/html/landcover.html"))
```

```{r}
#| output: asis
print_slide_text(slide_texts$built_form$land_cover)
```

### Intersection Density

```{r}
#| include: false
#| label: intersections
# ERROR
# intersections <- fuzzy_read(spatial_dir, "nodes", FUN = st_read)
# add_intersections_layer <- create_layer_function(data = intersections, yaml_key = "intersections")

# all_maps <- add_intersections_layer(all_maps)
# added_layers <- c(added_layers, "intersection-density")
```

```{r}
#| output: true
# plot_intersections
```

```{r}
#| output: asis
# print_slide_text(slide_texts$built_form$intersections)
```

### Access to Schools

```{r}
#| include: false
#| label: schools
# NON-STANDARD: Need to combine three separate shapefiles
school_points <- fuzzy_read(spatial_dir, "schools$", FUN = vect) 
schools_800 <- fuzzy_read(spatial_dir, "schools_800", FUN = vect)
schools_1600 <- fuzzy_read(spatial_dir, "schools_1600", FUN = vect)
schools_2400 <- fuzzy_read(spatial_dir, "schools_2400", FUN = vect)

schools_1600_only <- erase(schools_1600, schools_800)
schools_2400_only <- erase(schools_2400, schools_1600)
school_zones <- Reduce(rbind, c(schools_800, schools_1600_only, schools_2400_only)) %>% select(-level_1, -nodez)

# Interactive Plot (Leaflet)
add_school_zones_layer <- create_layer_function(data = school_zones, yaml_key = "school_zones")
add_school_points_layer <- create_layer_function(data = school_points, yaml_key = "school_points")
all_maps <- add_school_zones_layer(all_maps) %>% add_school_points_layer()
added_layers <- c(added_layers, "access-to-schools")

# Static plot (PNG)
plot_school <- plot_static(data = school_zones, yaml_key = "school_zones", plot_aoi = F)
plot_school <- plot_static(data = school_points, yaml_key = "school_points", baseplot = plot_school)
save_plot(plot = plot_school, filename = "school.png", directory = styled_maps_dir)
```

![](generated/styled-maps/school.png)

```{r}
#| output: asis
print_slide_text(slide_texts$built_form$schools)
```

### Access to Healthcare

```{r}
#| include: false
#| label: health
health_points <- fuzzy_read(spatial_dir, "health$", FUN = vect) 
health_1000 <- fuzzy_read(spatial_dir, "health_1000", FUN = vect)
health_2000 <- fuzzy_read(spatial_dir, "health_2000", FUN = vect)
health_3000 <- fuzzy_read(spatial_dir, "health_3000", FUN = vect)

health_zones <- Reduce(rbind, c(health_1000, health_2000, health_3000))

# Interactive Plot (Leaflet)
add_health_zones_layer <- create_layer_function(
  data = health_zones, yaml_key = "health_zones")
add_health_points_layer <- create_layer_function(data = health_points, yaml_key = "health_points")
all_maps <- add_health_zones_layer(all_maps) %>% add_health_points_layer()
added_layers <- c(added_layers, "access-to-healthcare")

# Static plot (PNG)
plot_health <- plot_static(data = health_zones, yaml_key = "health_zones", plot_aoi = F)
plot_health <- plot_static(data = health_points, yaml_key = "health_points", baseplot = plot_health)
save_plot(plot = plot_health, filename = "health.png", directory = styled_maps_dir)
```

![](generated/styled-maps/health.png)

```{r}
#| output: asis
print_slide_text(slide_texts$built_form$health_facilities)
```

## Climate Conditions

### Solar Photovoltaic Potential

```{r}
#| include: false
#| label: solar
solar <- fuzzy_read(spatial_dir, "solar", rast_as_vect)

# Interactive Plot (Leaflet)
add_solar_layer <- create_layer_function(data = (solar), yaml_key = "solar")
all_maps <- add_solar_layer(all_maps)
added_layers <- c(added_layers, "solar-photovoltaic-potential")

# Static plot (PNG)
plot_solar <- plot_static(data = solar, yaml_key = "solar")
save_plot(plot = plot_solar, filename = "solar.png", directory = styled_maps_dir)
```

![](generated/styled-maps/solar.png)

```{r}
#| output: asis
include_html_chart(file.path(output_dir, "plots/html/_PV_graph.html"))
```

```{r}
#| output: true
# plot_
```

```{r}
#| output: asis
print_slide_text(slide_texts$climate_conditions$solar)
```

### Air Quality

```{r}
#| include: false
#| label: air
air_quality <- fuzzy_read(spatial_dir, "air", rast)

# Interactive Plot (Leaflet)
add_air_quality_layer <- create_layer_function(data = rast_as_vect(air_quality), yaml_key = "air_quality")
all_maps <- add_air_quality_layer(all_maps)
added_layers <- c(added_layers, "air-quality")

# Static plot (PNG)
plot_air_quality <- plot_static(data = air_quality, yaml_key = "air_quality")
save_plot(plot = plot_air_quality, filename = "air_quality.png", directory = styled_maps_dir)
```

![](generated/styled-maps/air_quality.png)

```{r}
#| output: asis
print_slide_text(slide_texts$climate_conditions$air_quality)
```

### Summer Surface Temperature

```{r}
#| include: false
#| label: summer_lst
summer_lst <- fuzzy_read(spatial_dir, "summer", FUN = rast)

# Interactive Plot (Leaflet)
summer_lst_resample <- summer_lst %>%
  aggregate(fact = 4, fun = "max") %>% # Is this the right function choice?
  as.polygons(digits = 0)
add_summer_lst_layer <- create_layer_function(data = summer_lst_resample, yaml_key = "summer_lst")
all_maps <- add_summer_lst_layer(all_maps)
added_layers <- c(added_layers, "summer-surface-temperature")

# Static plot (PNG)
plot_summer_lst <- plot_static(data = summer_lst, yaml_key = "summer_lst")
save_plot(plot = plot_summer_lst, filename = "summer_lst.png", directory = styled_maps_dir)
```

![](generated/styled-maps/summer_lst.png)

```{r}
#| output: asis
print_slide_text(slide_texts$climate_conditions$summer_lst)
```

### Vegetated Areas

```{r}
#| include: false
#| label: vegetation
vegetation <- fuzzy_read(spatial_dir, "NDVI_Annual", rast)

# Interactive Plot (Leaflet)
vegetation_poly <- vegetation %>%
  aggregate(fact = 10, fun = "mean") %>%
  as.polygons(digits = 2, aggregate = T) # Is this larger with/without aggregate?
add_vegetation_layer <- create_layer_function(data = vegetation_poly, yaml_key = "vegetation")
all_maps <- add_vegetation_layer(all_maps)
added_layers <- c(added_layers, "vegetated-areas")

# Static plot (PNG)
plot_vegetation <- plot_static(data = vegetation, yaml_key = "vegetation")
save_plot(plot = plot_vegetation, filename = "vegetation.png", directory = styled_maps_dir)
```

![](generated/styled-maps/vegetation.png)

```{r}
#| output: asis
print_slide_text(slide_texts$climate_conditions$vegetation)
```

### Forests & Deforestation
```{r}
#| include: false
#| label: forest
forest <- fuzzy_read(spatial_dir, "ForestCover", rast)
values(forest)[values(forest) == 0] <- NA

# Interactive Plot (Leaflet)
add_forest_layer <- create_layer_function(data = rast_as_vect(forest), yaml_key = "forest")
all_maps <- add_forest_layer(all_maps)

# Static plot (PNG)
plot_forest <- plot_static(data = forest, yaml_key = "forest")
save_plot(plot = plot_forest, filename = "forest.png", directory = styled_maps_dir)

deforest <- fuzzy_read(spatial_dir, "Deforest", rast)
deforest[[1]] <- deforest[[1]] + 2000 # The file only shows the 1s and 10s column for the year
deforest[[1]][deforest[[1]] == 2000] <- NA

# Interactive Plot (Leaflet)
add_deforest_layer <- create_layer_function(data = rast_as_vect(deforest), yaml_key = "deforest")
all_maps <- add_deforest_layer(all_maps)
added_layers <- c(added_layers, "forests-deforestation")

# Static plot (PNG)
plot_deforest <- plot_static(deforest, "deforest")
save_plot(plot = plot_deforest, filename = "deforest.png", directory = styled_maps_dir)

plot_forest_deforest <- plot_static(deforest, "deforest", baseplot = plot_forest)
save_plot(plot = plot_forest_deforest, filename = "forest_deforest.png", directory = styled_maps_dir)
```

![](generated/styled-maps/forest_deforest.png)

```{r}
#| output: asis
print_slide_text(slide_texts$climate_conditions$forest)
```

## Risk Identification

### Fluvial Flooding

```{r}
#| include: false
#| label: fluvial

# NOTE: Fluvial and pluvial use different methods, and the layers.yml differs for them
# Fluvial demonstrates class data, while pluvial demonstrates (pseudo) continuous data
fluvial_low <- terra::crop(fuzzy_read(spatial_dir, "fluvial.*lt1.tif$", rast), static_map_bounds)
fluvial_med <- terra::crop(fuzzy_read(spatial_dir, "fluvial.*1-10.tif$", rast), static_map_bounds) * 10
fluvial_high <- terra::crop(fuzzy_read(spatial_dir, "fluvial.*gt10.tif$", rast), static_map_bounds) * 100

fluvial <- max(fluvial_low, fluvial_med, fluvial_high, na.rm = T)

if (all(is.na(values(fluvial)))) values(fluvial)[1] <- 0 # Temporary fix for when fluvial is all NAs

# Interactive Plot (Leaflet)
add_fluvial_layer <- create_layer_function(data = rast_as_vect(fluvial), yaml_key = "fluvial")
all_maps <- add_fluvial_layer(all_maps)
added_layers <- c(added_layers, "fluvial-flooding")

# Static plot (PNG)
plot_fluvial <- plot_static(fluvial, yaml_key = "fluvial")
save_plot(plot = plot_fluvial, filename = "fluvial.png", directory = styled_maps_dir)
```

![](generated/styled-maps/fluvial.png)

```{r}
#| output: asis
# include_html_chart(file.path(output_dir, "plots/html/fu_wsf.html"))
```

```{r}
#| output: asis
print_slide_text(slide_texts$risk_identification$flooding_builtup_fluvial)
```

### Pluvial Flooding

```{r}
#| include: false
#| label: pluvial
pluvial_low <- terra::crop(fuzzy_read(spatial_dir, "pluvial.*lt1.tif$", rast), static_map_bounds)
pluvial_med <- terra::crop(fuzzy_read(spatial_dir, "pluvial.*1-10.tif$", rast), static_map_bounds) * 10
pluvial_high <- terra::crop(fuzzy_read(spatial_dir, "pluvial.*gt10.tif$", rast), static_map_bounds) * 11

pluvial <- max(pluvial_low, pluvial_med, pluvial_high, na.rm = T) %>%
  aggregate(fact = 4, fun = "max")

# Interactive Plot (Leaflet)
add_pluvial_layer <- create_layer_function(data = rast_as_vect(pluvial), yaml_key = "pluvial")
all_maps <- add_pluvial_layer(all_maps)
added_layers <- c(added_layers, "pluvial-flooding")

# Static plot (PNG)
plot_pluvial <- plot_static(rast_as_vect(pluvial), yaml_key = "pluvial")
save_plot(plot = plot_pluvial, filename = "pluvial.png", directory = styled_maps_dir)
```

![](generated/styled-maps/pluvial.png)

```{r}
#| output: asis
# include_html_chart(file.path(output_dir, "plots/html/pu_wsf.html"))
```

```{r}
#| output: asis
print_slide_text(slide_texts$risk_identification$flooding_builtup_pluvial)
```

### Combined Fluvial & Pluvial Flooding

```{r}
#| include: false
#| label: combined_pluvial_fluvial
# CRASHES R, maybe due to memory? 
# combined_fluvial_pluvial <- max(fluvial, pluvial, na.rm = T)

# # Interactive Plot (Leaflet)
# add_combined_fluvial_pluvial_layer <- create_layer_function(data = rast_as_vect(combined_fluvial_pluvial), yaml_key = "flooding_combined")
# all_maps <- add_combined_fluvial_pluvial_layer(all_maps)
# added_layers <- c(added_layers, "combined-fluvial-pluvial-flooding")

# # Static plot (PNG)
# plot_combined_fluvial_pluvial <- plot_static(rast_as_vect(combined_fluvial_pluvial), yaml_key = "flooding_combined")
# save_plot(plot = plot_combined_fluvial_pluvial, filename = "combined-fluvial-pluvial.png", directory = styled_maps_dir)
```

<!-- ![](generated/styled-maps/combined-fluvial-pluvial.png) -->

```{r}
#| output: asis
print_slide_text(slide_texts$risk_identification$flooding_builtup_combined)
```

### Sea-level Rise
*(Incomplete)*

```{r}
#| output: asis
#| label: sea_level
print_slide_text(slide_texts$risk_identification$sea_level_rise)
```

### Coastal Erosion
*(Incomplete)*

```{r}
#| output: asis
#| label: erosion
print_slide_text(slide_texts$risk_identification$coastal_erosion)
```

### Elevation

```{r}
#| include: false
#| label: elevation
elevation <- fuzzy_read(spatial_dir, "elevation", FUN = rast)
elev_breaks <- break_pretty2(values(elevation), method = "interval")
for (i in seq_along(elev_breaks)) {
    elevation[elevation >= elev_breaks[i] & elevation < c(elev_breaks, 1e6)[i+1]] <- elev_breaks[i]
}
elevation <- as.polygons(elevation)

# Interactive Plot (Leaflet)
add_elevation_layer <- create_layer_function(data = elevation, yaml_key = "elevation")
all_maps <- add_elevation_layer(all_maps)
added_layers <- c(added_layers, "elevation")

# Static plot (PNG)
plot_elevation <- plot_static(data = elevation, yaml_key = "elevation", breaks = elev_breaks)
save_plot(plot = plot_elevation, filename = "elevation.png", directory = styled_maps_dir)
```

![](generated/styled-maps/elevation.png)

```{r}
#| output: asis
include_html_chart(file.path(output_dir, "plots/html/elevation.html"))
```

```{r}
#| output: asis
print_slide_text(slide_texts$risk_identification$elevation)
```

### Slope

```{r}
#| include: false
#| label: slope
# FIX: Currently plotting as raster because much faster, but => no label on hover
slope <- fuzzy_read(spatial_dir, "elevation", FUN = rast) %>%
  terrain(v="slope")

# Interactive Plot (Leaflet)
add_slope_layer <- create_layer_function(data = slope, yaml_key = "slope")
all_maps <- add_slope_layer(all_maps)
added_layers <- c(added_layers, "slope")

# Static plot (PNG)
plot_slope <- plot_static(data = slope, yaml_key = "slope")
save_plot(plot = plot_slope, filename = "slope.png", directory = styled_maps_dir)
```

![](generated/styled-maps/slope.png)

```{r}
#| output: asis
include_html_chart(file.path(output_dir, "plots/html/slope.html"))
```

```{r}
#| output: asis
print_slide_text(slide_texts$risk_identification$slope)
```

### Landslides

```{r}
#| include: false
#| label: landslides
landslides <- fuzzy_read(spatial_dir, "landslide", rast)

# Interactive Plot (Leaflet)
add_landslides_layer <- create_layer_function(data = rast_as_vect(landslides), yaml_key = "landslides")
all_maps <- add_landslides_layer(all_maps)
added_layers <- c(added_layers, "landslides")

# Static plot (PNG)
plot_landslides <- plot_static(data = landslides, yaml_key = "landslides")
save_plot(plot = plot_landslides, filename = "landslides.png", directory = styled_maps_dir)
```

![](generated/styled-maps/landslides.png)

```{r}
#| output: asis
print_slide_text(slide_texts$risk_identification$landslides)
```

### Liquefaction

```{r}
#| include: false
#| label: liquefaction
liquefaction <- fuzzy_read(spatial_dir, "liquefaction.tif$", rast_as_vect)

# Interactive Plot (Leaflet)
add_liquefaction_layer <- create_layer_function(data = liquefaction, yaml_key = "liquefaction")
all_maps <- add_liquefaction_layer(all_maps)
added_layers <- c(added_layers, "liquefaction")

# Static plot (PNG)
plot_liquefaction <- plot_static(data = liquefaction, yaml_key = "liquefaction")
save_plot(plot = plot_liquefaction, filename = "liquefaction.png", directory = styled_maps_dir)
```

![](generated/styled-maps/liquefaction.png)

```{r}
#| output: asis
print_slide_text(slide_texts$risk_identification$liquefaction)
```

### Burnable Area

```{r}
#| include: false
#| label: burnable
burnable <- fuzzy_read(spatial_dir, "burn", rast_as_vect)

# Interactive Plot (Leaflet)
add_burnable_layer <- create_layer_function(data = burnable, yaml_key = "burnable")
all_maps <- add_burnable_layer(all_maps)
added_layers <- c(added_layers, "burnable-area")

# Static plot (PNG)
plot_burnable <- plot_static(data = burnable, yaml_key = "burnable")
save_plot(plot = plot_burnable, filename = "burnable.png", directory = styled_maps_dir)
```

![](generated/styled-maps/burnable.png)

```{r}
#| output: asis
print_slide_text(slide_texts$risk_identification$burnable)
```

### Moisture
```{r}
#| include: false
#| label: moisture
moisture <- fuzzy_read(spatial_dir, "NDMI_Annual", rast)

# Interactive Plot (Leaflet)
moisture_poly <- moisture %>%
  aggregate(fact = 10, fun = "mean") %>%
  as.polygons(digits = 2, aggregate = T) # Is this larger with/without aggregate?
add_moisture_layer <- create_layer_function(data = moisture_poly, yaml_key = "moisture")
all_maps <- add_moisture_layer(all_maps)
added_layers <- c(added_layers, "moisture")

# Static plot (PNG)
plot_moisture <- plot_static(data = moisture_poly, yaml_key = "moisture")
save_plot(plot = plot_moisture, filename = "moisture.png", directory = styled_maps_dir)
```

![](generated/styled-maps/moisture.png)

```{r}
#| output: asis
print_slide_text(slide_texts$risk_identification$moisture)
```

### Historical Burnt Area
```{r}
#| include: false
#| label: burnt_area
# burnt_area <- fuzzy_read(spatial_dir, "???", rast_as_vect)
# 
# # Interactive Plot (Leaflet)
# add_burnt_area_layer <- create_layer_function(data = burnt_area, yaml_key = "burnt_area")
# all_maps <- add_burnt_area_layer(all_maps)
# added_layers <- c(added_layers, "burnt_area")
# 
# # Static plot (PNG)
# plot_burnt_area <- plot_static(data = burnt_area, yaml_key = "burnt_area")
# save_plot(plot = plot_burnt_area, filename = "burnt_area.png", directory = styled_maps_dir)
```

```{r}
#| output: true
# plot_burnt_area
```

```{r}
#| output: asis
print_slide_text(slide_texts$risk_identification$burnt_area)
```

### Fire Potential
```{r}
#| include: false
#| label: fwi
fwi <- fuzzy_read(spatial_dir, "fwi", rast)

# Interactive Plot (Leaflet)
add_fwi_layer <- create_layer_function(data = fwi, yaml_key = "fwi")
all_maps <- add_fwi_layer(all_maps)
added_layers <- c(added_layers, "fire-potential")

# Static plot (PNG)
# Commenting out because of large size (Need to change tile zoom level and static bounds)
# plot_fwi <- plot_static(data = fwi, yaml_key = "fwi")
# save_plot(plot = plot_fwi, filename = "fwi.png", directory = styled_maps_dir)
```

<!-- ![](generated/styled-maps/fwi.png) -->

```{r}
#| output: asis
print_slide_text(slide_texts$risk_identification$fwi)
```
:::

::: maps
```{r}
#| output: true
#| label: leaflet_maps
all_maps %>%
  add_aoi() %>%
  addLayersControl(
    overlayGroups = added_layers,
    options = layersControlOptions(collapsed = TRUE))

  # If I want to use javascript directly I could use htmlwidgets::onRender(),
  # or maybe just an observable cell
```
:::