From f48752d7479301912f9b17e4cfee6d3a56e63dee Mon Sep 17 00:00:00 2001 From: Jason Flower Date: Wed, 16 Sep 2026 15:37:48 +1000 Subject: [PATCH 1/2] work in progress --- R/convert_solution.R | 2 +- R/create_patch_df.R | 13 +-- README.Rmd | 204 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 213 insertions(+), 6 deletions(-) create mode 100644 README.Rmd diff --git a/R/convert_solution.R b/R/convert_solution.R index 7da12c0..df13b5f 100644 --- a/R/convert_solution.R +++ b/R/convert_solution.R @@ -61,7 +61,7 @@ convert_solution <- function(solution, patch_df, spatial_grid) { if(!check_df(patch_df)) { stop("patch_df must be a dataframe object")} - planning_unit_id <- unique(unlist(patch_df$id[which(solution$solution_1 > 0.5)])) + planning_unit_id <- unique(unlist(patch_df$idx[which(solution$solution_1 > 0.5)])) if(class(spatial_grid)[1] %in% c("RasterLayer", "SpatRaster")){ solution <- spatial_grid*0 diff --git a/R/create_patch_df.R b/R/create_patch_df.R index 3dce719..a97d610 100644 --- a/R/create_patch_df.R +++ b/R/create_patch_df.R @@ -58,7 +58,7 @@ create_patch_df <- function(spatial_grid, features, patches, costs = NULL, locke if (class(spatial_grid)[1] %in% c("RasterLayer", "SpatRaster")) { # Initialize - pu_grid_data <- tibble::tibble(id = as.list(seq_len(nrow(terra::as.data.frame(spatial_grid, na.rm = FALSE))))) %>% + pu_grid_data <- tibble::tibble(idx = as.list(seq_len(nrow(terra::as.data.frame(spatial_grid, na.rm = FALSE))))) %>% dplyr::bind_cols(tibble::tibble(terra::as.data.frame(features, na.rm = FALSE))) %>% dplyr::mutate(patch = 0) @@ -73,7 +73,7 @@ create_patch_df <- function(spatial_grid, features, patches, costs = NULL, locke pu_sm_data <- lapply(names(patches), function(i) { curr_sm_pu <- tibble::tibble( - id = list(as.numeric(row.names(terra::as.data.frame(patches[[i]], na.rm = FALSE))[which(terra::as.data.frame(patches[[i]], na.rm = FALSE) > 0.5)]))) %>% + idx = list(as.numeric(row.names(terra::as.data.frame(patches[[i]], na.rm = FALSE))[which(terra::as.data.frame(patches[[i]], na.rm = FALSE) > 0.5)]))) %>% dplyr::bind_cols( terra::as.data.frame(features * patches[[i]], na.rm = FALSE) %>% stats::setNames(names(features)) %>% @@ -127,7 +127,7 @@ create_patch_df <- function(spatial_grid, features, patches, costs = NULL, locke } # Initialize - pu_grid_data <- tibble::tibble(id = as.list(seq_len(nrow(spatial_grid)))) %>% + pu_grid_data <- tibble::tibble(idx = as.list(seq_len(nrow(spatial_grid)))) %>% dplyr::bind_cols(features) %>% dplyr::mutate(patch = 0) @@ -144,7 +144,7 @@ create_patch_df <- function(spatial_grid, features, patches, costs = NULL, locke pu_sm_data <- lapply(names(patches), function(i) { curr_sm_pu <- tibble::tibble( - id = list(as.numeric(row.names(patches[which(patches[,i] > 0.5),])))) %>% + idx = list(as.numeric(row.names(patches[which(patches[,i] > 0.5),])))) %>% dplyr::bind_cols(data.frame(t(features %>% dplyr::mutate_all(., ~(.*patches[,i])) %>% colSums(., na.rm = T)))) @@ -182,6 +182,9 @@ create_patch_df <- function(spatial_grid, features, patches, costs = NULL, locke # planning units constraints <- data.frame(test = rep(0,nrow(pu_data))) + # add in id column for planning unit data + pu_data$id <- seq_len(nrow(pu_data)) + index <- 1 #Create a vector with a '1' for each combination of patch-level @@ -189,7 +192,7 @@ create_patch_df <- function(spatial_grid, features, patches, costs = NULL, locke for (i in seq_len(nrow(pu_sm_data))) { print(paste0("Processing patch ", i, " of ", nrow(pu_sm_data))) - for (j in pu_sm_data$id[[i]]) { + for (j in pu_sm_data$idx[[i]]) { v <- rep(0, nrow(pu_data)) # initialize with zeros v[nrow(pu_grid_data) + i] <- 1 # specify patch-level planning unit v[as.numeric(j)] <- 1 # specify grid cell-level planning unit diff --git a/README.Rmd b/README.Rmd new file mode 100644 index 0000000..21d461a --- /dev/null +++ b/README.Rmd @@ -0,0 +1,204 @@ +--- +output: github_document +--- + + + +```{r, include = FALSE} +knitr::opts_chunk$set( + collapse = TRUE, + comment = "#>", + fig.path = "man/figures/README-", + out.width = "100%" +) + +devtools::load_all() +``` + +# patchwise patchwise website + + + + +`patchwise` is intended to be used as a supplementary package to `prioritizr` for instances in which users wish to protect entire contiguous patches of features rather than portions of many features. For example, consider conservation planning for an area of ocean where seamounts are one of the biodiversity features that are targeted for protection. If the seamounts span multiple planning units and representation target of say 20% is used, portions of many seamounts could be protected, but it might be better to protect the entirety (contiguous patches) of a smaller number of seamounts. `patchwise` provides this option, ensuring that representation targets are met by representing whole features. + +## Installation + +You can install the development version of `patchwise` from [GitHub](https://github.com/) with: + +```{r eval=FALSE} +# install.packages("pak") +pak::pak("emlab-ucsb/patchwise") +``` + +## Example using raster data + +First load the libraries needed. Apart from `patchwise`, the `terra` package is used for raster data manipulation, and `prioritizr` is used for the spatial prioritization. + +```{r libraries, eval=FALSE} +library(patchwise) +``` +```{r, include=FALSE} +library(prioritizr) +library(terra) +``` + +We will create some basic planning data to demonstrate how `patchwise` can be used. For this example we will create a raster planning grid which has a cost value of 1 for each cell, and the following features that will be targeted in the prioritization: + +- 4 random, binary (0 or 1) data layers, representing species distributions; for this example we are calling them fish +- 3 "patches" of contiguous features; for this example we are calling them seamounts + +```{r data-setup} +# create a 40 x 40 planning grid, with cost values all equal to 1 + +max_x_and_y <- 40 +pu_raster <- rast(nrows = max_x_and_y, ncols = max_x_and_y, xmin= 0, xmax= max_x_and_y, ymin= 0, ymax= max_x_and_y, resolution = 1 , vals = 1) |> + setNames("cost") + +#create a 4 layer raster of random, binary (0 or 1) features +# these could represent distributions of species; for this example they are named fish + +number_species <- 4 + +fish_distributions <- lapply(seq_len(number_species), function(x) { + setValues(pu_raster, round(runif(ncell(pu_raster)) > 0.5)) +}) |> + setNames(paste0("fish_", seq_len(number_species))) |> + rast() + +# create patches; for this example, they are named seamounts +seamounts <- data.frame(x = c(5, 22, 32), + y = c(5, 18, 29)) |> + vect() |> + buffer(4) |> + rasterize(pu_raster, field = 1) |> + setNames("Seamounts") +``` + +Let's look at our fish distributions and our seamounts + +```{r visualize-data} +plot(c(fish_distributions, seamounts)) +``` + +Now we can use `patchwise` to do some pre-processing of the seamounts data so the seamounts can be prioritized as whole patches in the following prioritization. + +```{r patchwise-prep} + +# Create seamount patches - seamount areas that touch are considered the same patch +patches_rast <- create_patches(seamounts) + +# Create patches dataframe - this creates constraints so that entire seamount patches are protected +patches_df_rast <- create_patch_df(spatial_grid = pu_raster, features = fish_distributions, patches = patches_rast, costs = pu_raster) +``` + +With that pre-processing done, we can now use `patchwise` to create protection targets for our features, including seamounts. In this example, we will use 20%, including 20% of whole seamounts. + +```{r targets-constraints} +# Create targets for protection - let's just do 20% for each feature (including 20% of whole seamounts) +targets_rast <- features_targets(targets = rep(0.2, (nlyr(fish_distributions) + 1)), features = fish_distributions, pre_patches = seamounts) + +# Add these targets to targets for protection for the "constraints" we introduced to protect entire seamount patches +constraints_rast <- constraints_targets(feature_targets = targets_rast, patch_df = patches_df_rast) +``` + +With all the data preparation now done, we can run a prioritization using `prioritizr`: + +```{r prioritization, include=FALSE} +# Create the prioritization problem +problem_patches <- problem(x = patches_df_rast, features = constraints_rast$feature, cost_column = "cost") |> + add_min_set_objective() |> + add_manual_targets(constraints_rast) |> + add_binary_decisions() |> + add_default_solver() + +# Solve the prioritization +solution_patches_tbl <- solve(problem_patches) +``` + +The solution object is a tibble. To convert this into a raster object for plotting, we use the `convert_solution()` function from `patchwise` + +```{r convert-solution} +# Convert the solution into a raster using the patchwise function `convert_solution()` +sol_rast_patches <- convert_solution(solution = solution_patches_tbl, patch_df = patches_df_rast, spatial_grid = pu_raster) |> + setNames("With patchwise") +``` + +For comparison, we will run a prioritization without using `patchwise` + +```{r prioritization-no-patches, include=FALSE} +features_rast <- c(fish_distributions, seamounts) + +problem_no_patches <- problem(x = pu_raster, features = features_rast) |> + add_min_set_objective() |> + add_relative_targets(0.2) |> + add_binary_decisions() |> + add_default_solver() + +# Solve the prioritization +solution_no_patches <- solve(problem_no_patches) |> + setNames("Without patchwise") +``` + +We can now plot the solutions, and overlaying the outlines of the seamounts (in red), we can see that one entire seamount is included in the solution that used `patchwise`, whereas the solution without `patchwise` selects a few planning units in each seamount. Note that in the solution with `patchwise`, planning units that overlap seamounts that are not entirely selected have also been selected to meet targets for other features (fish distributions). + +```{r prioritization-plot} +plot(c(solution_no_patches, sol_rast_patches), + fun = function()lines(as.polygons(seamounts), col = "red"), + plg = list(legend = c("Not selected", "Selected"))) +``` + +If you want to use a boundary penalty in the prioritization, we need to manually create a boundary matrix using the `patchwise` function `create_boundary_matrix()` + +```{r boundary-matrix} +boundary_matrix_rast <- create_boundary_matrix(spatial_grid = pu_raster, patches = patches_rast, patch_df = patches_df_rast) +``` + +We can now re-run the prioritization with a boundary penalty + +```{r prioritization-boundary, include=FALSE} +problem_boundary <- problem_patches |> + add_boundary_penalties(penalty = 0.000002, data = boundary_matrix_rast) + +solution_boundary_tbl <- solve(problem_boundary) + +solution_rast_boundary <- convert_solution(solution = solution_boundary_tbl, patch_df = patches_df_rast, spatial_grid = pu_raster) +``` + +We now get a solution with planning units more clustered together + +```{r prioritization-boundary-plot} +plot(solution_rast_boundary, plg = list(legend = c("Not selected", "Selected"))) +lines(as.polygons(seamounts), col = "red") +``` + +## Example with sf data + +The previous example used raster input data for the prioritization, but `patchwise` also handles `sf` data. + +```{r} +library(sf) +``` + + +First we need to create suitable `sf` data inputs. We can do this by polygonizing the raster data: + +```{r} +#create the planning grid, which is also the same as the cost grid since we are using planning units all with cost = 1 +pu_sf <- as.polygons(pu_raster, aggregate = FALSE) |> + st_as_sf() + +features_sf <- as.polygons(fish_distributions, aggregate = FALSE) |> + st_as_sf() + +seamounts_sf <- as.polygons(seamounts, aggregate = FALSE) |> + st_as_sf() +``` + +Let's check our features and seamounts look ok: + +```{r} +plot(features_sf) +plot(seamounts_sf) +``` + From 6b7d74144c8f24438ce4d6f418a95b751defa8ab Mon Sep 17 00:00:00 2001 From: Jason Flower Date: Thu, 17 Sep 2026 22:12:31 +1000 Subject: [PATCH 2/2] update to use idx column in prioritization data rather than id. Also all examples, tests and readme's now use internal data rather than relying on downloaded data using oceandatr --- .Rbuildignore | 3 + .gitignore | 2 + DESCRIPTION | 9 +- R/constraints_targets.R | 63 +- R/convert_solution.R | 95 +- R/create_boundary_matrix.R | 58 +- R/create_patch_df.R | 69 +- R/create_patches.R | 43 +- R/features_targets.R | 60 +- README.Rmd | 118 ++- README.md | 310 ++++--- data-raw/example-data.R | 32 + figure/unnamed-chunk-10-1.png | Bin 112488 -> 0 bytes figure/unnamed-chunk-11-1.png | Bin 10831 -> 0 bytes figure/unnamed-chunk-12-1.png | Bin 112608 -> 0 bytes figure/unnamed-chunk-13-1.png | Bin 113123 -> 0 bytes figure/unnamed-chunk-3-1.png | Bin 11628 -> 0 bytes figure/unnamed-chunk-4-1.png | Bin 14182 -> 0 bytes figure/unnamed-chunk-5-1.png | Bin 11614 -> 0 bytes figure/unnamed-chunk-6-1.png | Bin 14365 -> 0 bytes figure/unnamed-chunk-7-1.png | Bin 14175 -> 0 bytes figure/unnamed-chunk-9-1.png | Bin 11097 -> 0 bytes inst/extdata/pu_raster.tif | Bin 0 -> 1491 bytes inst/extdata/seamounts.tif | Bin 0 -> 1590 bytes inst/extdata/spp_distributions.tif | Bin 0 -> 4856 bytes man/constraints_targets.Rd | 61 +- man/convert_solution.Rd | 94 +- man/create_boundary_matrix.Rd | 56 +- man/create_patch_df.Rd | 66 +- man/create_patches.Rd | 39 +- man/features_targets.Rd | 60 +- .../README-prioritization-boundary-plot-1.png | Bin 0 -> 10442 bytes man/figures/README-prioritization-plot-1.png | Bin 0 -> 15419 bytes .../README-prioritization-plot-sf-1.png | Bin 0 -> 36484 bytes man/figures/README-unnamed-chunk-5-1.png | Bin 0 -> 105379 bytes man/figures/README-unnamed-chunk-6-1.png | Bin 0 -> 105379 bytes man/figures/README-visualize-data-1.png | Bin 0 -> 17193 bytes tests/testthat/test-constraints_targets.R | 84 +- tests/testthat/test-convert_solution.R | 111 --- .../test-convert_solution.R.notworking | 71 ++ tests/testthat/test-create_boundary_matrix.R | 70 +- tests/testthat/test-create_patch_df.R | 58 +- tests/testthat/test-create_patches.R | 38 +- tests/testthat/test-features_targets.R | 74 +- vignettes/figure/prioritization-plot-1.png | Bin 0 -> 13698 bytes vignettes/figure/prioritization-plot-sf-1.png | Bin 0 -> 38603 bytes .../figure/prioritization-plot-sf2-1.png | Bin 0 -> 38194 bytes vignettes/figure/prioritization-plot2-1.png | Bin 0 -> 14359 bytes vignettes/figure/unnamed-chunk-6-1.png | Bin 14365 -> 69451 bytes vignettes/figure/unnamed-chunk-8-1.png | Bin 0 -> 63799 bytes vignettes/figure/visualize-data-1.png | Bin 0 -> 14507 bytes vignettes/locked_in_out.Rmd | 873 +++++------------- vignettes/locked_in_out.Rmd.orig | 487 +++++----- 53 files changed, 1301 insertions(+), 1803 deletions(-) create mode 100644 data-raw/example-data.R delete mode 100644 figure/unnamed-chunk-10-1.png delete mode 100644 figure/unnamed-chunk-11-1.png delete mode 100644 figure/unnamed-chunk-12-1.png delete mode 100644 figure/unnamed-chunk-13-1.png delete mode 100644 figure/unnamed-chunk-3-1.png delete mode 100644 figure/unnamed-chunk-4-1.png delete mode 100644 figure/unnamed-chunk-5-1.png delete mode 100644 figure/unnamed-chunk-6-1.png delete mode 100644 figure/unnamed-chunk-7-1.png delete mode 100644 figure/unnamed-chunk-9-1.png create mode 100644 inst/extdata/pu_raster.tif create mode 100644 inst/extdata/seamounts.tif create mode 100644 inst/extdata/spp_distributions.tif create mode 100644 man/figures/README-prioritization-boundary-plot-1.png create mode 100644 man/figures/README-prioritization-plot-1.png create mode 100644 man/figures/README-prioritization-plot-sf-1.png create mode 100644 man/figures/README-unnamed-chunk-5-1.png create mode 100644 man/figures/README-unnamed-chunk-6-1.png create mode 100644 man/figures/README-visualize-data-1.png delete mode 100644 tests/testthat/test-convert_solution.R create mode 100644 tests/testthat/test-convert_solution.R.notworking create mode 100644 vignettes/figure/prioritization-plot-1.png create mode 100644 vignettes/figure/prioritization-plot-sf-1.png create mode 100644 vignettes/figure/prioritization-plot-sf2-1.png create mode 100644 vignettes/figure/prioritization-plot2-1.png create mode 100644 vignettes/figure/unnamed-chunk-8-1.png create mode 100644 vignettes/figure/visualize-data-1.png diff --git a/.Rbuildignore b/.Rbuildignore index c0537c2..2850a5b 100644 --- a/.Rbuildignore +++ b/.Rbuildignore @@ -7,3 +7,6 @@ ^docs$ ^pkgdown$ ^\.github$ +^doc$ +^Meta$ +figure$ diff --git a/.gitignore b/.gitignore index f47ffab..e77a603 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,5 @@ .httr-oauth .DS_Store inst/doc +/doc/ +/Meta/ diff --git a/DESCRIPTION b/DESCRIPTION index 72da618..0cecf9f 100644 --- a/DESCRIPTION +++ b/DESCRIPTION @@ -1,6 +1,6 @@ Package: patchwise Title: Create Patches of Feature Groups for Use in Spatial Prioritizations -Version: 0.1.0 +Version: 0.2.0 Authors@R: c( person(given = "Echelle S.", family = "Burns", email = "echelle_burns@ucsb.edu", role = c("aut", "cre"), comment = c(ORCID = "0000-0002-3902-1410")), person(given = "Jason", family = "Flower", email = "jflower@ucsb.edu", role = c("aut"), comment = c(ORCID = "0000-0002-6731-8182")) @@ -20,18 +20,13 @@ Imports: tidyselect, rlang Roxygen: list(markdown = TRUE) -Remotes: - github::emlab-ucsb/spatialgridr, - github::emlab-ucsb/oceandatr -RoxygenNote: 7.3.1 Suggests: knitr, rmarkdown, codetools, testthat (>= 3.0.0), - oceandatr, - spatialgridr, prioritizr Config/testthat/edition: 3 VignetteBuilder: knitr URL: https://emlab-ucsb.github.io/patchwise/ +Config/roxygen2/version: 8.1.0 diff --git a/R/constraints_targets.R b/R/constraints_targets.R index 37cc4e2..c965ab2 100644 --- a/R/constraints_targets.R +++ b/R/constraints_targets.R @@ -1,41 +1,42 @@ -#' Create a dataframe for manual targets for all layers, including the features and the constraints +#' Create a dataframe for manual targets for all layers, including the features +#' and the constraints #' -#' @description This function creates a dataframe with the comibination of feature targets, generated by `features_targets()` and the targets for constraints to be used in prioritizr +#' @description This function creates a dataframe with the combination of +#' feature targets, generated by `features_targets()` and the targets for +#' constraints to be used in prioritizr #' -#' @param feature_targets a dataframe of feature targets generated by `features_targets()` -#' @param patch_df a dataframe generated by `create_patch_df()` that includes constraints for each patch and grid cell combination +#' @param feature_targets a dataframe of feature targets generated by +#' `features_targets()` +#' @param patch_df a dataframe generated by `create_patch_df()` that includes +#' constraints for each patch and grid cell combination #' #' @return A dataframe to be used to specify all manual targets for prioritizr #' @export #' #' @examples -#'# Start with a little housekeeping to get the data from oceandatr -#'# Choose area of interest (Bermuda EEZ) -#'area <- oceandatr::get_area(area_name = "Bermuda", mregions_column = "territory1") -#'projection <-'+proj=laea +lon_0=-64.8108333 +lat_0=32.3571917 +datum=WGS84 +units=m +no_defs' -#'# Create a planning grid -#'planning_raster <- spatialgridr::get_grid(area, projection = projection) -#'# Grab all relevant data -#'features_raster <- oceandatr::get_features(spatial_grid = planning_raster) -#'# Separate seamount data - we want to protect entire patches -#'seamounts_raster <- features_raster[["seamounts"]] -#'features_raster <- features_raster[[names(features_raster)[names(features_raster) != "seamounts"]]] -#'# Create a "cost" to protecting a cell - just a uniform cost for this example -#'cost_raster <- stats::setNames(planning_raster, "cost") -#'# Create patches from layer -#'patches_raster <- create_patches(seamounts_raster) -#'# Create patch dataframe -#'patches_raster_df <- create_patch_df(spatial_grid = planning_raster, features = features_raster, -#' patches = patches_raster, costs = cost_raster) -#'# Create boundary matrix for prioritizr -#'boundary_matrix <- create_boundary_matrix(spatial_grid = planning_raster, -#' patches = patches_raster, patch_df = patches_raster_df) -#'# Create target features - using just 20% for every feature -#'features_targets <- features_targets(targets = rep(0.2, (terra::nlyr(features_raster)) + 1), -#' features = features_raster, pre_patches = seamounts_raster) -#'# Create constraint targets -#'constraint_targets <- constraints_targets(feature_targets = features_targets, -#' patch_df = patches_raster_df) +#'# Import some planning data +#' +#'#import planning units/ cost raster +#'pu_raster <- terra::rast(system.file("extdata/pu_raster.tif", package = "patchwise")) + +#'#import species distributions - feature data for planning +#'species_distributions <- terra::rast(system.file("extdata/spp_distributions.tif", package = "patchwise")) +#' +#'#import seamounts +#'seamounts <- terra::rast(system.file("extdata/seamounts.tif", package = "patchwise")) +#' +#'# Create seamount patches as multi-layer raster +#'patches_raster <- create_patches(seamounts) +#' +#'patches_df <- create_patch_df(spatial_grid = pu_raster, features = species_distributions, +#'patches = patches_raster, costs = pu_raster) +#' +#'# Create targets for protection - use 20% for each feature (including 20% of whole seamounts) in this example +#'targets_df <- features_targets(targets = rep(0.2, (terra::nlyr(species_distributions) + 1)), features = species_distributions, pre_patches = seamounts) +#' +#'# Add these targets to targets for protection for the "constraints" we introduced to protect entire seamount patches +#'constraints_df <- constraints_targets(feature_targets = targets_df, patch_df = patches_df) + constraints_targets <- function(feature_targets, patch_df) { diff --git a/R/convert_solution.R b/R/convert_solution.R index df13b5f..f8f353f 100644 --- a/R/convert_solution.R +++ b/R/convert_solution.R @@ -1,56 +1,61 @@ #' Converts prioritization solution into a more digestible output #' -#' @description This function converts the prioritization solution that uses patches to a raster or sf object (depending on the format of your spatial_grid) that clearly marks areas suggested for protection (1) and areas not suggested for protection (0) +#' @description This function converts the prioritization solution that uses +#' patches to a raster or sf object (depending on the format of your +#' spatial_grid) that clearly marks areas suggested for protection (1) and +#' areas not suggested for protection (0) #' -#' @param solution the solution that results from using `prioritizr::solve()` on `prioritizr::problem()` -#' @param patch_df a dataframe generated by `create_patch_df()` that includes constraints for each patch and grid cell combination -#' @param spatial_grid a raster or sf template with the desired resolution and coordinate reference system generated by `spatialgridr::get_grid()`; values in areas of interest are 1, while all other values are NA (only required if feature is a sf object) +#' @param solution the solution that results from using `prioritizr::solve()` on +#' `prioritizr::problem()` +#' @param patch_df a dataframe generated by `create_patch_df()` that includes +#' constraints for each patch and grid cell combination +#' @param spatial_grid a raster or sf template with the desired resolution and +#' coordinate reference system; values in areas of interest are 1, while all +#' other values are NA (only required if feature is a sf object) #' -#' @return A raster or sf object that denotes areas suggested for protection (value = 1) +#' @return A raster or sf object that denotes areas suggested for protection +#' (value = 1) #' @export #' #' @examples #' \dontrun{ -#'# Start with a little housekeeping to get the data from oceandatr -#'# Choose area of interest (Bermuda EEZ) -#'area <- oceandatr::get_area(area_name = "Bermuda", mregions_column = "territory1") -#'projection <-'+proj=laea +lon_0=-64.8108333 +lat_0=32.3571917 +datum=WGS84 +units=m +no_defs' -#'# Create a planning grid -#'planning_raster <- spatialgridr::get_grid(area, projection = projection) -#'# Grab all relevant data -#'features_raster <- oceandatr::get_features(spatial_grid = planning_raster) -#'# Separate seamount data - we want to protect entire patches -#'seamounts_raster <- features_raster[["seamounts"]] -#'features_raster <- features_raster[[names(features_raster)[names(features_raster) != "seamounts"]]] -#'# Create a "cost" to protecting a cell - just a uniform cost for this example -#'cost_raster <- stats::setNames(planning_raster, "cost") -#'# Create patches from layer -#'patches_raster <- create_patches(seamounts_raster) -#'# Create patch dataframe -#'patches_raster_df <- create_patch_df(spatial_grid = planning_raster, features = features_raster, -#' patches = patches_raster, costs = cost_raster) -#'# Create boundary matrix for prioritizr -#'boundary_matrix <- create_boundary_matrix(spatial_grid = planning_raster, patches = patches_raster, -#' patch_df = patches_raster_df) -#'# Create target features - using just 20% for every feature -#'features_targets <- features_targets(targets = rep(0.2, (terra::nlyr(features_raster)) + 1), -#' features = features_raster, pre_patches = seamounts_raster) -#'# Create constraint targets -#'constraint_targets <- constraints_targets(feature_targets = features_targets, -#' patch_df = patches_raster_df) -#'# Create prioritization problem -#'problem_raster <- prioritizr::problem(x = patches_raster_df, -#' features = constraint_targets$feature, cost_column = "cost") %>% -#' prioritizr::add_min_set_objective() %>% -#' prioritizr::add_manual_targets(constraint_targets) %>% -#' prioritizr::add_binary_decisions() %>% -#' prioritizr::add_boundary_penalties(penalty = 0.000002, data = boundary_matrix) %>% -#' prioritizr::add_default_solver(gap = 0.1, threads = parallel::detectCores()-1) -#'# Solve problem -#'solution <- solve(problem_raster) -#'# Convert to a more digestible format -#'suggested_protection <- convert_solution(solution = solution, patch_df = patches_raster_df, -#' spatial_grid = planning_raster) +#'#import planning units/ cost raster +#'pu_raster <- terra::rast(system.file("extdata/pu_raster.tif", package = "patchwise")) + +#'#import species distributions - feature data for planning +#'species_distributions <- terra::rast(system.file("extdata/spp_distributions.tif", package = "patchwise")) +#' +#'#import seamounts +#'seamounts <- terra::rast(system.file("extdata/seamounts.tif", package = "patchwise")) +#' +#'# Create seamount patches as multi-layer raster +#'patches_raster <- create_patches(seamounts) +#' +#'patches_df <- create_patch_df(spatial_grid = pu_raster, features = species_distributions, +#'patches = patches_raster, costs = pu_raster) +#' +#'# Create targets for protection - use 20% for each feature (including 20% of whole seamounts) in this example +#'targets_df <- features_targets(targets = rep(0.2, (terra::nlyr(species_distributions) + 1)), features = species_distributions, pre_patches = seamounts) +#' +#'# Add these targets to targets for protection for the "constraints" we introduced to protect entire seamount patches +#'constraints_df <- constraints_targets(feature_targets = targets_df, patch_df = patches_df) +#' +#'library(prioritizr) +#' +#'# Create the prioritization problem +#'problem_patches <- problem(x = patches_df, features = constraints_df$feature, cost_column = "cost") |> +#' add_min_set_objective() |> +#' add_manual_targets(constraints_df) |> +#' add_binary_decisions() |> +#' add_default_solver() +#' +#'# Solve the problem +#'solution_patches_tbl <- solve(problem_patches) +#' +#'# Convert the solution into a raster using `convert_solution()` +#'sol_rast_patches <- convert_solution(solution = solution_patches_tbl, patch_df = patches_df, spatial_grid = pu_raster) +#' +#'terra::plot(sol_rast_patches) #' } convert_solution <- function(solution, patch_df, spatial_grid) { diff --git a/R/create_boundary_matrix.R b/R/create_boundary_matrix.R index 45a2c11..f18f24b 100644 --- a/R/create_boundary_matrix.R +++ b/R/create_boundary_matrix.R @@ -1,36 +1,42 @@ #' Create boundary matrix for prioritizr if you are using patches #' -#' @description This function creates a boundary matrix to plug into prioritizr +#' @description This function creates a boundary matrix which is required if you +#' want to use a boundary penalty in prioritizr #' -#' @param spatial_grid a raster or sf template with the desired resolution and coordinate reference system generated by `spatialgridr::get_grid()`; values in areas of interest are 1, while all other values are NA (only required if feature is a sf object) -#' @param patches a raster or sf object generated by `create_patches()`; a single feature split into spatially distinct groups; each layer of the raster or each column of the sf object identifies the location of each patch -#' @param patch_df a dataframe generated by `create_patch_df()` that includes constraints for each patch and grid cell combination +#' @param spatial_grid a raster or sf template with the desired resolution and +#' coordinate reference system; values in areas of interest are 1, while all +#' other values are NA (only required if feature is a sf object) +#' @param patches a raster or sf object generated by `create_patches()`; a +#' single feature split into spatially distinct groups; each layer of the +#' raster or each column of the sf object identifies the location of each +#' patch +#' @param patch_df a dataframe generated by `create_patch_df()` that includes +#' constraints for each patch and grid cell combination #' -#' @return A boundary matrix to plug into prioritizr +#' @return A sparse matrix #' @export #' #' @examples -#'# Start with a little housekeeping to get the data from oceandatr -#'# Choose area of interest (Bermuda EEZ) -#'area <- oceandatr::get_area(area_name = "Bermuda", mregions_column = "territory1") -#'projection <-'+proj=laea +lon_0=-64.8108333 +lat_0=32.3571917 +datum=WGS84 +units=m +no_defs' -#'# Create a planning grid -#'planning_raster <- spatialgridr::get_grid(area, projection = projection) -#'# Grab all relevant data -#'features_raster <- oceandatr::get_features(spatial_grid = planning_raster) -#'# Separate seamount data - we want to protect entire patches -#'seamounts_raster <- features_raster[["seamounts"]] -#'features_raster <- features_raster[[names(features_raster)[names(features_raster) != "seamounts"]]] -#'# Create a "cost" to protecting a cell - just a uniform cost for this example -#'cost_raster <- stats::setNames(planning_raster, "cost") -#'# Create patches from layer -#'patches_raster <- create_patches(seamounts_raster) -#'# Create patch dataframe -#'patches_raster_df <- create_patch_df(spatial_grid = planning_raster, features = features_raster, -#' patches = patches_raster, costs = cost_raster) -#'# Create boundary matrix for prioritizr -#'boundary_matrix <- create_boundary_matrix(spatial_grid = planning_raster, -#' patches = patches_raster, patch_df = patches_raster_df) +#'# Import some planning data +#' +#'#import planning units/ cost raster +#'pu_raster <- terra::rast(system.file("extdata/pu_raster.tif", package = "patchwise")) + +#'#import species distributions - feature data for planning +#'species_distributions <- terra::rast(system.file("extdata/spp_distributions.tif", package = "patchwise")) +#' +#'#import seamounts +#'seamounts <- terra::rast(system.file("extdata/seamounts.tif", package = "patchwise")) +#' +#'# Create seamount patches as multi-layer raster +#'patches_raster <- create_patches(seamounts) +#' +#'patches_df <- create_patch_df(spatial_grid = pu_raster, features = species_distributions, +#'patches = patches_raster, costs = pu_raster) +#' +#'#Create boundary matrix if you want to use a boundary penatly function in prioritizr +#'boundary_matrix <- create_boundary_matrix(spatial_grid = pu_raster, patches = patches_raster, patch_df = patches_df) + create_boundary_matrix <- function(spatial_grid, patches, patch_df){ diff --git a/R/create_patch_df.R b/R/create_patch_df.R index a97d610..f9848c6 100644 --- a/R/create_patch_df.R +++ b/R/create_patch_df.R @@ -1,37 +1,52 @@ -#' Create a dataframe that counts each patch independently for the prioritizr input +#' Create a dataframe that counts each patch independently for the prioritizr +#' input #' -#' @description This function takes all of the inputs of prioritizr and creates a dataframe precursor for prioritizr. This specific function includes the use of "patches" which have been already generated by `create_patches()`. "Patches" are spatial groups of a particular feature, such as seamounts. Prioritizr will protect entire patches to meet the protection goal for that feature. The output of this function should be passed to `create_boundary_matrix()` before being passed to prioritizr. +#' @description This function takes all of the inputs of prioritizr and creates +#' a dataframe precursor for prioritizr. This specific function includes the +#' use of "patches" which have been already generated by `create_patches()`. +#' "Patches" are spatial groups of a particular feature, such as seamounts. +#' Prioritizr will protect entire patches to meet the protection goal for that +#' feature. The output of this function should be passed to +#' `create_boundary_matrix()` before being passed to prioritizr. #' -#' @param spatial_grid a raster or sf template with the desired resolution and coordinate reference system generated by `spatialgridr::get_grid()`; values in areas of interest are 1, while all other values are NA -#' @param features a raster or sf object that includes all relevant features to be used in the prioritization; each layer of the raster or each column of the sf object identifies the location of each feature -#' @param patches a raster or sf object generated by `create_patches()`; a single feature split into spatially distinct groups; each layer of the raster or each column of the sf object identifies the location of each patch -#' @param costs a raster or sf object of the costs for protecting each cell in the planning grid -#' @param locked_out a raster or sf object for areas to be locked out (absolutely not protected) in the prioritization -#' @param locked_in a raster or sf object for areas to be locked in (absolutely protected) in the prioritization +#' @param spatial_grid a raster or sf template with the desired resolution and +#' coordinate reference system; values in areas of interest are 1, while all +#' other values are NA +#' @param features a raster or sf object that includes all relevant features to +#' be used in the prioritization; each layer of the raster or each column of +#' the sf object identifies the location of each feature +#' @param patches a raster or sf object generated by `create_patches()`; a +#' single feature split into spatially distinct groups; each layer of the +#' raster or each column of the sf object identifies the location of each +#' patch +#' @param costs a raster or sf object of the costs for protecting each cell in +#' the planning grid +#' @param locked_out a raster or sf object for areas to be locked out +#' (absolutely not protected) in the prioritization +#' @param locked_in a raster or sf object for areas to be locked in (absolutely +#' protected) in the prioritization #' #' @return A data frame to be used as an input for `create_boundary_matrix()` #' @importFrom rlang := #' @export #' #' @examples -#'# Start with a little housekeeping to get the data from oceandatr -#'# Choose area of interest (Bermuda EEZ) -#'area <- oceandatr::get_area(area_name = "Bermuda", mregions_column = "territory1") -#'projection <-'+proj=laea +lon_0=-64.8108333 +lat_0=32.3571917 +datum=WGS84 +units=m +no_defs' -#'# Create a planning grid -#'planning_raster <- spatialgridr::get_grid(area, projection = projection) -#'# Grab all relevant data -#'features_raster <- oceandatr::get_features(spatial_grid = planning_raster) -#'# Separate seamount data - we want to protect entire patches -#'seamounts_raster <- features_raster[["seamounts"]] -#'features_raster <- features_raster[[names(features_raster)[names(features_raster) != "seamounts"]]] -#'# Create a "cost" to protecting a cell - just a uniform cost for this example -#'cost_raster <- stats::setNames(planning_raster, "cost") -#'# Create patches from layer -#'patches_raster <- create_patches(seamounts_raster) -#'# Create patch dataframe -#'patches_raster_df <- create_patch_df(spatial_grid = planning_raster, features = features_raster, -#' patches = patches_raster, costs = cost_raster) +#'# Import some planning data +#' +#'#import planning units/ cost raster +#'pu_raster <- terra::rast(system.file("extdata/pu_raster.tif", package = "patchwise")) + +#'#import species distributions - feature data for planning +#'species_distributions <- terra::rast(system.file("extdata/spp_distributions.tif", package = "patchwise")) +#' +#'#import seamounts +#'seamounts <- terra::rast(system.file("extdata/seamounts.tif", package = "patchwise")) +#' +#'# Create seamount patches as multi-layer raster +#'patches_raster <- create_patches(seamounts) +#' +#'patches_df <- create_patch_df(spatial_grid = pu_raster, features = species_distributions, +#'patches = patches_raster, costs = pu_raster) create_patch_df <- function(spatial_grid, features, patches, costs = NULL, locked_out = NULL, locked_in = NULL){ @@ -190,7 +205,7 @@ create_patch_df <- function(spatial_grid, features, patches, costs = NULL, locke #Create a vector with a '1' for each combination of patch-level # and grid-cell level planning unit that overlaps with that patch. for (i in seq_len(nrow(pu_sm_data))) { - print(paste0("Processing patch ", i, " of ", nrow(pu_sm_data))) + message(paste0("Processing patch ", i, " of ", nrow(pu_sm_data))) for (j in pu_sm_data$idx[[i]]) { v <- rep(0, nrow(pu_data)) # initialize with zeros diff --git a/R/create_patches.R b/R/create_patches.R index 0fd40af..e48401b 100644 --- a/R/create_patches.R +++ b/R/create_patches.R @@ -1,29 +1,30 @@ -#' Create patches for a specific feature +#'Create patches for a specific feature #' -#' @description This function takes a feature and splits it into multiple "patches" of the feature. This is ideal for features that you want to protect x% of, but want to make sure that entire patches (as opposed to pieces of patches) are protected to meet that target. +#'@description This function takes a feature and splits it into multiple +#' "patches" of the feature. This is ideal for features that you want to +#' protect x% of, but want to make sure that entire patches (as opposed to +#' pieces of patches) are protected to meet that target. #' -#' @param feature a raster or sf object with the feature of interest present (value = 1) or absent (value = NA) -#' @param spatial_grid a raster or sf template with the desired resolution and coordinate reference system generated by `spatialgridr::get_grid()`; values in areas of interest are 1, while all other values are NA (only required if feature is a sf object) +#'@param feature a raster or sf object with the feature of interest present +#' (value = 1) or absent (value = NA) +#'@param spatial_grid a raster or sf template with the desired resolution and +#' coordinate reference system generated; values in areas of interest are 1, +#' while all other values are NA (only required if feature is a sf object) #' -#' @return A raster or sf object with independent layers (raster)/columns (sf) designating the location of each patch -#' @export +#'@return A raster or sf object with independent layers (raster)/columns (sf) +#' designating the location of each patch +#'@export #' #' @examples -#'# Start with a little housekeeping to get the data from oceandatr -#'# Choose area of interest (Bermuda EEZ) -#'area <- oceandatr::get_area(area_name = "Bermuda", mregions_column = "territory1") -#'projection <-'+proj=laea +lon_0=-64.8108333 +lat_0=32.3571917 +datum=WGS84 +units=m +no_defs' -#'# Create a planning grid -#'planning_raster <- spatialgridr::get_grid(area, projection = projection) -#'# Grab all relevant data -#'features_raster <- oceandatr::get_features(spatial_grid = planning_raster) -#'# Separate seamount data - we want to protect entire patches -#'seamounts_raster <- features_raster[["seamounts"]] -#'features_raster <- features_raster[[names(features_raster)[names(features_raster) != "seamounts"]]] -#'# Create a "cost" to protecting a cell - just a uniform cost for this example -#'cost_raster <- stats::setNames(planning_raster, "cost") -#'# Create patches from layer -#'patches_raster <- create_patches(seamounts_raster) +#'# Import some planning data +#'#import seamounts +#'seamounts <- terra::rast(system.file("extdata/seamounts.tif", package = "patchwise")) +#' +#'terra::plot(seamounts) +#' +#'# Create seamount patches as multi-layer raster +#'patches_raster <- create_patches(seamounts) +#'terra::plot(patches_raster) create_patches <- function(feature, spatial_grid = NULL) { diff --git a/R/features_targets.R b/R/features_targets.R index 965abd7..7f7b737 100644 --- a/R/features_targets.R +++ b/R/features_targets.R @@ -1,41 +1,39 @@ #' Create a dataframe for the relative and absolute targets for features #' -#' @description This function creates a dataframe of targets for each of the features to be used in the prioritization +#' @description This function creates a dataframe of targets for each of the +#' features to be used in the prioritization #' -#' @param targets a vector of targets for protection (range between 0 and 1); must be the same length as the number of features + the pre-patches variable -#' @param features a raster or sf object that includes all relevant features to be used in the prioritization; each layer of the raster or each column of the sf object identifies the location of each feature -#' @param pre_patches a raster or sf object that includes the feature that is to be split into patches (not the layer that is already split into patches) -#' @param locked_out a raster or sf object for areas to be locked out (absolutely not protected) in the prioritization -#' @param locked_in a raster or sf object for areas to be locked in (absolutely protected) in the prioritization +#' @param targets a vector of targets for protection (range between 0 and 1); +#' must be the same length as the number of features + the pre-patches +#' variable +#' @param features a raster or sf object that includes all relevant features to +#' be used in the prioritization; each layer of the raster or each column of +#' the sf object identifies the location of each feature +#' @param pre_patches a raster or sf object that includes the feature that is to +#' be split into patches (not the layer that is already split into patches) +#' @param locked_out a raster or sf object for areas to be locked out +#' (absolutely not protected) in the prioritization +#' @param locked_in a raster or sf object for areas to be locked in (absolutely +#' protected) in the prioritization #' -#' @return A data frame to be used to specify targets for features. Will need to be plugged into `constraint_targets()` before being implemented into prioritizr +#' @return A data frame to be used to specify targets for features. Will need to +#' be plugged into `constraint_targets()` before being implemented into +#' prioritizr #' @export #' #' @examples -#'# Start with a little housekeeping to get the data from oceandatr -#'# Choose area of interest (Bermuda EEZ) -#'area <- oceandatr::get_area(area_name = "Bermuda", mregions_column = "territory1") -#'projection <-'+proj=laea +lon_0=-64.8108333 +lat_0=32.3571917 +datum=WGS84 +units=m +no_defs' -#'# Create a planning grid -#'planning_raster <- spatialgridr::get_grid(area, projection = projection) -#'# Grab all relevant data -#'features_raster <- oceandatr::get_features(spatial_grid = planning_raster) -#'# Separate seamount data - we want to protect entire patches -#'seamounts_raster <- features_raster[["seamounts"]] -#'features_raster <- features_raster[[names(features_raster)[names(features_raster) != "seamounts"]]] -#'# Create a "cost" to protecting a cell - just a uniform cost for this example -#'cost_raster <- stats::setNames(planning_raster, "cost") -#'# Create patches from layer -#'patches_raster <- create_patches(seamounts_raster) -#'# Create patch dataframe -#'patches_raster_df <- create_patch_df(spatial_grid = planning_raster, features = features_raster, -#' patches = patches_raster, costs = cost_raster) -#'# Create boundary matrix for prioritizr -#'boundary_matrix <- create_boundary_matrix(spatial_grid = planning_raster, patches = patches_raster, -#' patch_df = patches_raster_df) -#'# Create target features - using just 20% for every feature -#'features_targets <- features_targets(targets = rep(0.2, (terra::nlyr(features_raster)) + 1), -#' features = features_raster, pre_patches = seamounts_raster) +#'# Import some planning data +#' +#'#import species distributions - feature data for planning +#'species_distributions <- terra::rast(system.file("extdata/spp_distributions.tif", package = "patchwise")) +#' +#'#import seamounts +#'seamounts <- terra::rast(system.file("extdata/seamounts.tif", package = "patchwise")) +#' +#' +#'# Create targets for protection - use 20% for each feature (including 20% of whole seamounts) in this example +#'targets_df <- features_targets(targets = rep(0.2, (terra::nlyr(species_distributions) + 1)), features = species_distributions, pre_patches = seamounts) +#'head(targets_df) features_targets <- function(targets, features, pre_patches, locked_out = NULL, locked_in = NULL){ diff --git a/README.Rmd b/README.Rmd index 21d461a..7baef07 100644 --- a/README.Rmd +++ b/README.Rmd @@ -13,6 +13,9 @@ knitr::opts_chunk$set( ) devtools::load_all() +library(prioritizr) +library(terra) +library(sf) ``` # patchwise patchwise website @@ -37,42 +40,24 @@ First load the libraries needed. Apart from `patchwise`, the `terra` package is ```{r libraries, eval=FALSE} library(patchwise) -``` -```{r, include=FALSE} library(prioritizr) library(terra) ``` -We will create some basic planning data to demonstrate how `patchwise` can be used. For this example we will create a raster planning grid which has a cost value of 1 for each cell, and the following features that will be targeted in the prioritization: +We will import some basic planning data to demonstrate how `patchwise` can be used. For this example we will use a a 40 x 40 raster planning grid which has a cost value of 1 for each cell, and the following features that will be targeted in the prioritization: - 4 random, binary (0 or 1) data layers, representing species distributions; for this example we are calling them fish - 3 "patches" of contiguous features; for this example we are calling them seamounts ```{r data-setup} -# create a 40 x 40 planning grid, with cost values all equal to 1 - -max_x_and_y <- 40 -pu_raster <- rast(nrows = max_x_and_y, ncols = max_x_and_y, xmin= 0, xmax= max_x_and_y, ymin= 0, ymax= max_x_and_y, resolution = 1 , vals = 1) |> - setNames("cost") - -#create a 4 layer raster of random, binary (0 or 1) features -# these could represent distributions of species; for this example they are named fish - -number_species <- 4 +#import planning units/ cost raster +pu_raster <- rast(system.file("extdata/pu_raster.tif", package = "patchwise")) -fish_distributions <- lapply(seq_len(number_species), function(x) { - setValues(pu_raster, round(runif(ncell(pu_raster)) > 0.5)) -}) |> - setNames(paste0("fish_", seq_len(number_species))) |> - rast() +#import fish distributions +fish_distributions <- rast(system.file("extdata/spp_distributions.tif", package = "patchwise")) -# create patches; for this example, they are named seamounts -seamounts <- data.frame(x = c(5, 22, 32), - y = c(5, 18, 29)) |> - vect() |> - buffer(4) |> - rasterize(pu_raster, field = 1) |> - setNames("Seamounts") +#import seamounts +seamounts <- rast(system.file("extdata/seamounts.tif", package = "patchwise")) ``` Let's look at our fish distributions and our seamounts @@ -84,8 +69,7 @@ plot(c(fish_distributions, seamounts)) Now we can use `patchwise` to do some pre-processing of the seamounts data so the seamounts can be prioritized as whole patches in the following prioritization. ```{r patchwise-prep} - -# Create seamount patches - seamount areas that touch are considered the same patch +# Create seamount patches patches_rast <- create_patches(seamounts) # Create patches dataframe - this creates constraints so that entire seamount patches are protected @@ -95,7 +79,7 @@ patches_df_rast <- create_patch_df(spatial_grid = pu_raster, features = fish_dis With that pre-processing done, we can now use `patchwise` to create protection targets for our features, including seamounts. In this example, we will use 20%, including 20% of whole seamounts. ```{r targets-constraints} -# Create targets for protection - let's just do 20% for each feature (including 20% of whole seamounts) +# Create targets for protection - 20% for each feature (including 20% of whole seamounts) targets_rast <- features_targets(targets = rep(0.2, (nlyr(fish_distributions) + 1)), features = fish_distributions, pre_patches = seamounts) # Add these targets to targets for protection for the "constraints" we introduced to protect entire seamount patches @@ -120,7 +104,7 @@ The solution object is a tibble. To convert this into a raster object for plotti ```{r convert-solution} # Convert the solution into a raster using the patchwise function `convert_solution()` -sol_rast_patches <- convert_solution(solution = solution_patches_tbl, patch_df = patches_df_rast, spatial_grid = pu_raster) |> +sol_rast_patches <- convert_solution(solution = solution_patches_tbl, patch_df = patches_df_rast, spatial_grid = pu_raster) |> setNames("With patchwise") ``` @@ -176,7 +160,7 @@ lines(as.polygons(seamounts), col = "red") The previous example used raster input data for the prioritization, but `patchwise` also handles `sf` data. -```{r} +```{r eval=FALSE} library(sf) ``` @@ -191,14 +175,82 @@ pu_sf <- as.polygons(pu_raster, aggregate = FALSE) |> features_sf <- as.polygons(fish_distributions, aggregate = FALSE) |> st_as_sf() -seamounts_sf <- as.polygons(seamounts, aggregate = FALSE) |> +seamounts_sf <- as.polygons(seamounts, aggregate = FALSE, na.rm = FALSE) |> st_as_sf() + +#replace NAs with zeroes +seamounts_sf[is.na(seamounts_sf$Seamounts), "Seamounts"] <- 0 ``` Let's check our features and seamounts look ok: ```{r} -plot(features_sf) -plot(seamounts_sf) +plot(cbind(features_sf, st_drop_geometry(seamounts_sf))) +``` + +Now we can run the same `patchwise` functions as we did with raster data to prepare the data for prioritization + +```{r patchwise-prep-sf} + +# Create seamount patches +patches_sf <- create_patches(seamounts_sf, spatial_grid = pu_sf) + +# Create patches dataframe - this creates constraints so that entire seamount patches are protected +patches_df_sf <- create_patch_df(spatial_grid = pu_sf, features = features_sf, patches = patches_sf, costs = pu_sf) + +# Create targets for protection - 20% for each feature (including 20% of whole seamounts) +targets_sf <- features_targets(targets = rep(0.2, ncol(features_sf)), features = features_sf, pre_patches = seamounts_sf) + +# Add these targets to targets for protection for the "constraints" we introduced to protect entire seamount patches +constraints_sf <- constraints_targets(feature_targets = targets_sf, patch_df = patches_df_sf) +``` + +With all the data preparation now done, we can run a prioritization using `prioritizr`: + +```{r prioritization_sf, include=FALSE} +# Create the prioritization problem +problem_patches_sf <- problem(x = patches_df_sf, features = constraints_sf$feature, cost_column = "cost") |> + add_min_set_objective() |> + add_manual_targets(constraints_sf) |> + add_binary_decisions() |> + add_default_solver() + +# Solve the prioritization +solution_patches_sf_tbl <- solve(problem_patches_sf) ``` +The solution object is a tibble. To convert this into a raster object for plotting, we use the `convert_solution()` function from `patchwise` + +```{r convert-solution-sf} +# Convert the solution into an sf object using the patchwise function `convert_solution()` +solution_sf_patches <- convert_solution(solution = solution_patches_sf_tbl, patch_df = patches_df_sf, spatial_grid = pu_sf) +``` + +For comparison, we will run a prioritization without using `patchwise` + +```{r prioritization-no-patches-sf, include=FALSE} +sf_planning_data <- cbind(features_sf, st_drop_geometry(seamounts_sf), st_drop_geometry(pu_sf)) + +problem_no_patches_sf <- problem(x = sf_planning_data, + features = names(st_drop_geometry(sf_planning_data)[-6]), + cost_column = "cost") |> + add_min_set_objective() |> + add_relative_targets(0.2) |> + add_binary_decisions() |> + add_default_solver() + +# Solve the prioritization +solution_no_patches_sf <- solve(problem_no_patches_sf) +``` + +We can now plot the solutions, and overlaying the outlines of the seamounts (in red), we can see that one entire seamount is included in the solution that used `patchwise`, whereas the solution without `patchwise` selects a few planning units in each seamount. Note that in the solution with `patchwise`, planning units that overlap seamounts that are not entirely selected have also been selected to meet targets for other features (fish distributions). + +```{r prioritization-plot-sf} +cbind(solution_no_patches_sf[,"solution_1"], st_drop_geometry(solution_sf_patches[, "protected"])) |> + setNames(c("Without patchwise", "With patchwise", "geometry")) |> + vect() |> + plot(1:2, + type = "interval", + plg = list(legend = c("Not selected", "Selected")), + fun = function()lines(as.polygons(seamounts, aggregate = TRUE), col = "red")) +``` diff --git a/README.md b/README.md index 312b841..459e705 100644 --- a/README.md +++ b/README.md @@ -1,214 +1,236 @@ + + + # patchwise patchwise website -`patchwise` is intended to be used as a supplementary package to `oceandatr` (and `spatialgridr`) for instances in which users wish to protect entire "chunks" of areas using `prioritizr`. -One example is when a user wishes to include seamounts as a feature to protect in `prioritizr` with a target of 20% protection. Instead of protecting a little bit of each seamount until the 20% is reached, `patchwise` makes it easy to ensure that entire seamounts are protected sequentially to meet the protection target. + -## Installation -You can install the development version of `patchwise` from GitHub with: + -``` -if (!require(devtools)) install.packages("devtools") -devtools::install_github("emlab-ucsb/patchwise") -``` +`patchwise` is intended to be used as a supplementary package to +`prioritizr` for instances in which users wish to protect entire +contiguous patches of features rather than portions of many features. +For example, consider conservation planning for an area of ocean where +seamounts are one of the biodiversity features that are targeted for +protection. If the seamounts span multiple planning units and +representation target of say 20% is used, portions of many seamounts +could be protected, but it might be better to protect the entirety +(contiguous patches) of a smaller number of seamounts. `patchwise` +provides this option, ensuring that representation targets are met by +representing whole features. + +## Installation -You can install `oceandatr` and `spatialgridr` from GitHub with: +You can install the development version of `patchwise` from +[GitHub](https://github.com/) with: +``` r +# install.packages("pak") +pak::pak("emlab-ucsb/patchwise") ``` -if (!require(devtools)) install.packages("devtools") -devtools::install_github("emlab-ucsb/oceandatr") -devtools::install_github("emlab-ucsb/spatialgridr") -``` - -## Examples of usage -### Using `raster` objects as inputs +## Example using raster data -Since this package is intended to be used in combination with `oceandatr`, there are several housekeeping steps that need to be completed first. +First load the libraries needed. Apart from `patchwise`, the `terra` +package is used for raster data manipulation, and `prioritizr` is used +for the spatial prioritization. -``` -# Load libraries +``` r library(patchwise) +library(prioritizr) +library(terra) +``` -# Choose area of interest (Bermuda EEZ) -area <- oceandatr::get_area(area_name = "Bermuda", mregions_column = "territory1") -projection <- '+proj=laea +lon_0=-64.8108333 +lat_0=32.3571917 +datum=WGS84 +units=m +no_defs' - -# Create a planning grid -planning_rast <- spatialgridr::get_grid(area, projection = projection) +We will import some basic planning data to demonstrate how `patchwise` +can be used. For this example we will use a a 40 x 40 raster planning +grid which has a cost value of 1 for each cell, and the following +features that will be targeted in the prioritization: -# Grab all relevant data -features_rast <- oceandatr::get_features(spatial_grid = planning_rast) +- 4 random, binary (0 or 1) data layers, representing species + distributions; for this example we are calling them fish +- 3 “patches” of contiguous features; for this example we are calling + them seamounts -# Create a "cost" to protecting a cell - just a uniform cost for this example -cost_rast <- stats::setNames(planning_rast, "cost") +``` r +#import planning units/ cost raster +pu_raster <- rast(system.file("extdata/pu_raster.tif", package = "patchwise")) -# Separate seamount data - we want to protect entire patches -seamounts_rast <- features_rast[["seamounts"]] -features_rast <- features_rast[[names(features_rast)[names(features_rast) != "seamounts"]]] +#import fish distributions +fish_distributions <- rast(system.file("extdata/spp_distributions.tif", package = "patchwise")) -# Show what seamounts look like... -terra::plot(seamounts_rast) # there are 7 seamount areas (seamounts that are touching) +#import seamounts +seamounts <- rast(system.file("extdata/seamounts.tif", package = "patchwise")) ``` -![](https://github.com/echelleburns/patchwise/assets/40546424/7e717d95-4673-4dac-8f59-dbb4865398ea) +Let’s look at our fish distributions and our seamounts +``` r +plot(c(fish_distributions, seamounts)) ``` -# Create seamount patches - seamount areas that touch are considered the same patch -patches_rast <- patchwise::create_patches(seamounts_rast) -# Create patches dataframe - this creates several constraints so that entire seamount units are protected together -patches_df_rast <- patchwise::create_patch_df(spatial_grid = planning_rast, features = features_rast, patches = patches_rast, costs = cost_rast) + -# Create boundary matrix for prioritizr -boundary_matrix_rast <- patchwise::create_boundary_matrix(spatial_grid = planning_rast, patches = patches_rast, patch_df = patches_df_rast) +Now we can use `patchwise` to do some pre-processing of the seamounts +data so the seamounts can be prioritized as whole patches in the +following prioritization. -# Create targets for protection - let's just do 20% for each feature (including 20% of whole seamounts) -targets_rast <- patchwise::features_targets(targets = rep(0.2, (terra::nlyr(features_rast) + 1)), features = features_rast, pre_patches = seamounts_rast) +``` r +# Create seamount patches +patches_rast <- create_patches(seamounts) -# Add these targets to targets for protection for the "constraints" we introduced to protect entire seamount units -constraints_rast <- patchwise::constraints_targets(feature_targets = targets_rast, patch_df = patches_df_rast) - -# Run the prioritization -problem_rast <- prioritizr::problem(x = patches_df_rast, features = constraints_rast$feature, cost_column = "cost") %>% - prioritizr::add_min_set_objective() %>% - prioritizr::add_manual_targets(constraints_rast) %>% - prioritizr::add_binary_decisions() %>% - prioritizr::add_boundary_penalties(penalty = 0.000002, data = boundary_matrix_rast) %>% - prioritizr::add_default_solver(gap = 0.1, threads = parallel::detectCores()-1) +# Create patches dataframe - this creates constraints so that entire seamount patches are protected +patches_df_rast <- create_patch_df(spatial_grid = pu_raster, features = fish_distributions, patches = patches_rast, costs = pu_raster) +#> Processing patch 1 of 3 +#> Processing patch 2 of 3 +#> Processing patch 3 of 3 +``` -# Solve the prioritization -solution_rast <- solve(problem_rast) +With that pre-processing done, we can now use `patchwise` to create +protection targets for our features, including seamounts. In this +example, we will use 20%, including 20% of whole seamounts. -# Convert the prioritization into a more digestible format -result_rast <- patchwise::convert_solution(solution = solution_rast, patch_df = patches_df_rast, spatial_grid = planning_rast) +``` r +# Create targets for protection - 20% for each feature (including 20% of whole seamounts) +targets_rast <- features_targets(targets = rep(0.2, (nlyr(fish_distributions) + 1)), features = fish_distributions, pre_patches = seamounts) -# Show the results -terra::plot(result_rast) +# Add these targets to targets for protection for the "constraints" we introduced to protect entire seamount patches +constraints_rast <- constraints_targets(feature_targets = targets_rast, patch_df = patches_df_rast) ``` -![](https://github.com/emlab-ucsb/patchwise/assets/40546424/82d88030-e915-4fde-a3ec-a99b62ff596d) - +With all the data preparation now done, we can run a prioritization +using `prioritizr`: -Areas in green were identified by `prioritizr` as areas worth protecting. We can see that entire seamounts were used to meet the target objective of protecting 20% of seamounts. We can compare this result to a `prioritizr` run that does not protect whole seamounts: +The solution object is a tibble. To convert this into a raster object +for plotting, we use the `convert_solution()` function from `patchwise` +``` r +# Convert the solution into a raster using the patchwise function `convert_solution()` +sol_rast_patches <- convert_solution(solution = solution_patches_tbl, patch_df = patches_df_rast, spatial_grid = pu_raster) |> + setNames("With patchwise") ``` -# Grab all relevant data -features_rast_nopatch <- oceandatr::get_features(spatial_grid = planning_rast) -# Run the prioritization -problem_rast_nopatch <- prioritizr::problem(x = cost_rast, features = features_rast_nopatch) %>% - prioritizr::add_min_set_objective() %>% - prioritizr::add_relative_targets(rep(0.2, terra::nlyr(features_rast_nopatch))) %>% - prioritizr::add_binary_decisions() %>% - prioritizr::add_boundary_penalties(penalty = 0.000002) %>% - prioritizr::add_default_solver(gap = 0.1, threads = parallel::detectCores()-1) +For comparison, we will run a prioritization without using `patchwise` -# Solve the prioritization -solution_nopatch <- solve(problem_rast_nopatch) +We can now plot the solutions, and overlaying the outlines of the +seamounts (in red), we can see that one entire seamount is included in +the solution that used `patchwise`, whereas the solution without +`patchwise` selects a few planning units in each seamount. Note that in +the solution with `patchwise`, planning units that overlap seamounts +that are not entirely selected have also been selected to meet targets +for other features (fish distributions). -# Show the results -terra::plot(solution_nopatch) +``` r +plot(c(solution_no_patches, sol_rast_patches), + fun = function()lines(as.polygons(seamounts), col = "red"), + plg = list(legend = c("Not selected", "Selected"))) ``` -![](https://github.com/emlab-ucsb/patchwise/assets/40546424/0d27f6df-32e4-49ff-abbc-720b930c26d4) + -Only portions of seamount units are protected here. +If you want to use a boundary penalty in the prioritization, we need to +manually create a boundary matrix using the `patchwise` function +`create_boundary_matrix()` -### Using `sf` objects as inputs +``` r +boundary_matrix_rast <- create_boundary_matrix(spatial_grid = pu_raster, patches = patches_rast, patch_df = patches_df_rast) +``` + +We can now re-run the prioritization with a boundary penalty -Since this package is intended to be used in combination with `oceandatr`, there are several housekeeping steps that need to be completed first. +We now get a solution with planning units more clustered together +``` r +plot(solution_rast_boundary, plg = list(legend = c("Not selected", "Selected"))) +lines(as.polygons(seamounts), col = "red") ``` -# Load libraries -library(patchwise) -# Choose area of interest (Bermuda EEZ) -area <- oceandatr::get_area(area_name = "Bermuda", mregions_column = "territory1") -projection <- '+proj=laea +lon_0=-64.8108333 +lat_0=32.3571917 +datum=WGS84 +units=m +no_defs' + -# Create a planning grid -planning_sf <- spatialgridr::get_grid(area, projection = projection, option = "sf_square") +## Example with sf data -# Grab all relevant data -features_sf <- oceandatr::get_features(spatial_grid = planning_sf) +The previous example used raster input data for the prioritization, but +`patchwise` also handles `sf` data. -# Create a "cost" to protecting a cell - just a uniform cost for this example -cost_sf <- features_sf %>% - dplyr::mutate(cost = 1) %>% - dplyr::select(cost) +``` r +library(sf) +``` -# Separate seamount data - we want to protect entire patches -seamounts_sf <- features_sf %>% - dplyr::select(seamounts) +First we need to create suitable `sf` data inputs. We can do this by +polygonizing the raster data: -features_sf <- features_sf %>% - dplyr::select(-seamounts) +``` r +#create the planning grid, which is also the same as the cost grid since we are using planning units all with cost = 1 +pu_sf <- as.polygons(pu_raster, aggregate = FALSE) |> + st_as_sf() -# Show what seamounts look like... -plot(seamounts_sf, border = F) # there are 7 seamount areas (seamounts that are touching) -``` +features_sf <- as.polygons(fish_distributions, aggregate = FALSE) |> + st_as_sf() -![](https://github.com/emlab-ucsb/patchwise/assets/40546424/892e0ee5-6791-4fb7-acac-6e3fcb8718b0) +seamounts_sf <- as.polygons(seamounts, aggregate = FALSE, na.rm = FALSE) |> + st_as_sf() +#replace NAs with zeroes +seamounts_sf[is.na(seamounts_sf$Seamounts), "Seamounts"] <- 0 ``` -# Create seamount patches - seamount areas that touch are considered the same patch -patches_sf <- patchwise::create_patches(seamounts_sf, spatial_grid = planning_sf) -# Create patches dataframe - this creates several constraints so that entire seamount units are protected together -patches_df_sf <- patchwise::create_patch_df(spatial_grid = planning_sf, features = features_sf, patches = patches_sf, costs = cost_sf) +Let’s check our features and seamounts look ok: -# Create boundary matrix for prioritizr -boundary_matrix_sf <- patchwise::create_boundary_matrix(spatial_grid = planning_sf, patches = patches_sf, patch_df = patches_df_sf) +``` r +plot(cbind(features_sf, st_drop_geometry(seamounts_sf))) +``` -# Create targets for protection - let's just do 20% for each feature (including 20% of whole seamounts) -targets_sf <- patchwise::features_targets(targets = rep(0.2, ncol(features_sf)), features = features_sf, pre_patches = seamounts_sf) + -# Add these targets to targets for protection for the "constraints" we introduced to protect entire seamount units -constraints_sf <- patchwise::constraints_targets(feature_targets = targets_sf, patch_df = patches_df_sf) +Now we can run the same `patchwise` functions as we did with raster data +to prepare the data for prioritization -# Run the prioritization -problem_sf <- prioritizr::problem(x = patches_df_sf, features = constraints_sf$feature, cost_column = "cost") %>% - prioritizr::add_min_set_objective() %>% - prioritizr::add_manual_targets(constraints_sf) %>% - prioritizr::add_binary_decisions() %>% - prioritizr::add_boundary_penalties(penalty = 0.000002, data = boundary_matrix_sf) %>% - prioritizr::add_default_solver(gap = 0.1, threads = parallel::detectCores()-1) +``` r -# Solve the prioritization -solution_sf <- solve(problem_sf) +# Create seamount patches +patches_sf <- create_patches(seamounts_sf, spatial_grid = pu_sf) -# Convert the prioritization into a more digestible format -result_sf <- patchwise::convert_solution(solution = solution_sf, patch_df = patches_df_sf, spatial_grid = planning_sf) +# Create patches dataframe - this creates constraints so that entire seamount patches are protected +patches_df_sf <- create_patch_df(spatial_grid = pu_sf, features = features_sf, patches = patches_sf, costs = pu_sf) +#> Processing patch 1 of 3 +#> Processing patch 2 of 3 +#> Processing patch 3 of 3 -# Show the results -plot(result_sf, border = F) +# Create targets for protection - 20% for each feature (including 20% of whole seamounts) +targets_sf <- features_targets(targets = rep(0.2, ncol(features_sf)), features = features_sf, pre_patches = seamounts_sf) + +# Add these targets to targets for protection for the "constraints" we introduced to protect entire seamount patches +constraints_sf <- constraints_targets(feature_targets = targets_sf, patch_df = patches_df_sf) ``` -![](https://github.com/emlab-ucsb/patchwise/assets/40546424/4fe72641-1693-43f5-a317-b86d30e7c54c) +With all the data preparation now done, we can run a prioritization +using `prioritizr`: -Areas in yellow were identified by `prioritizr` as areas worth protecting. We can see that entire seamounts were used to meet the target objective of protecting 20% of seamounts. We can compare this result to a `prioritizr` run that does not protect whole seamounts: +The solution object is a tibble. To convert this into a raster object +for plotting, we use the `convert_solution()` function from `patchwise` +``` r +# Convert the solution into an sf object using the patchwise function `convert_solution()` +solution_sf_patches <- convert_solution(solution = solution_patches_sf_tbl, patch_df = patches_df_sf, spatial_grid = pu_sf) ``` -# Grab all relevant data -features_sf_nopatch <- oceandatr::get_features(spatial_grid = planning_sf) %>% - dplyr::mutate(cost = 1) %>% # create a cost column - dplyr::relocate(cost, .before = x) # make sure cost column is before geometry column -# Run the prioritization -problem_sf_nopatch <- prioritizr::problem(x = features_sf_nopatch, features = names(features_sf_nopatch)[1:(ncol(features_sf_nopatch)-1)], cost_column = "cost") %>% - prioritizr::add_min_set_objective() %>% - prioritizr::add_relative_targets(rep(0.2, ncol(features_sf_nopatch)-1)) %>% - prioritizr::add_binary_decisions() %>% - prioritizr::add_boundary_penalties(penalty = 0.000002) %>% - prioritizr::add_default_solver(gap = 0.1, threads = parallel::detectCores()-1) +For comparison, we will run a prioritization without using `patchwise` -# Solve the prioritization -solution_sf_nopatch <- solve(problem_sf_nopatch) +We can now plot the solutions, and overlaying the outlines of the +seamounts (in red), we can see that one entire seamount is included in +the solution that used `patchwise`, whereas the solution without +`patchwise` selects a few planning units in each seamount. Note that in +the solution with `patchwise`, planning units that overlap seamounts +that are not entirely selected have also been selected to meet targets +for other features (fish distributions). -# Show the results -plot(solution_sf_nopatch %>% dplyr::select(solution_1), border = F) +``` r +cbind(solution_no_patches_sf[,"solution_1"], st_drop_geometry(solution_sf_patches[, "protected"])) |> + setNames(c("Without patchwise", "With patchwise", "geometry")) |> + vect() |> + plot(1:2, + type = "interval", + plg = list(legend = c("Not selected", "Selected")), + fun = function()lines(as.polygons(seamounts, aggregate = TRUE), col = "red")) ``` -![](https://github.com/emlab-ucsb/patchwise/assets/40546424/a4fee456-4206-4668-bd61-76e22b8b0222) - -Only portions of seamount units are protected here. + diff --git a/data-raw/example-data.R b/data-raw/example-data.R new file mode 100644 index 0000000..46763af --- /dev/null +++ b/data-raw/example-data.R @@ -0,0 +1,32 @@ +# Creation of a raster planning grid and some features for use in package examples + +# create a 40 x 40 planning grid, with cost values all equal to 1 + +max_x_and_y <- 40 +pu_raster <- terra::rast(nrows = max_x_and_y, ncols = max_x_and_y, xmin= 0, xmax= max_x_and_y, ymin= 0, ymax= max_x_and_y, resolution = 1 , vals = 1) |> + setNames("cost") + +#create a 4 layer raster of random, binary (0 or 1) features +# these could represent distributions of species; for this example they are named fish + +number_species <- 4 + +fish_distributions <- lapply(seq_len(number_species), function(x) { + terra::setValues(pu_raster, round(runif(terra::ncell(pu_raster)) > 0.5)) +}) |> + setNames(paste0("fish_", seq_len(number_species))) |> + terra::rast() + +# create patches; for this example, they are named seamounts +seamounts <- data.frame(x = c(5, 22, 32), + y = c(5, 18, 29)) |> + terra::vect() |> + terra::buffer(4) |> + terra::rasterize(pu_raster, field = 1) |> + setNames("Seamounts") + +terra::writeRaster(pu_raster, "inst/extdata/pu_raster.tif") + +terra::writeRaster(fish_distributions, "inst/extdata/spp_distributions.tif") + +terra::writeRaster(seamounts, "inst/extdata/seamounts.tif") diff --git a/figure/unnamed-chunk-10-1.png b/figure/unnamed-chunk-10-1.png deleted file mode 100644 index 42b235d94aa82848cf3d75dfae53757b1cbb0d60..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 112488 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 PuF;UVp}vOgW`SSvdI}U* z9EQxsY{@UG)))QPojs?JGmmzlCoMV?nMZx5A62pwHiGo>baSxgN`gp!T3BWJIm3u& zJV+7d+AEphA?}A^&1z`JH1&VGU73D0)ABX<^dUWLQj=>?%J~Iodk*}-GP@BiT-_WR zLcJjKv_Rof^2$HheU`&g<10e*h_}^C+)t{y84%zDzN)uULvl+4LbY-33Qv zdar9_>*S%E!<6!-bLyE215VP8BPnk;dajdpXju=Q_tCSvt$Qo_nUl=1rzd=SLAJ)B z*87!fqEG?q@n5fV&iI+AX#{<_uk+#WNpEa^-nd`U3n_fuI^}bNOR&V|N|&{Zfmh$0 zeBhtYONPxX^@W8phUA0u1|b8sKN12Mzq(7J)ehfDFa7h<@8`~{oVf4%3^58=n|5F-qEwbJWGvaYEMpCoWX)j6T9WMhSY~XA!B~=IFxD7~nZaNzWBI-H z`8?0}`Tdhu8Pm($_x--E>zs3)!(M_?ylNsBo^w&sOZoGtw=ah&tD?U`hyoL_{54_l z#d>x+VRo`o-p7dp=9hytU@m^+e2ZDSUPvSI3x)W-JAy512d`HA4lmC(MLHYh!xE_C ziZ9(scA>lruq$O0@$=Mj;}<#xE!s~Mr}xZuEnBtLC4>?+eb@9JbTUvB2~M-p)$T#J{ytmvF`C5 z4zq(+^3E7Z)t$F%p}em(HTYwQxrVrtcGA>W308-CzFL+%gHV9Ost4Cw#0tOLF3UKR zbk=@(ycI$cr|%DA+FH0ngroNi2e&V7RDl2{k-xp1#B z8Q`9N8&mVnDg>}_WV^q{#|&i!)hXHV-#2_8242(ficz8I?_I#m!v@h}%oQn$OX`>5 ziItK>_EF4Yy+oggvQR}ccs?fTFCW^?L;i_YmPeGkKf{S zx_r=IC3S9%uwb>*#Oa*Ix|M6(s#4>#$Eec5eZU{?Q7Lc0tdEO-ZHilKxl!!7=r_?y zEze*_1%6Rp95p>8CJ2`TnFlpru}Zw;Phn`*V%3Wr@V#AM_gKXZsq9F^xp)L+yiQWc z4BLR2OBb)j3FS}w;3fELp@GYl)Ik$@uMCDM$&+A~Qi~G~%EtWtipNas?c@=dI8A#4 zXh>+w?V7JDC;4C?`fiX47bady699H3dZ*Qwf+ZdmQP+v+Is>6KEU$|IP%#;9xa zmd{mMJ(Y@)_XdWk;z@sjc9DIIr+(?#`uMu@yxQJo2cGhyUS;hRm)2`jRi8UUh|5%7 zV?po8exwEhLAz7aiRZGzmyRhb3;DZh59OOW&CTaeUwFQJ;(g0&ckP)5-ehmw9A4xD z^)UI`azKE;`s3Il<^|O=n@N{6!Lr&Bo;nRLB;@=AQIa!Dk(VfZ&!~D2zhDVyVrhlACiBbpWc0ya zPkAW>a@phC;h~3N35wPfG3&!c`B>fl2<`$(vZ408J+A&~!C){?zNP-G)R99GXRTTf z7nnv8=M8?0I|63nDbfD56HaaABpxf^NB%5$8HioxOgL791KdtSDbH~M@4Sy2dH;0y z={o88d$+}>7-nWToXlfd!`;99Rn_OI;|rIc4lnc`NMal>iG>X_e$lGAD|Vv=OzLD{BE#c$rox{1Fqm5;7?K0UIeQu5xsIp~J8v|C|@3gKtV+boAL5zjrKNZApPEi}jNvb2Ew z=;