From 0bd04b368444286246fc7945d7791c79925b08f6 Mon Sep 17 00:00:00 2001 From: wlangera Date: Mon, 11 Mar 2024 13:40:14 +0100 Subject: [PATCH 01/19] ignore png files --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index b88ce52..b823aab 100644 --- a/.gitignore +++ b/.gitignore @@ -16,6 +16,7 @@ *.geojson *.kml *.csv +*.png *.shx *.xls* *_files From fb8ebe4e57a706f0e23e695bc1251607025537d9 Mon Sep 17 00:00:00 2001 From: wlangera Date: Mon, 11 Mar 2024 13:40:29 +0100 Subject: [PATCH 02/19] add figure steekproefkader duinen --- .../exploratie_duinen_weidestreek.Rmd | 128 ++++++++++++++++++ 1 file changed, 128 insertions(+) diff --git a/source/markdown/exploratie_duinen_weidestreek.Rmd b/source/markdown/exploratie_duinen_weidestreek.Rmd index cdf1d64..3c5d229 100644 --- a/source/markdown/exploratie_duinen_weidestreek.Rmd +++ b/source/markdown/exploratie_duinen_weidestreek.Rmd @@ -670,6 +670,128 @@ mapview( mapview(steekproefkader_finaal$Duinen, zcol = "stratum", layer = "stratum") ``` +```{r} +# Create png for report +detail_west <- c( + "xmin" = 34000, + "ymin" = 203000, + "xmax" = 40500, + "ymax" = 208000) + +detail_west_sf <- tibble(geometry = st_as_sfc(st_bbox(detail_west))) %>% + st_as_sf() %>% + st_set_crs(31370) + +mapview::mapviewOptions(fgb = FALSE) # opslaan werkt anders niet +dir.create("media/steekproeftrekking", showWarnings = FALSE) + +m <- mapview( + st_crop(kleine_landbouwstreken$Duinen, detail_west_sf), + color = "red", + alpha.regions = 0, + legend = FALSE, + lwd = 2 + ) + + mapview(st_crop(steekproefkader_finaal$Duinen, detail_west_sf), + zcol = "stratum", + layer = "stratum") + + mapview(detail_west_sf, color = "purple", alpha.regions = 0, legend = FALSE, + lwd = 2) + +mapview::mapshot(m, file = here("media", "steekproeftrekking", + "steekproefkader_duinen_west.png")) +``` + + +```{r} +detail_east <- c( + "xmin" = 77000, + "ymin" = 225000, + "xmax" = 81500, + "ymax" = 230000) + +detail_east_sf <- tibble(geometry = st_as_sfc(st_bbox(detail_east))) %>% + st_as_sf() %>% + st_set_crs(31370) + +m <- mapview( + st_crop(kleine_landbouwstreken$Duinen, detail_east_sf), + color = "red", + alpha.regions = 0, + legend = FALSE, + lwd = 2 + ) + + mapview(st_crop(steekproefkader_finaal$Duinen, detail_east_sf), + zcol = "stratum", + layer = "stratum") + + mapview(detail_east_sf, color = "purple", alpha.regions = 0, legend = FALSE, + lwd = 2) + +mapview::mapshot(m, file = here("media", "steekproeftrekking", + "steekproefkader_duinen_oost.png")) +``` + +```{r} +m <- mapview( + kleine_landbouwstreken$Duinen, + color = "red", + alpha.regions = 0, + legend = FALSE, + lwd = 1 + ) + + mapview(steekproefkader_finaal$Duinen, + zcol = "stratum", + layer = "stratum") + + mapview(detail_east_sf, color = "purple", alpha.regions = 0, legend = FALSE, + lwd = 1) + + mapview(detail_west_sf, color = "purple", alpha.regions = 0, legend = FALSE, + lwd = 1) + +mapview::mapshot(m, file = here("media", "steekproeftrekking", + "steekproefkader_duinen.png")) +``` + +```{r} +plot1 <- png::readPNG(here("media", "steekproeftrekking", + "steekproefkader_duinen_west.png")) +plot2 <- png::readPNG(here("media", "steekproeftrekking", + "steekproefkader_duinen_oost.png")) +plot3 <- png::readPNG(here("media", "steekproeftrekking", + "steekproefkader_duinen.png")) + +p <- cowplot::plot_grid( + grid::rasterGrob(plot3), + cowplot::plot_grid(grid::rasterGrob(plot1), grid::rasterGrob(plot2), + labels = c("A.", "B.")), + ncol = 1) + + +plots <- cowplot::align_plots( + grid::rasterGrob(plot3), grid::rasterGrob(plot1), + align = "v", axis = "l") +# then build the bottom row +bottom_row <- cowplot::plot_grid( + grid::rasterGrob(plot1), grid::rasterGrob(plot2), + labels = c("A.", "B."), label_size = 12) + +p <- cowplot::plot_grid(plots[[1]], bottom_row, ncol = 1) + +p <- cowplot::ggdraw(p) + + geom_text( + data = data.frame(x = c(0.38, 0.64), + y = c(0.72, 0.88), + label = c("A.", "B.")), + aes(x, y, label = label), size = 3, + inherit.aes = FALSE + ) + +ggsave(here("media", "steekproeftrekking", "steekproefkader_duinen_totaal.png"), + p, + dpi = 300, + width = 9, + height = 8) +``` + ## Weidestreek Er zijn geen soortbeschermingsmaatregelen in de Weidestreek binnen het steekproefkader. @@ -1059,3 +1181,9 @@ Ruimtelijk gezien komt de steekproef ook relatief goed overeen met het steekproe De Weidestreek is een aparte regio met een relatief groot oppervlak die gunstig is voor akkervogels. De steekproeftrekking van de Weidestreek kan dus wel een meerwaarde hebben voor uitspraken op Vlaams niveau. Het aantal telpunten kan groot genoeg zijn om uitspraken te doen op schaal van deze landbouwstreek zelf en de proporties van de strata in de steekproef komen relatief goed overeenkomen met deze in het steekproefkader. + +### Uitbreiding Weidestreek + +De vervolgvraag stelt zich of we een grotere finale steekproef kunnen bekomen door geen reservepunten te voorzien. + + From e571074d0ddf8f93174d431af54eccfb1c36f8a5 Mon Sep 17 00:00:00 2001 From: wlangera Date: Mon, 11 Mar 2024 14:01:19 +0100 Subject: [PATCH 03/19] create figure afbakening duinen --- .../exploratie_duinen_weidestreek.Rmd | 99 ++++++++++++++++++- 1 file changed, 98 insertions(+), 1 deletion(-) diff --git a/source/markdown/exploratie_duinen_weidestreek.Rmd b/source/markdown/exploratie_duinen_weidestreek.Rmd index 3c5d229..b6b9955 100644 --- a/source/markdown/exploratie_duinen_weidestreek.Rmd +++ b/source/markdown/exploratie_duinen_weidestreek.Rmd @@ -281,6 +281,104 @@ mapview( mapview(paden$Duinen, legend = FALSE) ``` +```{r} +# Create png for report +detail_westkant <- c( + "xmin" = 21500, + "ymin" = 197000, + "xmax" = 50000, + "ymax" = 217000) + +detail_westkant_sf <- tibble(geometry = st_as_sfc(st_bbox(detail_westkant))) %>% + st_as_sf() %>% + st_set_crs(31370) + +mapview::mapviewOptions(fgb = FALSE) # opslaan werkt anders niet +dir.create("media/steekproeftrekking", showWarnings = FALSE) + +m <- mapview( + st_crop(kleine_landbouwstreken$Duinen, detail_westkant_sf), + color = "red", + alpha.regions = 0, + legend = FALSE + ) + + mapview( + st_crop(selectie_openheid_klasses$Duinen, detail_westkant_sf), + col.regions = "red", + legend = FALSE + ) + + mapview( + st_crop(exclusie_osm_landgebruiken$Duinen, detail_westkant_sf), + col.regions = "green", + legend = FALSE + ) + + mapview( + st_crop(paden$Duinen, detail_westkant_sf), + legend = FALSE) + +mapview::mapshot(m, file = here("media", "steekproeftrekking", + "afbakening_duinen_west.png")) +``` + +```{r} +# Create png for report +detail_oostkant <- c( + "xmin" = 50000, + "ymin" = 213000, + "xmax" = 82000, + "ymax" = 230000) + +detail_oostkant_sf <- tibble(geometry = st_as_sfc(st_bbox(detail_oostkant))) %>% + st_as_sf() %>% + st_set_crs(31370) + +mapview::mapviewOptions(fgb = FALSE) # opslaan werkt anders niet +dir.create("media/steekproeftrekking", showWarnings = FALSE) + +m <- mapview( + st_crop(kleine_landbouwstreken$Duinen, detail_oostkant_sf), + color = "red", + alpha.regions = 0, + legend = FALSE + ) + + mapview( + st_crop(selectie_openheid_klasses$Duinen, detail_oostkant_sf), + col.regions = "red", + legend = FALSE + ) + + mapview( + st_crop(exclusie_osm_landgebruiken$Duinen, detail_oostkant_sf), + col.regions = "green", + legend = FALSE + ) + + mapview( + st_crop(paden$Duinen, detail_oostkant_sf), + legend = FALSE) + +mapview::mapshot(m, file = here("media", "steekproeftrekking", + "afbakening_duinen_oost.png")) +``` + +```{r} +plot1 <- png::readPNG(here("media", "steekproeftrekking", + "afbakening_duinen_west.png")) +plot2 <- png::readPNG(here("media", "steekproeftrekking", + "afbakening_duinen_oost.png")) + +p <- cowplot::plot_grid( + grid::rasterGrob(plot1), + grid::rasterGrob(plot2), + nrow = 1, labels = c("A.", "B.")) + + +ggsave(here("media", "steekproeftrekking", "afbakening_duinen_totaal.png"), + p, + dpi = 300, + width = 8, + height = 4) +``` + + ```{r} paden$Duinen %>% group_by(Naam, key, value) %>% @@ -702,7 +800,6 @@ mapview::mapshot(m, file = here("media", "steekproeftrekking", "steekproefkader_duinen_west.png")) ``` - ```{r} detail_east <- c( "xmin" = 77000, From 2be241087732a2966ebcc6af0927d5b1a53314fb Mon Sep 17 00:00:00 2001 From: wlangera Date: Mon, 11 Mar 2024 15:09:17 +0100 Subject: [PATCH 04/19] create figures weidestreek --- .../exploratie_duinen_weidestreek.Rmd | 47 ++++++++++++++++++- 1 file changed, 46 insertions(+), 1 deletion(-) diff --git a/source/markdown/exploratie_duinen_weidestreek.Rmd b/source/markdown/exploratie_duinen_weidestreek.Rmd index b6b9955..02609ff 100644 --- a/source/markdown/exploratie_duinen_weidestreek.Rmd +++ b/source/markdown/exploratie_duinen_weidestreek.Rmd @@ -409,6 +409,31 @@ mapview( mapview(paden$Weidestreek, legend = FALSE) ``` +```{r} +m <- mapview( + kleine_landbouwstreken$Weidestreek, + color = "red", + alpha.regions = 0, + legend = FALSE + ) + + mapview( + selectie_openheid_klasses$Weidestreek, + col.regions = "red", + legend = FALSE + ) + + mapview( + exclusie_osm_landgebruiken$Weidestreek, + col.regions = "green", + legend = FALSE + ) + + mapview( + paden$Weidestreek, + legend = FALSE) + +mapview::mapshot(m, file = here("media", "steekproeftrekking", + "afbakening_weidestreek.png")) +``` + ```{r} paden$Weidestreek %>% group_by(Naam, key, value) %>% @@ -914,7 +939,27 @@ mapview( alpha.regions = 0, legend = FALSE ) + - mapview(steekproefkader_finaal$Weidestreek, zcol = "stratum", layer = "stratum") + mapview( + steekproefkader_finaal$Weidestreek, + zcol = "stratum", + layer = "stratum") +``` + +```{r} +m <- mapview( + kleine_landbouwstreken$Weidestreek, + color = "red", + alpha.regions = 0, + legend = FALSE + ) + + mapview( + steekproefkader_finaal$Weidestreek, + zcol = "stratum", + layer = "stratum", + cex = 4) + +mapview::mapshot(m, file = here("media", "steekproeftrekking", + "steekproefkader_weidestreek.png")) ``` # Conclusie steekproefkader From ccdd0a56f332f2c3b610c708ecfe3dd337d3ec19 Mon Sep 17 00:00:00 2001 From: wlangera Date: Mon, 11 Mar 2024 16:40:45 +0100 Subject: [PATCH 05/19] calc chisq for size --- .../exploratie_duinen_weidestreek.Rmd | 69 +++++++++++++++++-- 1 file changed, 65 insertions(+), 4 deletions(-) diff --git a/source/markdown/exploratie_duinen_weidestreek.Rmd b/source/markdown/exploratie_duinen_weidestreek.Rmd index 02609ff..fce7395 100644 --- a/source/markdown/exploratie_duinen_weidestreek.Rmd +++ b/source/markdown/exploratie_duinen_weidestreek.Rmd @@ -300,7 +300,8 @@ m <- mapview( st_crop(kleine_landbouwstreken$Duinen, detail_westkant_sf), color = "red", alpha.regions = 0, - legend = FALSE + legend = FALSE, + lwd = 1 ) + mapview( st_crop(selectie_openheid_klasses$Duinen, detail_westkant_sf), @@ -339,7 +340,8 @@ m <- mapview( st_crop(kleine_landbouwstreken$Duinen, detail_oostkant_sf), color = "red", alpha.regions = 0, - legend = FALSE + legend = FALSE, + lwd = 1 ) + mapview( st_crop(selectie_openheid_klasses$Duinen, detail_oostkant_sf), @@ -414,7 +416,8 @@ m <- mapview( kleine_landbouwstreken$Weidestreek, color = "red", alpha.regions = 0, - legend = FALSE + legend = FALSE, + lwd = 2 ) + mapview( selectie_openheid_klasses$Weidestreek, @@ -950,7 +953,8 @@ m <- mapview( kleine_landbouwstreken$Weidestreek, color = "red", alpha.regions = 0, - legend = FALSE + legend = FALSE, + lwd = 2 ) + mapview( steekproefkader_finaal$Weidestreek, @@ -1328,4 +1332,61 @@ Het aantal telpunten kan groot genoeg zijn om uitspraken te doen op schaal van d De vervolgvraag stelt zich of we een grotere finale steekproef kunnen bekomen door geen reservepunten te voorzien. +```{r} +calc_chisq <- function(observed, expected) { + calc_df <- tibble(observed = observed, expected = expected) %>% + rowwise() %>% + mutate(single_chi = (observed - expected)^2 / expected) + + sum(calc_df$single_chi) +} +``` + +```{r} +sizes <- 50:80 +out_list <- vector(mode = "list", length = length(sizes)) + +for (i in seq_along(sizes)) { + extended_size <- sizes[i] + + allocatie_extended <- allocatie( + steekproefkader = steekproefkader_finaal$Weidestreek, + min_samplesize = 0, + target_samplesize = extended_size, + popsize_minimum = 0, + allocatie_binnen_sbp = allocatie_binnen_sbp$Weidestreek, + allocatie_leemstreek = 0, + ol_strata = c("OL", "HOL") + ) + + steekproef_extended <- draw_sample( + sampling_frame = steekproefkader_per_stratum$Weidestreek, + sample_size = extended_size, + sample_size_multiplication = 1, + balance = c("X", "Y") + ) + steekproef_extended_thinned <- thin_sample( + sample = steekproef_extended, + thin_dist = 600 + ) + + summary_df <- steekproef_extended_thinned %>% + st_drop_geometry() %>% + count(openheid_klasse, is_sbp) %>% + mutate(prop = n / sum(n)) %>% + full_join(allocatie_extended, by = join_by(openheid_klasse, is_sbp)) %>% + select(Naam, openheid_klasse, is_sbp, allocatie, samplesize, + prop_steekproef = prop, n_steekproef = n) + + out_list[[i]] <- tibble( + steekproef_grootte = extended_size, + finale_grootte = nrow(steekproef_extended_thinned), + chisq = calc_chisq(observed = summary_df$n_steekproef, + expected = summary_df$samplesize) + ) +} +names(out_list) <- sizes + +chi_squared_df <- do.call(rbind.data.frame, out_list) +``` From e535e1716829d44b6b7b003cc21bb7ff1714b3ba Mon Sep 17 00:00:00 2001 From: wlangera Date: Mon, 11 Mar 2024 17:23:48 +0100 Subject: [PATCH 06/19] create figure chisq --- .../exploratie_duinen_weidestreek.Rmd | 40 ++++++++++++++++++- 1 file changed, 39 insertions(+), 1 deletion(-) diff --git a/source/markdown/exploratie_duinen_weidestreek.Rmd b/source/markdown/exploratie_duinen_weidestreek.Rmd index fce7395..f98fe6c 100644 --- a/source/markdown/exploratie_duinen_weidestreek.Rmd +++ b/source/markdown/exploratie_duinen_weidestreek.Rmd @@ -28,12 +28,18 @@ opts_knit$set(root.dir = here::here()) ```{r} # packages library(tidyverse) +library(INBOtheme) library(sf) library(terra) library(nngeo) library(GVI) library(mapview) +theme_set(theme_inbo(transparent = TRUE)) + +# Conflicts +conflicted::conflicts_prefer(dplyr::filter) + # source mbag_dir <- here() source(here("source", "R", "steekproefkader.R")) @@ -1330,7 +1336,12 @@ Het aantal telpunten kan groot genoeg zijn om uitspraken te doen op schaal van d ### Uitbreiding Weidestreek +```{r} +sizes <- 40:80 +``` + De vervolgvraag stelt zich of we een grotere finale steekproef kunnen bekomen door geen reservepunten te voorzien. +We analiseren groottes van `r min(sizes)` tot `r max(sizes)`. ```{r} calc_chisq <- function(observed, expected) { @@ -1343,7 +1354,6 @@ calc_chisq <- function(observed, expected) { ``` ```{r} -sizes <- 50:80 out_list <- vector(mode = "list", length = length(sizes)) for (i in seq_along(sizes)) { @@ -1390,3 +1400,31 @@ names(out_list) <- sizes chi_squared_df <- do.call(rbind.data.frame, out_list) ``` + +```{r} +max_inf_val <- chi_squared_df %>% + filter(chisq == Inf) %>% + pull(steekproef_grootte) %>% + max() + +ggplot(chi_squared_df, aes(x = steekproef_grootte, y = chisq)) + + geom_point(aes(fill = finale_grootte), shape = 21, size = 3) + + geom_vline(xintercept = max_inf_val + 0.5, linetype = "dashed", + colour = "darkgrey") + + annotate("label", + x = max_inf_val, + y = max(pull(filter(chi_squared_df, chisq != Inf), chisq)), + label = "Inf", + colour = "black", + fill = "lightblue", + hjust = "right") + + geom_text(aes(label = finale_grootte), + position = position_nudge(x = -0.3, y = 0.5)) + + scale_x_continuous(minor_breaks = sizes, + breaks = seq(min(sizes), max(sizes), 5)) + + scale_fill_gradientn(colours = c("firebrick", "yellow2", "green")) + + labs(x = "Initiële steekproefgrootte", + y = "Chi-kwadraattoetsingsgrootheid", + fill = "Finale\nsteekproef-\ngrootte") +``` + From ca89f035913c9df2df8c2ddb1c846eec2fb27551 Mon Sep 17 00:00:00 2001 From: wlangera Date: Mon, 11 Mar 2024 17:54:39 +0100 Subject: [PATCH 07/19] fix bug in chi squared input --- .../exploratie_duinen_weidestreek.Rmd | 23 ++++--------------- 1 file changed, 5 insertions(+), 18 deletions(-) diff --git a/source/markdown/exploratie_duinen_weidestreek.Rmd b/source/markdown/exploratie_duinen_weidestreek.Rmd index f98fe6c..80c35cd 100644 --- a/source/markdown/exploratie_duinen_weidestreek.Rmd +++ b/source/markdown/exploratie_duinen_weidestreek.Rmd @@ -1337,7 +1337,7 @@ Het aantal telpunten kan groot genoeg zijn om uitspraken te doen op schaal van d ### Uitbreiding Weidestreek ```{r} -sizes <- 40:80 +sizes <- 40:100 ``` De vervolgvraag stelt zich of we een grotere finale steekproef kunnen bekomen door geen reservepunten te voorzien. @@ -1387,13 +1387,14 @@ for (i in seq_along(sizes)) { mutate(prop = n / sum(n)) %>% full_join(allocatie_extended, by = join_by(openheid_klasse, is_sbp)) %>% select(Naam, openheid_klasse, is_sbp, allocatie, samplesize, - prop_steekproef = prop, n_steekproef = n) + prop_steekproef = prop, n_steekproef = n) %>% + mutate(expected = allocatie * sum(n_steekproef)) out_list[[i]] <- tibble( steekproef_grootte = extended_size, finale_grootte = nrow(steekproef_extended_thinned), chisq = calc_chisq(observed = summary_df$n_steekproef, - expected = summary_df$samplesize) + expected = summary_df$expected) ) } names(out_list) <- sizes @@ -1402,24 +1403,10 @@ chi_squared_df <- do.call(rbind.data.frame, out_list) ``` ```{r} -max_inf_val <- chi_squared_df %>% - filter(chisq == Inf) %>% - pull(steekproef_grootte) %>% - max() - ggplot(chi_squared_df, aes(x = steekproef_grootte, y = chisq)) + geom_point(aes(fill = finale_grootte), shape = 21, size = 3) + - geom_vline(xintercept = max_inf_val + 0.5, linetype = "dashed", - colour = "darkgrey") + - annotate("label", - x = max_inf_val, - y = max(pull(filter(chi_squared_df, chisq != Inf), chisq)), - label = "Inf", - colour = "black", - fill = "lightblue", - hjust = "right") + geom_text(aes(label = finale_grootte), - position = position_nudge(x = -0.3, y = 0.5)) + + position = position_nudge(x = -0.3, y = 0.1)) + scale_x_continuous(minor_breaks = sizes, breaks = seq(min(sizes), max(sizes), 5)) + scale_fill_gradientn(colours = c("firebrick", "yellow2", "green")) + From aaf54d61b2ab46795cc62710482a1d928c4a2f86 Mon Sep 17 00:00:00 2001 From: wlangera Date: Mon, 11 Mar 2024 17:59:27 +0100 Subject: [PATCH 08/19] fix ggplot figure after bug fix --- source/markdown/exploratie_duinen_weidestreek.Rmd | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/source/markdown/exploratie_duinen_weidestreek.Rmd b/source/markdown/exploratie_duinen_weidestreek.Rmd index 80c35cd..98fa35f 100644 --- a/source/markdown/exploratie_duinen_weidestreek.Rmd +++ b/source/markdown/exploratie_duinen_weidestreek.Rmd @@ -1403,6 +1403,17 @@ chi_squared_df <- do.call(rbind.data.frame, out_list) ``` ```{r} +ggplot(chi_squared_df, aes(x = steekproef_grootte, y = chisq)) + + geom_point(aes(fill = finale_grootte), shape = 21, size = 3) + + geom_text(aes(label = finale_grootte), + position = position_nudge(x = -0.3, y = 0.1)) + + scale_x_continuous(minor_breaks = sizes, + breaks = seq(min(sizes), max(sizes), 5)) + + scale_fill_gradientn(colours = c("firebrick", "yellow2", "green")) + + labs(x = "Initiële steekproefgrootte", + y = "Chi-kwadraattoetsingsgrootheid", + fill = "Finale\nsteekproef-\ngrootte") + ggplot(chi_squared_df, aes(x = steekproef_grootte, y = chisq)) + geom_point(aes(fill = finale_grootte), shape = 21, size = 3) + geom_text(aes(label = finale_grootte), From eee552fb664d1218b5336be134fcee6499d90d69 Mon Sep 17 00:00:00 2001 From: wlangera Date: Tue, 12 Mar 2024 09:47:14 +0100 Subject: [PATCH 09/19] add thinning simulations --- .../exploratie_duinen_weidestreek.Rmd | 71 +++++++++++++++++-- 1 file changed, 67 insertions(+), 4 deletions(-) diff --git a/source/markdown/exploratie_duinen_weidestreek.Rmd b/source/markdown/exploratie_duinen_weidestreek.Rmd index 98fa35f..c25bd5b 100644 --- a/source/markdown/exploratie_duinen_weidestreek.Rmd +++ b/source/markdown/exploratie_duinen_weidestreek.Rmd @@ -1397,7 +1397,6 @@ for (i in seq_along(sizes)) { expected = summary_df$expected) ) } -names(out_list) <- sizes chi_squared_df <- do.call(rbind.data.frame, out_list) ``` @@ -1413,16 +1412,80 @@ ggplot(chi_squared_df, aes(x = steekproef_grootte, y = chisq)) + labs(x = "Initiële steekproefgrootte", y = "Chi-kwadraattoetsingsgrootheid", fill = "Finale\nsteekproef-\ngrootte") +``` -ggplot(chi_squared_df, aes(x = steekproef_grootte, y = chisq)) + +Wat als we spelen met de thinning? + +```{r} +thinning <- seq(400, 550, by = 50) +``` + +```{r} +out_list_thinning <- vector(mode = "list", + length = length(sizes) * length(thinning)) + +for (j in seq_along(thinning)) { + thin <- thinning[j] + for (i in seq_along(sizes)) { + extended_size <- sizes[i] + + print(paste0("Steekproefgrootte: ", extended_size, + ". Thinning: ", thin, ".")) + + allocatie_extended <- allocatie( + steekproefkader = steekproefkader_finaal$Weidestreek, + min_samplesize = 0, + target_samplesize = extended_size, + popsize_minimum = 0, + allocatie_binnen_sbp = allocatie_binnen_sbp$Weidestreek, + allocatie_leemstreek = 0, + ol_strata = c("OL", "HOL") + ) + + steekproef_extended <- draw_sample( + sampling_frame = steekproefkader_per_stratum$Weidestreek, + sample_size = extended_size, + sample_size_multiplication = 1, + balance = c("X", "Y") + ) + + steekproef_extended_thinned <- thin_sample( + sample = steekproef_extended, + thin_dist = thin + ) + + summary_df <- steekproef_extended_thinned %>% + st_drop_geometry() %>% + count(openheid_klasse, is_sbp) %>% + mutate(prop = n / sum(n)) %>% + full_join(allocatie_extended, by = join_by(openheid_klasse, is_sbp)) %>% + select(Naam, openheid_klasse, is_sbp, allocatie, samplesize, + prop_steekproef = prop, n_steekproef = n) %>% + mutate(expected = allocatie * sum(n_steekproef)) + + out_list_thinning[[i + (j - 1) * length(sizes)]] <- tibble( + steekproef_grootte = extended_size, + finale_grootte = nrow(steekproef_extended_thinned), + chisq = calc_chisq(observed = summary_df$n_steekproef, + expected = summary_df$expected), + thinning = thin + ) + } +} + +chi_squared_df_thinning <- do.call(rbind.data.frame, out_list_thinning) +``` + +```{r} +ggplot(chi_squared_df_thinning, aes(x = steekproef_grootte, y = chisq)) + geom_point(aes(fill = finale_grootte), shape = 21, size = 3) + geom_text(aes(label = finale_grootte), - position = position_nudge(x = -0.3, y = 0.1)) + + position = position_nudge(x = -0.3, y = 0.2)) + scale_x_continuous(minor_breaks = sizes, breaks = seq(min(sizes), max(sizes), 5)) + scale_fill_gradientn(colours = c("firebrick", "yellow2", "green")) + + facet_wrap(~thinning, ncol = 2) + labs(x = "Initiële steekproefgrootte", y = "Chi-kwadraattoetsingsgrootheid", fill = "Finale\nsteekproef-\ngrootte") ``` - From 4ebb2cc23811d3b64504d50e0f13fe8e66eb1cd0 Mon Sep 17 00:00:00 2001 From: wlangera Date: Tue, 12 Mar 2024 14:42:03 +0100 Subject: [PATCH 10/19] add targets weidestreek --- .../mas_steekproef_weidestreek/.Rprofile | 2 + .../mas_steekproef_weidestreek/_targets.R | 32 + .../_targets_packages.R | 27 + .../mas_steekproef_weidestreek.Rproj | 16 + .../mas_steekproef_weidestreek/renv.lock | 2632 +++++++++++++++++ .../renv/.gitignore | 7 + .../renv/activate.R | 1180 ++++++++ .../renv/settings.json | 19 + .../targets_steekproef_weidestreek.Rmd | 505 ++++ 9 files changed, 4420 insertions(+) create mode 100644 source/targets/mas_steekproef_weidestreek/.Rprofile create mode 100644 source/targets/mas_steekproef_weidestreek/_targets.R create mode 100644 source/targets/mas_steekproef_weidestreek/_targets_packages.R create mode 100644 source/targets/mas_steekproef_weidestreek/mas_steekproef_weidestreek.Rproj create mode 100644 source/targets/mas_steekproef_weidestreek/renv.lock create mode 100644 source/targets/mas_steekproef_weidestreek/renv/.gitignore create mode 100644 source/targets/mas_steekproef_weidestreek/renv/activate.R create mode 100644 source/targets/mas_steekproef_weidestreek/renv/settings.json create mode 100644 source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd diff --git a/source/targets/mas_steekproef_weidestreek/.Rprofile b/source/targets/mas_steekproef_weidestreek/.Rprofile new file mode 100644 index 0000000..89ae947 --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/.Rprofile @@ -0,0 +1,2 @@ +source("renv/activate.R") +library(sf) diff --git a/source/targets/mas_steekproef_weidestreek/_targets.R b/source/targets/mas_steekproef_weidestreek/_targets.R new file mode 100644 index 0000000..61c9de9 --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/_targets.R @@ -0,0 +1,32 @@ +# Generated by targets: do not edit by hand +library(targets) +lapply( + X = list.files( + path = file.path(targets::tar_path_script_support(), "globals"), + pattern = "\\.R$", + full.names = TRUE, + all.files = TRUE, + recursive = TRUE + ), + FUN = function(path) { + eval( + expr = parse(file = path, keep.source = TRUE), + envir = targets::tar_option_get(name = "envir") + ) + } +) +lapply( + X = list.files( + path = file.path(targets::tar_path_script_support(), "targets"), + pattern = "\\.R$", + full.names = TRUE, + all.files = TRUE, + recursive = TRUE + ), + FUN = function(path) { + eval( + expr = parse(file = path, keep.source = TRUE), + envir = targets::tar_option_get(name = "envir") + ) + } +) diff --git a/source/targets/mas_steekproef_weidestreek/_targets_packages.R b/source/targets/mas_steekproef_weidestreek/_targets_packages.R new file mode 100644 index 0000000..2946120 --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/_targets_packages.R @@ -0,0 +1,27 @@ +# Generated by targets::tar_renv(): do not edit by hand +library(GVI) +library(arrow) +library(bs4Dash) +library(clustermq) +library(dplyr) +library(exactextractr) +library(future) +library(gt) +library(httr) +library(markdown) +library(nngeo) +library(osmextract) +library(pingr) +library(qs) +library(readr) +library(rstudioapi) +library(sf) +library(shiny) +library(shinyWidgets) +library(shinybusy) +library(terra) +library(tibble) +library(tidyr) +library(visNetwork) +library(SamplingBigData) +library(duckdb) diff --git a/source/targets/mas_steekproef_weidestreek/mas_steekproef_weidestreek.Rproj b/source/targets/mas_steekproef_weidestreek/mas_steekproef_weidestreek.Rproj new file mode 100644 index 0000000..b42a3cc --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/mas_steekproef_weidestreek.Rproj @@ -0,0 +1,16 @@ +Version: 1.0 + +RestoreWorkspace: Default +SaveWorkspace: Default +AlwaysSaveHistory: Default + +EnableCodeIndexing: Yes +UseSpacesForTab: Yes +NumSpacesForTab: 2 +Encoding: UTF-8 + +RnwWeave: knitr +LaTeX: XeLaTeX + +AutoAppendNewline: Yes +StripTrailingWhitespace: Yes diff --git a/source/targets/mas_steekproef_weidestreek/renv.lock b/source/targets/mas_steekproef_weidestreek/renv.lock new file mode 100644 index 0000000..a018ded --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/renv.lock @@ -0,0 +1,2632 @@ +{ + "R": { + "Version": "4.3.2", + "Repositories": [ + { + "Name": "CRAN", + "URL": "https://packagemanager.posit.co/cran/latest" + }, + { + "Name": "INLA", + "URL": "https://inla.r-inla-download.org/R/stable" + }, + { + "Name": "inbo", + "URL": "https://inbo.r-universe.dev" + } + ] + }, + "Packages": { + "BH": { + "Package": "BH", + "Version": "1.81.0-1", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "68122010f01c4dcfbe58ce7112f2433d" + }, + "DBI": { + "Package": "DBI", + "Version": "1.2.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "methods" + ], + "Hash": "3e0051431dff9acfe66c23765e55c556" + }, + "GVI": { + "Package": "GVI", + "Version": "1.3", + "Source": "GitHub", + "RemoteType": "github", + "RemoteHost": "api.github.com", + "RemoteRepo": "GVI", + "RemoteUsername": "hansvancalster", + "RemoteRef": "patch-1", + "RemoteSha": "82c89ec5c4f4f788fb0974dd27c2082a4b0f2da3", + "Requirements": [ + "R", + "Rcpp", + "RcppProgress", + "doParallel", + "dplyr", + "foreach", + "ggplot2", + "graphics", + "magrittr", + "methods", + "purrr", + "raster", + "scales", + "sf", + "terra", + "tidyr", + "utils" + ], + "Hash": "121b538c9f9d4643b78430cc8f0112ec" + }, + "KernSmooth": { + "Package": "KernSmooth", + "Version": "2.23-22", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "stats" + ], + "Hash": "2fecebc3047322fa5930f74fae5de70f" + }, + "MASS": { + "Package": "MASS", + "Version": "7.3-60", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "grDevices", + "graphics", + "methods", + "stats", + "utils" + ], + "Hash": "a56a6365b3fa73293ea8d084be0d9bb0" + }, + "Matrix": { + "Package": "Matrix", + "Version": "1.6-4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "grDevices", + "graphics", + "grid", + "lattice", + "methods", + "stats", + "utils" + ], + "Hash": "d9c655b30a2edc6bb2244c1d1e8d549d" + }, + "R6": { + "Package": "R6", + "Version": "2.5.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "470851b6d5d0ac559e9d01bb352b4021" + }, + "RApiSerialize": { + "Package": "RApiSerialize", + "Version": "0.1.2", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "d8a79c95f553670ceffbd190815bbfce" + }, + "RColorBrewer": { + "Package": "RColorBrewer", + "Version": "1.1-3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "45f0398006e83a5b10b72a90663d8d8c" + }, + "Rcpp": { + "Package": "Rcpp", + "Version": "1.0.11", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "methods", + "utils" + ], + "Hash": "ae6cbbe1492f4de79c45fce06f967ce8" + }, + "RcppEigen": { + "Package": "RcppEigen", + "Version": "0.3.3.9.4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "Rcpp", + "stats", + "utils" + ], + "Hash": "acb0a5bf38490f26ab8661b467f4f53a" + }, + "RcppParallel": { + "Package": "RcppParallel", + "Version": "5.1.7", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "a45594a00f5dbb073d5ec9f48592a08a" + }, + "RcppProgress": { + "Package": "RcppProgress", + "Version": "0.4.2", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "1c0aa18b97e6aaa17f93b8b866c0ace5" + }, + "SamplingBigData": { + "Package": "SamplingBigData", + "Version": "1.0.0", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "7c6fae63a8843588a1462d74779c4b8b" + }, + "V8": { + "Package": "V8", + "Version": "4.4.1", + "Source": "Repository", + "Repository": "RSPM", + "Requirements": [ + "Rcpp", + "curl", + "jsonlite", + "utils" + ], + "Hash": "435359b59b8a9b8f9235135da471ea3c" + }, + "anytime": { + "Package": "anytime", + "Version": "0.3.9", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "BH", + "R", + "Rcpp" + ], + "Hash": "74a64813f17b492da9c6afda6b128e3d" + }, + "arrow": { + "Package": "arrow", + "Version": "14.0.0.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "R6", + "assertthat", + "bit64", + "cpp11", + "glue", + "methods", + "purrr", + "rlang", + "stats", + "tidyselect", + "utils", + "vctrs" + ], + "Hash": "042f2ee2286a91abe5a3d66c9be92380" + }, + "askpass": { + "Package": "askpass", + "Version": "1.2.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "sys" + ], + "Hash": "cad6cf7f1d5f6e906700b9d3e718c796" + }, + "assertthat": { + "Package": "assertthat", + "Version": "0.2.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "tools" + ], + "Hash": "50c838a310445e954bc13f26f26a6ecf" + }, + "backports": { + "Package": "backports", + "Version": "1.4.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "c39fbec8a30d23e721980b8afb31984c" + }, + "base64enc": { + "Package": "base64enc", + "Version": "0.1-3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "543776ae6848fde2f48ff3816d0628bc" + }, + "base64url": { + "Package": "base64url", + "Version": "1.4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "backports" + ], + "Hash": "0c54cf3a08cc0e550fbd64ad33166143" + }, + "bigD": { + "Package": "bigD", + "Version": "0.2.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "93637e906f3fe962413912c956eb44db" + }, + "bit": { + "Package": "bit", + "Version": "4.0.5", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "d242abec29412ce988848d0294b208fd" + }, + "bit64": { + "Package": "bit64", + "Version": "4.0.5", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "bit", + "methods", + "stats", + "utils" + ], + "Hash": "9fe98599ca456d6552421db0d6772d8f" + }, + "bitops": { + "Package": "bitops", + "Version": "1.0-7", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "b7d8d8ee39869c18d8846a184dd8a1af" + }, + "blob": { + "Package": "blob", + "Version": "1.2.4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "methods", + "rlang", + "vctrs" + ], + "Hash": "40415719b5a479b87949f3aa0aee737c" + }, + "bookdown": { + "Package": "bookdown", + "Version": "0.37", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "htmltools", + "jquerylib", + "knitr", + "rmarkdown", + "tinytex", + "xfun", + "yaml" + ], + "Hash": "b1b1c3be5c75309f6107726fa58ee20c" + }, + "broom": { + "Package": "broom", + "Version": "1.0.5", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "backports", + "dplyr", + "ellipsis", + "generics", + "glue", + "lifecycle", + "purrr", + "rlang", + "stringr", + "tibble", + "tidyr" + ], + "Hash": "fd25391c3c4f6ecf0fa95f1e6d15378c" + }, + "bs4Dash": { + "Package": "bs4Dash", + "Version": "2.3.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "bslib", + "fresh", + "htmltools", + "httpuv", + "httr", + "jsonlite", + "lifecycle", + "shiny", + "waiter" + ], + "Hash": "441417a5a4ad8d5c20d75f409630b7e8" + }, + "bslib": { + "Package": "bslib", + "Version": "0.6.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "base64enc", + "cachem", + "grDevices", + "htmltools", + "jquerylib", + "jsonlite", + "lifecycle", + "memoise", + "mime", + "rlang", + "sass" + ], + "Hash": "c0d8599494bc7fb408cd206bbdd9cab0" + }, + "cachem": { + "Package": "cachem", + "Version": "1.0.8", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "fastmap", + "rlang" + ], + "Hash": "c35768291560ce302c0a6589f92e837d" + }, + "callr": { + "Package": "callr", + "Version": "3.7.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "R6", + "processx", + "utils" + ], + "Hash": "9b2191ede20fa29828139b9900922e51" + }, + "cellranger": { + "Package": "cellranger", + "Version": "1.1.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "rematch", + "tibble" + ], + "Hash": "f61dbaec772ccd2e17705c1e872e9e7c" + }, + "class": { + "Package": "class", + "Version": "7.3-22", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "MASS", + "R", + "stats", + "utils" + ], + "Hash": "f91f6b29f38b8c280f2b9477787d4bb2" + }, + "classInt": { + "Package": "classInt", + "Version": "0.4-10", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "KernSmooth", + "R", + "class", + "e1071", + "grDevices", + "graphics", + "stats" + ], + "Hash": "f5a40793b1ae463a7ffb3902a95bf864" + }, + "cli": { + "Package": "cli", + "Version": "3.6.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "utils" + ], + "Hash": "1216ac65ac55ec0058a6f75d7ca0fd52" + }, + "clipr": { + "Package": "clipr", + "Version": "0.8.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "utils" + ], + "Hash": "3f038e5ac7f41d4ac41ce658c85e3042" + }, + "clustermq": { + "Package": "clustermq", + "Version": "0.9.2", + "Source": "Repository", + "Repository": "RSPM", + "Requirements": [ + "R", + "R6", + "Rcpp", + "methods", + "narray", + "progress", + "utils" + ], + "Hash": "c3319f2c87363fd8df84f2bbfc9a4182" + }, + "codetools": { + "Package": "codetools", + "Version": "0.2-19", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "c089a619a7fae175d149d89164f8c7d8" + }, + "colorspace": { + "Package": "colorspace", + "Version": "2.1-0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "grDevices", + "graphics", + "methods", + "stats" + ], + "Hash": "f20c47fd52fae58b4e377c37bb8c335b" + }, + "commonmark": { + "Package": "commonmark", + "Version": "1.9.0", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "d691c61bff84bd63c383874d2d0c3307" + }, + "conflicted": { + "Package": "conflicted", + "Version": "1.2.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "memoise", + "rlang" + ], + "Hash": "bb097fccb22d156624fd07cd2894ddb6" + }, + "cpp11": { + "Package": "cpp11", + "Version": "0.4.7", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "5a295d7d963cc5035284dcdbaf334f4e" + }, + "crayon": { + "Package": "crayon", + "Version": "1.5.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "grDevices", + "methods", + "utils" + ], + "Hash": "e8a1e41acf02548751f45c718d55aa6a" + }, + "credentials": { + "Package": "credentials", + "Version": "2.0.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "askpass", + "curl", + "jsonlite", + "openssl", + "sys" + ], + "Hash": "c7844b32098dcbd1c59cbd8dddb4ecc6" + }, + "curl": { + "Package": "curl", + "Version": "5.2.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "ce88d13c0b10fe88a37d9c59dba2d7f9" + }, + "data.table": { + "Package": "data.table", + "Version": "1.14.10", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "methods" + ], + "Hash": "6ea17a32294d8ca00455825ab0cf71b9" + }, + "dbplyr": { + "Package": "dbplyr", + "Version": "2.4.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "DBI", + "R", + "R6", + "blob", + "cli", + "dplyr", + "glue", + "lifecycle", + "magrittr", + "methods", + "pillar", + "purrr", + "rlang", + "tibble", + "tidyr", + "tidyselect", + "utils", + "vctrs", + "withr" + ], + "Hash": "59351f28a81f0742720b85363c4fdd61" + }, + "desc": { + "Package": "desc", + "Version": "1.4.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "R6", + "cli", + "utils" + ], + "Hash": "99b79fcbd6c4d1ce087f5c5c758b384f" + }, + "digest": { + "Package": "digest", + "Version": "0.6.33", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "utils" + ], + "Hash": "b18a9cf3c003977b0cc49d5e76ebe48d" + }, + "doParallel": { + "Package": "doParallel", + "Version": "1.0.17", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "foreach", + "iterators", + "parallel", + "utils" + ], + "Hash": "451e5edf411987991ab6a5410c45011f" + }, + "dplyr": { + "Package": "dplyr", + "Version": "1.1.4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "R6", + "cli", + "generics", + "glue", + "lifecycle", + "magrittr", + "methods", + "pillar", + "rlang", + "tibble", + "tidyselect", + "utils", + "vctrs" + ], + "Hash": "fedd9d00c2944ff00a0e2696ccf048ec" + }, + "dtplyr": { + "Package": "dtplyr", + "Version": "1.3.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "data.table", + "dplyr", + "glue", + "lifecycle", + "rlang", + "tibble", + "tidyselect", + "vctrs" + ], + "Hash": "54ed3ea01b11e81a86544faaecfef8e2" + }, + "duckdb": { + "Package": "duckdb", + "Version": "0.9.2-1", + "Source": "Repository", + "Repository": "RSPM", + "Requirements": [ + "DBI", + "R", + "methods", + "utils" + ], + "Hash": "3ce50b727c58e724c4c61397a41946ac" + }, + "e1071": { + "Package": "e1071", + "Version": "1.7-14", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "class", + "grDevices", + "graphics", + "methods", + "proxy", + "stats", + "utils" + ], + "Hash": "4ef372b716824753719a8a38b258442d" + }, + "ellipsis": { + "Package": "ellipsis", + "Version": "0.3.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "rlang" + ], + "Hash": "bb0eec2fe32e88d9e2836c2f73ea2077" + }, + "evaluate": { + "Package": "evaluate", + "Version": "0.23", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "methods" + ], + "Hash": "daf4a1246be12c1fa8c7705a0935c1a0" + }, + "exactextractr": { + "Package": "exactextractr", + "Version": "0.10.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "Rcpp", + "methods", + "raster", + "sf" + ], + "Hash": "3db813596387e90573ad092d5e3fde37" + }, + "fansi": { + "Package": "fansi", + "Version": "1.0.6", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "grDevices", + "utils" + ], + "Hash": "962174cf2aeb5b9eea581522286a911f" + }, + "farver": { + "Package": "farver", + "Version": "2.1.1", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "8106d78941f34855c440ddb946b8f7a5" + }, + "fastmap": { + "Package": "fastmap", + "Version": "1.1.1", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "f7736a18de97dea803bde0a2daaafb27" + }, + "fontawesome": { + "Package": "fontawesome", + "Version": "0.5.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "htmltools", + "rlang" + ], + "Hash": "c2efdd5f0bcd1ea861c2d4e2a883a67d" + }, + "forcats": { + "Package": "forcats", + "Version": "1.0.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "glue", + "lifecycle", + "magrittr", + "rlang", + "tibble" + ], + "Hash": "1a0a9a3d5083d0d573c4214576f1e690" + }, + "foreach": { + "Package": "foreach", + "Version": "1.5.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "codetools", + "iterators", + "utils" + ], + "Hash": "618609b42c9406731ead03adf5379850" + }, + "fresh": { + "Package": "fresh", + "Version": "0.2.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "htmltools", + "rstudioapi", + "sass", + "shiny" + ], + "Hash": "fa54367040deb4537da49b7ac0ee5770" + }, + "fs": { + "Package": "fs", + "Version": "1.6.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "methods" + ], + "Hash": "47b5f30c720c23999b913a1a635cf0bb" + }, + "future": { + "Package": "future", + "Version": "1.33.1", + "Source": "Repository", + "Repository": "RSPM", + "Requirements": [ + "digest", + "globals", + "listenv", + "parallel", + "parallelly", + "utils" + ], + "Hash": "e57e292737f7a4efa9d8a91c5908222c" + }, + "gargle": { + "Package": "gargle", + "Version": "1.5.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "fs", + "glue", + "httr", + "jsonlite", + "lifecycle", + "openssl", + "rappdirs", + "rlang", + "stats", + "utils", + "withr" + ], + "Hash": "fc0b272e5847c58cd5da9b20eedbd026" + }, + "generics": { + "Package": "generics", + "Version": "0.1.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "methods" + ], + "Hash": "15e9634c0fcd294799e9b2e929ed1b86" + }, + "gert": { + "Package": "gert", + "Version": "2.0.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "askpass", + "credentials", + "openssl", + "rstudioapi", + "sys", + "zip" + ], + "Hash": "f70d3fe2d9e7654213a946963d1591eb" + }, + "ggplot2": { + "Package": "ggplot2", + "Version": "3.4.4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "MASS", + "R", + "cli", + "glue", + "grDevices", + "grid", + "gtable", + "isoband", + "lifecycle", + "mgcv", + "rlang", + "scales", + "stats", + "tibble", + "vctrs", + "withr" + ], + "Hash": "313d31eff2274ecf4c1d3581db7241f9" + }, + "gh": { + "Package": "gh", + "Version": "1.4.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "gitcreds", + "httr2", + "ini", + "jsonlite", + "rlang" + ], + "Hash": "03533b1c875028233598f848fda44c4c" + }, + "gitcreds": { + "Package": "gitcreds", + "Version": "0.1.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "ab08ac61f3e1be454ae21911eb8bc2fe" + }, + "globals": { + "Package": "globals", + "Version": "0.16.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "codetools" + ], + "Hash": "baa9585ab4ce47a9f4618e671778cc6f" + }, + "glue": { + "Package": "glue", + "Version": "1.6.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "methods" + ], + "Hash": "4f2596dfb05dac67b9dc558e5c6fba2e" + }, + "googledrive": { + "Package": "googledrive", + "Version": "2.1.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "gargle", + "glue", + "httr", + "jsonlite", + "lifecycle", + "magrittr", + "pillar", + "purrr", + "rlang", + "tibble", + "utils", + "uuid", + "vctrs", + "withr" + ], + "Hash": "e99641edef03e2a5e87f0a0b1fcc97f4" + }, + "googlesheets4": { + "Package": "googlesheets4", + "Version": "1.1.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cellranger", + "cli", + "curl", + "gargle", + "glue", + "googledrive", + "httr", + "ids", + "lifecycle", + "magrittr", + "methods", + "purrr", + "rematch2", + "rlang", + "tibble", + "utils", + "vctrs", + "withr" + ], + "Hash": "d6db1667059d027da730decdc214b959" + }, + "gt": { + "Package": "gt", + "Version": "0.10.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "base64enc", + "bigD", + "bitops", + "cli", + "commonmark", + "dplyr", + "fs", + "glue", + "htmltools", + "htmlwidgets", + "juicyjuice", + "magrittr", + "markdown", + "reactable", + "rlang", + "sass", + "scales", + "tibble", + "tidyselect", + "xml2" + ], + "Hash": "21737c74811cccac01b5097bcb0f8b4c" + }, + "gtable": { + "Package": "gtable", + "Version": "0.3.4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "glue", + "grid", + "lifecycle", + "rlang" + ], + "Hash": "b29cf3031f49b04ab9c852c912547eef" + }, + "haven": { + "Package": "haven", + "Version": "2.5.4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "cpp11", + "forcats", + "hms", + "lifecycle", + "methods", + "readr", + "rlang", + "tibble", + "tidyselect", + "vctrs" + ], + "Hash": "9171f898db9d9c4c1b2c745adc2c1ef1" + }, + "highr": { + "Package": "highr", + "Version": "0.10", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "xfun" + ], + "Hash": "06230136b2d2b9ba5805e1963fa6e890" + }, + "hms": { + "Package": "hms", + "Version": "1.1.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "lifecycle", + "methods", + "pkgconfig", + "rlang", + "vctrs" + ], + "Hash": "b59377caa7ed00fa41808342002138f9" + }, + "htmltools": { + "Package": "htmltools", + "Version": "0.5.7", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "base64enc", + "digest", + "ellipsis", + "fastmap", + "grDevices", + "rlang", + "utils" + ], + "Hash": "2d7b3857980e0e0d0a1fd6f11928ab0f" + }, + "htmlwidgets": { + "Package": "htmlwidgets", + "Version": "1.6.4", + "Source": "Repository", + "Repository": "RSPM", + "Requirements": [ + "grDevices", + "htmltools", + "jsonlite", + "knitr", + "rmarkdown", + "yaml" + ], + "Hash": "04291cc45198225444a397606810ac37" + }, + "httpuv": { + "Package": "httpuv", + "Version": "1.6.13", + "Source": "Repository", + "Repository": "RSPM", + "Requirements": [ + "R", + "R6", + "Rcpp", + "later", + "promises", + "utils" + ], + "Hash": "d23d2879001f3d82ee9dc38a9ef53c4c" + }, + "httr": { + "Package": "httr", + "Version": "1.4.7", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "R6", + "curl", + "jsonlite", + "mime", + "openssl" + ], + "Hash": "ac107251d9d9fd72f0ca8049988f1d7f" + }, + "httr2": { + "Package": "httr2", + "Version": "1.0.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "R6", + "cli", + "curl", + "glue", + "lifecycle", + "magrittr", + "openssl", + "rappdirs", + "rlang", + "vctrs", + "withr" + ], + "Hash": "e2b30f1fc039a0bab047dd52bb20ef71" + }, + "ids": { + "Package": "ids", + "Version": "1.0.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "openssl", + "uuid" + ], + "Hash": "99df65cfef20e525ed38c3d2577f7190" + }, + "igraph": { + "Package": "igraph", + "Version": "1.6.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "Matrix", + "R", + "cli", + "cpp11", + "grDevices", + "graphics", + "lifecycle", + "magrittr", + "methods", + "pkgconfig", + "rlang", + "stats", + "utils" + ], + "Hash": "eef74fe28b747e52288ea9e1d3600034" + }, + "ini": { + "Package": "ini", + "Version": "0.3.1", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "6154ec2223172bce8162d4153cda21f7" + }, + "isoband": { + "Package": "isoband", + "Version": "0.2.7", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "grid", + "utils" + ], + "Hash": "0080607b4a1a7b28979aecef976d8bc2" + }, + "iterators": { + "Package": "iterators", + "Version": "1.0.14", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "utils" + ], + "Hash": "8954069286b4b2b0d023d1b288dce978" + }, + "jquerylib": { + "Package": "jquerylib", + "Version": "0.1.4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "htmltools" + ], + "Hash": "5aab57a3bd297eee1c1d862735972182" + }, + "jsonlite": { + "Package": "jsonlite", + "Version": "1.8.8", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "methods" + ], + "Hash": "e1b9c55281c5adc4dd113652d9e26768" + }, + "juicyjuice": { + "Package": "juicyjuice", + "Version": "0.1.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "V8" + ], + "Hash": "3bcd11943da509341838da9399e18bce" + }, + "knitr": { + "Package": "knitr", + "Version": "1.45", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "evaluate", + "highr", + "methods", + "tools", + "xfun", + "yaml" + ], + "Hash": "1ec462871063897135c1bcbe0fc8f07d" + }, + "labeling": { + "Package": "labeling", + "Version": "0.4.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "graphics", + "stats" + ], + "Hash": "b64ec208ac5bc1852b285f665d6368b3" + }, + "later": { + "Package": "later", + "Version": "1.3.2", + "Source": "Repository", + "Repository": "RSPM", + "Requirements": [ + "Rcpp", + "rlang" + ], + "Hash": "a3e051d405326b8b0012377434c62b37" + }, + "lattice": { + "Package": "lattice", + "Version": "0.22-5", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "grDevices", + "graphics", + "grid", + "stats", + "utils" + ], + "Hash": "7c5e89f04e72d6611c77451f6331a091" + }, + "lifecycle": { + "Package": "lifecycle", + "Version": "1.0.4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "glue", + "rlang" + ], + "Hash": "b8552d117e1b808b09a832f589b79035" + }, + "listenv": { + "Package": "listenv", + "Version": "0.9.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "4fbd3679ec8ee169ba28d4b1ea7d0e8f" + }, + "lubridate": { + "Package": "lubridate", + "Version": "1.9.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "generics", + "methods", + "timechange" + ], + "Hash": "680ad542fbcf801442c83a6ac5a2126c" + }, + "magrittr": { + "Package": "magrittr", + "Version": "2.0.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "7ce2733a9826b3aeb1775d56fd305472" + }, + "markdown": { + "Package": "markdown", + "Version": "1.12", + "Source": "Repository", + "Repository": "RSPM", + "Requirements": [ + "R", + "commonmark", + "utils", + "xfun" + ], + "Hash": "765cf53992401b3b6c297b69e1edb8bd" + }, + "memoise": { + "Package": "memoise", + "Version": "2.0.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "cachem", + "rlang" + ], + "Hash": "e2817ccf4a065c5d9d7f2cfbe7c1d78c" + }, + "mgcv": { + "Package": "mgcv", + "Version": "1.9-1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "Matrix", + "R", + "graphics", + "methods", + "nlme", + "splines", + "stats", + "utils" + ], + "Hash": "110ee9d83b496279960e162ac97764ce" + }, + "mime": { + "Package": "mime", + "Version": "0.12", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "tools" + ], + "Hash": "18e9c28c1d3ca1560ce30658b22ce104" + }, + "modelr": { + "Package": "modelr", + "Version": "0.1.11", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "broom", + "magrittr", + "purrr", + "rlang", + "tibble", + "tidyr", + "tidyselect", + "vctrs" + ], + "Hash": "4f50122dc256b1b6996a4703fecea821" + }, + "munsell": { + "Package": "munsell", + "Version": "0.5.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "colorspace", + "methods" + ], + "Hash": "6dfe8bf774944bd5595785e3229d8771" + }, + "nabor": { + "Package": "nabor", + "Version": "0.5.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "BH", + "R", + "Rcpp", + "RcppEigen", + "methods" + ], + "Hash": "54388cc0cf3dfc0948a4bfbf9e8cceba" + }, + "narray": { + "Package": "narray", + "Version": "0.5.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "Rcpp", + "progress", + "stats", + "stringr", + "utils" + ], + "Hash": "7ec5a2396d3c9ad4374495283dfcdc83" + }, + "nlme": { + "Package": "nlme", + "Version": "3.1-164", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "graphics", + "lattice", + "stats", + "utils" + ], + "Hash": "a623a2239e642806158bc4dc3f51565d" + }, + "nngeo": { + "Package": "nngeo", + "Version": "0.4.7", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "data.table", + "methods", + "nabor", + "parallel", + "sf", + "units" + ], + "Hash": "e07deca5934b4e567b2089d5ebc85ef7" + }, + "openssl": { + "Package": "openssl", + "Version": "2.1.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "askpass" + ], + "Hash": "2a0dc8c6adfb6f032e4d4af82d258ab5" + }, + "osmextract": { + "Package": "osmextract", + "Version": "0.5.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "httr", + "jsonlite", + "sf", + "tools", + "utils" + ], + "Hash": "325765c4927551138994b1722d6094fc" + }, + "parallelly": { + "Package": "parallelly", + "Version": "1.36.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "parallel", + "tools", + "utils" + ], + "Hash": "bca377e1c87ec89ebed77bba00635b2e" + }, + "pillar": { + "Package": "pillar", + "Version": "1.9.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "cli", + "fansi", + "glue", + "lifecycle", + "rlang", + "utf8", + "utils", + "vctrs" + ], + "Hash": "15da5a8412f317beeee6175fbc76f4bb" + }, + "pingr": { + "Package": "pingr", + "Version": "2.0.3", + "Source": "Repository", + "Repository": "RSPM", + "Requirements": [ + "R", + "processx", + "utils" + ], + "Hash": "8d2db1d13f4198a00ebf2f066bf2ab67" + }, + "pkgconfig": { + "Package": "pkgconfig", + "Version": "2.0.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "utils" + ], + "Hash": "01f28d4278f15c76cddbea05899c5d6f" + }, + "prettyunits": { + "Package": "prettyunits", + "Version": "1.2.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "6b01fc98b1e86c4f705ce9dcfd2f57c7" + }, + "processx": { + "Package": "processx", + "Version": "3.8.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "R6", + "ps", + "utils" + ], + "Hash": "82d48b1aec56084d9438dbf98087a7e9" + }, + "progress": { + "Package": "progress", + "Version": "1.2.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "R6", + "crayon", + "hms", + "prettyunits" + ], + "Hash": "f4625e061cb2865f111b47ff163a5ca6" + }, + "promises": { + "Package": "promises", + "Version": "1.2.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R6", + "Rcpp", + "fastmap", + "later", + "magrittr", + "rlang", + "stats" + ], + "Hash": "0d8a15c9d000970ada1ab21405387dee" + }, + "proxy": { + "Package": "proxy", + "Version": "0.4-27", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "stats", + "utils" + ], + "Hash": "e0ef355c12942cf7a6b91a6cfaea8b3e" + }, + "ps": { + "Package": "ps", + "Version": "1.7.5", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "utils" + ], + "Hash": "709d852d33178db54b17c722e5b1e594" + }, + "purrr": { + "Package": "purrr", + "Version": "1.0.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "lifecycle", + "magrittr", + "rlang", + "vctrs" + ], + "Hash": "1cba04a4e9414bdefc9dcaa99649a8dc" + }, + "qs": { + "Package": "qs", + "Version": "0.25.7", + "Source": "Repository", + "Repository": "RSPM", + "Requirements": [ + "R", + "RApiSerialize", + "Rcpp", + "stringfish" + ], + "Hash": "f5adb766329cc757980d943ce472e831" + }, + "ragg": { + "Package": "ragg", + "Version": "1.2.7", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "systemfonts", + "textshaping" + ], + "Hash": "90a1b8b7e518d7f90480d56453b4d062" + }, + "rappdirs": { + "Package": "rappdirs", + "Version": "0.3.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "5e3c5dc0b071b21fa128676560dbe94d" + }, + "raster": { + "Package": "raster", + "Version": "3.6-26", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "Rcpp", + "methods", + "sp", + "terra" + ], + "Hash": "7d6eda494f34a644420ac1bfd2a8023a" + }, + "reactR": { + "Package": "reactR", + "Version": "0.5.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "htmltools" + ], + "Hash": "c9014fd1a435b2d790dd506589cb24e5" + }, + "reactable": { + "Package": "reactable", + "Version": "0.4.4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "digest", + "htmltools", + "htmlwidgets", + "jsonlite", + "reactR" + ], + "Hash": "6069eb2a6597963eae0605c1875ff14c" + }, + "readr": { + "Package": "readr", + "Version": "2.1.4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "R6", + "cli", + "clipr", + "cpp11", + "crayon", + "hms", + "lifecycle", + "methods", + "rlang", + "tibble", + "tzdb", + "utils", + "vroom" + ], + "Hash": "b5047343b3825f37ad9d3b5d89aa1078" + }, + "readxl": { + "Package": "readxl", + "Version": "1.4.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cellranger", + "cpp11", + "progress", + "tibble", + "utils" + ], + "Hash": "8cf9c239b96df1bbb133b74aef77ad0a" + }, + "rematch": { + "Package": "rematch", + "Version": "2.0.0", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "cbff1b666c6fa6d21202f07e2318d4f1" + }, + "rematch2": { + "Package": "rematch2", + "Version": "2.1.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "tibble" + ], + "Hash": "76c9e04c712a05848ae7a23d2f170a40" + }, + "renv": { + "Package": "renv", + "Version": "1.0.3", + "Source": "Repository", + "Repository": "RSPM", + "Requirements": [ + "utils" + ], + "Hash": "41b847654f567341725473431dd0d5ab" + }, + "reprex": { + "Package": "reprex", + "Version": "2.0.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "callr", + "cli", + "clipr", + "fs", + "glue", + "knitr", + "lifecycle", + "rlang", + "rmarkdown", + "rstudioapi", + "utils", + "withr" + ], + "Hash": "d66fe009d4c20b7ab1927eb405db9ee2" + }, + "rlang": { + "Package": "rlang", + "Version": "1.1.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "utils" + ], + "Hash": "50a6dbdc522936ca35afc5e2082ea91b" + }, + "rmarkdown": { + "Package": "rmarkdown", + "Version": "2.25", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "bslib", + "evaluate", + "fontawesome", + "htmltools", + "jquerylib", + "jsonlite", + "knitr", + "methods", + "stringr", + "tinytex", + "tools", + "utils", + "xfun", + "yaml" + ], + "Hash": "d65e35823c817f09f4de424fcdfa812a" + }, + "rprojroot": { + "Package": "rprojroot", + "Version": "2.0.4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "4c8415e0ec1e29f3f4f6fc108bef0144" + }, + "rstudioapi": { + "Package": "rstudioapi", + "Version": "0.15.0", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "5564500e25cffad9e22244ced1379887" + }, + "rvest": { + "Package": "rvest", + "Version": "1.0.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "glue", + "httr", + "lifecycle", + "magrittr", + "rlang", + "selectr", + "tibble", + "withr", + "xml2" + ], + "Hash": "a4a5ac819a467808c60e36e92ddf195e" + }, + "s2": { + "Package": "s2", + "Version": "1.1.6", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "Rcpp", + "wk" + ], + "Hash": "32f7b1a15bb01ae809022960abad5363" + }, + "sass": { + "Package": "sass", + "Version": "0.4.8", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R6", + "fs", + "htmltools", + "rappdirs", + "rlang" + ], + "Hash": "168f9353c76d4c4b0a0bbf72e2c2d035" + }, + "scales": { + "Package": "scales", + "Version": "1.3.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "R6", + "RColorBrewer", + "cli", + "farver", + "glue", + "labeling", + "lifecycle", + "munsell", + "rlang", + "viridisLite" + ], + "Hash": "c19df082ba346b0ffa6f833e92de34d1" + }, + "selectr": { + "Package": "selectr", + "Version": "0.4-2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "R6", + "methods", + "stringr" + ], + "Hash": "3838071b66e0c566d55cc26bd6e27bf4" + }, + "sf": { + "Package": "sf", + "Version": "1.0-15", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "DBI", + "R", + "Rcpp", + "classInt", + "grDevices", + "graphics", + "grid", + "magrittr", + "methods", + "s2", + "stats", + "tools", + "units", + "utils" + ], + "Hash": "f432b3379fb1a47046e253468b6b6b6d" + }, + "shiny": { + "Package": "shiny", + "Version": "1.8.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "R6", + "bslib", + "cachem", + "commonmark", + "crayon", + "ellipsis", + "fastmap", + "fontawesome", + "glue", + "grDevices", + "htmltools", + "httpuv", + "jsonlite", + "later", + "lifecycle", + "methods", + "mime", + "promises", + "rlang", + "sourcetools", + "tools", + "utils", + "withr", + "xtable" + ], + "Hash": "3a1f41807d648a908e3c7f0334bf85e6" + }, + "shinyWidgets": { + "Package": "shinyWidgets", + "Version": "0.8.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "anytime", + "bslib", + "grDevices", + "htmltools", + "jsonlite", + "rlang", + "sass", + "shiny" + ], + "Hash": "c6acc72327e63668bbc7bd258ee54132" + }, + "shinybusy": { + "Package": "shinybusy", + "Version": "0.3.2", + "Source": "Repository", + "Repository": "RSPM", + "Requirements": [ + "htmltools", + "htmlwidgets", + "jsonlite", + "shiny" + ], + "Hash": "cfb1edf0a7b334747556da1598ef67b1" + }, + "sourcetools": { + "Package": "sourcetools", + "Version": "0.1.7-1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "5f5a7629f956619d519205ec475fe647" + }, + "sp": { + "Package": "sp", + "Version": "2.1-2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "grDevices", + "graphics", + "grid", + "lattice", + "methods", + "stats", + "utils" + ], + "Hash": "40a9887191d33b2521a1d741f8c8aea2" + }, + "stringfish": { + "Package": "stringfish", + "Version": "0.16.0", + "Source": "Repository", + "Repository": "RSPM", + "Requirements": [ + "R", + "Rcpp", + "RcppParallel" + ], + "Hash": "b7eb79470319ae71d4b5ed9cd7bf7294" + }, + "stringi": { + "Package": "stringi", + "Version": "1.8.3", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "stats", + "tools", + "utils" + ], + "Hash": "058aebddea264f4c99401515182e656a" + }, + "stringr": { + "Package": "stringr", + "Version": "1.5.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "glue", + "lifecycle", + "magrittr", + "rlang", + "stringi", + "vctrs" + ], + "Hash": "960e2ae9e09656611e0b8214ad543207" + }, + "sys": { + "Package": "sys", + "Version": "3.4.2", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "3a1be13d68d47a8cd0bfd74739ca1555" + }, + "systemfonts": { + "Package": "systemfonts", + "Version": "1.0.5", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cpp11" + ], + "Hash": "15b594369e70b975ba9f064295983499" + }, + "tarchetypes": { + "Package": "tarchetypes", + "Version": "0.7.10", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "digest", + "dplyr", + "fs", + "parallel", + "rlang", + "targets", + "tibble", + "tidyselect", + "utils", + "vctrs", + "withr" + ], + "Hash": "ddb09b32a3ac61f8e36cdc78a4df3c01" + }, + "targets": { + "Package": "targets", + "Version": "1.4.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "R6", + "base64url", + "callr", + "cli", + "codetools", + "data.table", + "digest", + "igraph", + "knitr", + "rlang", + "stats", + "tibble", + "tidyselect", + "tools", + "utils", + "vctrs", + "yaml" + ], + "Hash": "0be50803a2b160210f4f64792e6a29a5" + }, + "terra": { + "Package": "terra", + "Version": "1.7-65", + "Source": "Repository", + "Repository": "RSPM", + "Requirements": [ + "R", + "Rcpp", + "methods" + ], + "Hash": "8e245fd4eab07bf55ddb2e6ea353c0e1" + }, + "textshaping": { + "Package": "textshaping", + "Version": "0.3.7", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cpp11", + "systemfonts" + ], + "Hash": "997aac9ad649e0ef3b97f96cddd5622b" + }, + "tibble": { + "Package": "tibble", + "Version": "3.2.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "fansi", + "lifecycle", + "magrittr", + "methods", + "pillar", + "pkgconfig", + "rlang", + "utils", + "vctrs" + ], + "Hash": "a84e2cc86d07289b3b6f5069df7a004c" + }, + "tidyr": { + "Package": "tidyr", + "Version": "1.3.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "cpp11", + "dplyr", + "glue", + "lifecycle", + "magrittr", + "purrr", + "rlang", + "stringr", + "tibble", + "tidyselect", + "utils", + "vctrs" + ], + "Hash": "e47debdc7ce599b070c8e78e8ac0cfcf" + }, + "tidyselect": { + "Package": "tidyselect", + "Version": "1.2.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "glue", + "lifecycle", + "rlang", + "vctrs", + "withr" + ], + "Hash": "79540e5fcd9e0435af547d885f184fd5" + }, + "tidyverse": { + "Package": "tidyverse", + "Version": "2.0.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "broom", + "cli", + "conflicted", + "dbplyr", + "dplyr", + "dtplyr", + "forcats", + "ggplot2", + "googledrive", + "googlesheets4", + "haven", + "hms", + "httr", + "jsonlite", + "lubridate", + "magrittr", + "modelr", + "pillar", + "purrr", + "ragg", + "readr", + "readxl", + "reprex", + "rlang", + "rstudioapi", + "rvest", + "stringr", + "tibble", + "tidyr", + "xml2" + ], + "Hash": "c328568cd14ea89a83bd4ca7f54ae07e" + }, + "timechange": { + "Package": "timechange", + "Version": "0.2.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cpp11" + ], + "Hash": "8548b44f79a35ba1791308b61e6012d7" + }, + "tinytex": { + "Package": "tinytex", + "Version": "0.49", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "xfun" + ], + "Hash": "5ac22900ae0f386e54f1c307eca7d843" + }, + "tzdb": { + "Package": "tzdb", + "Version": "0.4.0", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cpp11" + ], + "Hash": "f561504ec2897f4d46f0c7657e488ae1" + }, + "units": { + "Package": "units", + "Version": "0.8-5", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "Rcpp" + ], + "Hash": "119d19da480e873f72241ff6962ffd83" + }, + "usethis": { + "Package": "usethis", + "Version": "2.2.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "clipr", + "crayon", + "curl", + "desc", + "fs", + "gert", + "gh", + "glue", + "jsonlite", + "lifecycle", + "purrr", + "rappdirs", + "rlang", + "rprojroot", + "rstudioapi", + "stats", + "utils", + "whisker", + "withr", + "yaml" + ], + "Hash": "60e51f0b94d0324dc19e44110098fa9f" + }, + "utf8": { + "Package": "utf8", + "Version": "1.2.4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "62b65c52671e6665f803ff02954446e9" + }, + "uuid": { + "Package": "uuid", + "Version": "1.1-1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "3d78edfb977a69fc7a0341bee25e163f" + }, + "vctrs": { + "Package": "vctrs", + "Version": "0.6.5", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "glue", + "lifecycle", + "rlang" + ], + "Hash": "c03fa420630029418f7e6da3667aac4a" + }, + "viridisLite": { + "Package": "viridisLite", + "Version": "0.4.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "c826c7c4241b6fc89ff55aaea3fa7491" + }, + "visNetwork": { + "Package": "visNetwork", + "Version": "2.1.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "grDevices", + "htmltools", + "htmlwidgets", + "jsonlite", + "magrittr", + "methods", + "stats", + "utils" + ], + "Hash": "3e48b097e8d9a91ecced2ed4817a678d" + }, + "vroom": { + "Package": "vroom", + "Version": "1.6.5", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "bit64", + "cli", + "cpp11", + "crayon", + "glue", + "hms", + "lifecycle", + "methods", + "progress", + "rlang", + "stats", + "tibble", + "tidyselect", + "tzdb", + "vctrs", + "withr" + ], + "Hash": "390f9315bc0025be03012054103d227c" + }, + "waiter": { + "Package": "waiter", + "Version": "0.2.5", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R6", + "htmltools", + "shiny" + ], + "Hash": "93e6b6c8ae3f81d4be77a0dc74e5cf5e" + }, + "whisker": { + "Package": "whisker", + "Version": "0.4.1", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "c6abfa47a46d281a7d5159d0a8891e88" + }, + "withr": { + "Package": "withr", + "Version": "2.5.2", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "grDevices", + "graphics", + "stats" + ], + "Hash": "4b25e70111b7d644322e9513f403a272" + }, + "wk": { + "Package": "wk", + "Version": "0.9.1", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R" + ], + "Hash": "5d4545e140e36476f35f20d0ca87963e" + }, + "xfun": { + "Package": "xfun", + "Version": "0.41", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "stats", + "tools" + ], + "Hash": "460a5e0fe46a80ef87424ad216028014" + }, + "xml2": { + "Package": "xml2", + "Version": "1.3.6", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "cli", + "methods", + "rlang" + ], + "Hash": "1d0336142f4cd25d8d23cd3ba7a8fb61" + }, + "xtable": { + "Package": "xtable", + "Version": "1.8-4", + "Source": "Repository", + "Repository": "CRAN", + "Requirements": [ + "R", + "stats", + "utils" + ], + "Hash": "b8acdf8af494d9ec19ccb2481a9b11c2" + }, + "yaml": { + "Package": "yaml", + "Version": "2.3.8", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "29240487a071f535f5e5d5a323b7afbd" + }, + "zip": { + "Package": "zip", + "Version": "2.3.0", + "Source": "Repository", + "Repository": "CRAN", + "Hash": "d98c94dacb7e0efcf83b0a133a705504" + } + } +} diff --git a/source/targets/mas_steekproef_weidestreek/renv/.gitignore b/source/targets/mas_steekproef_weidestreek/renv/.gitignore new file mode 100644 index 0000000..0ec0cbb --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/renv/.gitignore @@ -0,0 +1,7 @@ +library/ +local/ +cellar/ +lock/ +python/ +sandbox/ +staging/ diff --git a/source/targets/mas_steekproef_weidestreek/renv/activate.R b/source/targets/mas_steekproef_weidestreek/renv/activate.R new file mode 100644 index 0000000..cb5401f --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/renv/activate.R @@ -0,0 +1,1180 @@ + +local({ + + # the requested version of renv + version <- "1.0.3" + attr(version, "sha") <- NULL + + # the project directory + project <- getwd() + + # use start-up diagnostics if enabled + diagnostics <- Sys.getenv("RENV_STARTUP_DIAGNOSTICS", unset = "FALSE") + if (diagnostics) { + start <- Sys.time() + profile <- tempfile("renv-startup-", fileext = ".Rprof") + utils::Rprof(profile) + on.exit({ + utils::Rprof(NULL) + elapsed <- signif(difftime(Sys.time(), start, units = "auto"), digits = 2L) + writeLines(sprintf("- renv took %s to run the autoloader.", format(elapsed))) + writeLines(sprintf("- Profile: %s", profile)) + print(utils::summaryRprof(profile)) + }, add = TRUE) + } + + # figure out whether the autoloader is enabled + enabled <- local({ + + # first, check config option + override <- getOption("renv.config.autoloader.enabled") + if (!is.null(override)) + return(override) + + # next, check environment variables + # TODO: prefer using the configuration one in the future + envvars <- c( + "RENV_CONFIG_AUTOLOADER_ENABLED", + "RENV_AUTOLOADER_ENABLED", + "RENV_ACTIVATE_PROJECT" + ) + + for (envvar in envvars) { + envval <- Sys.getenv(envvar, unset = NA) + if (!is.na(envval)) + return(tolower(envval) %in% c("true", "t", "1")) + } + + # enable by default + TRUE + + }) + + if (!enabled) + return(FALSE) + + # avoid recursion + if (identical(getOption("renv.autoloader.running"), TRUE)) { + warning("ignoring recursive attempt to run renv autoloader") + return(invisible(TRUE)) + } + + # signal that we're loading renv during R startup + options(renv.autoloader.running = TRUE) + on.exit(options(renv.autoloader.running = NULL), add = TRUE) + + # signal that we've consented to use renv + options(renv.consent = TRUE) + + # load the 'utils' package eagerly -- this ensures that renv shims, which + # mask 'utils' packages, will come first on the search path + library(utils, lib.loc = .Library) + + # unload renv if it's already been loaded + if ("renv" %in% loadedNamespaces()) + unloadNamespace("renv") + + # load bootstrap tools + `%||%` <- function(x, y) { + if (is.null(x)) y else x + } + + catf <- function(fmt, ..., appendLF = TRUE) { + + quiet <- getOption("renv.bootstrap.quiet", default = FALSE) + if (quiet) + return(invisible()) + + msg <- sprintf(fmt, ...) + cat(msg, file = stdout(), sep = if (appendLF) "\n" else "") + + invisible(msg) + + } + + header <- function(label, + ..., + prefix = "#", + suffix = "-", + n = min(getOption("width"), 78)) + { + label <- sprintf(label, ...) + n <- max(n - nchar(label) - nchar(prefix) - 2L, 8L) + if (n <= 0) + return(paste(prefix, label)) + + tail <- paste(rep.int(suffix, n), collapse = "") + paste0(prefix, " ", label, " ", tail) + + } + + startswith <- function(string, prefix) { + substring(string, 1, nchar(prefix)) == prefix + } + + bootstrap <- function(version, library) { + + friendly <- renv_bootstrap_version_friendly(version) + section <- header(sprintf("Bootstrapping renv %s", friendly)) + catf(section) + + # attempt to download renv + catf("- Downloading renv ... ", appendLF = FALSE) + withCallingHandlers( + tarball <- renv_bootstrap_download(version), + error = function(err) { + catf("FAILED") + stop("failed to download:\n", conditionMessage(err)) + } + ) + catf("OK") + on.exit(unlink(tarball), add = TRUE) + + # now attempt to install + catf("- Installing renv ... ", appendLF = FALSE) + withCallingHandlers( + status <- renv_bootstrap_install(version, tarball, library), + error = function(err) { + catf("FAILED") + stop("failed to install:\n", conditionMessage(err)) + } + ) + catf("OK") + + # add empty line to break up bootstrapping from normal output + catf("") + + return(invisible()) + } + + renv_bootstrap_tests_running <- function() { + getOption("renv.tests.running", default = FALSE) + } + + renv_bootstrap_repos <- function() { + + # get CRAN repository + cran <- getOption("renv.repos.cran", "https://cloud.r-project.org") + + # check for repos override + repos <- Sys.getenv("RENV_CONFIG_REPOS_OVERRIDE", unset = NA) + if (!is.na(repos)) { + + # check for RSPM; if set, use a fallback repository for renv + rspm <- Sys.getenv("RSPM", unset = NA) + if (identical(rspm, repos)) + repos <- c(RSPM = rspm, CRAN = cran) + + return(repos) + + } + + # check for lockfile repositories + repos <- tryCatch(renv_bootstrap_repos_lockfile(), error = identity) + if (!inherits(repos, "error") && length(repos)) + return(repos) + + # retrieve current repos + repos <- getOption("repos") + + # ensure @CRAN@ entries are resolved + repos[repos == "@CRAN@"] <- cran + + # add in renv.bootstrap.repos if set + default <- c(FALLBACK = "https://cloud.r-project.org") + extra <- getOption("renv.bootstrap.repos", default = default) + repos <- c(repos, extra) + + # remove duplicates that might've snuck in + dupes <- duplicated(repos) | duplicated(names(repos)) + repos[!dupes] + + } + + renv_bootstrap_repos_lockfile <- function() { + + lockpath <- Sys.getenv("RENV_PATHS_LOCKFILE", unset = "renv.lock") + if (!file.exists(lockpath)) + return(NULL) + + lockfile <- tryCatch(renv_json_read(lockpath), error = identity) + if (inherits(lockfile, "error")) { + warning(lockfile) + return(NULL) + } + + repos <- lockfile$R$Repositories + if (length(repos) == 0) + return(NULL) + + keys <- vapply(repos, `[[`, "Name", FUN.VALUE = character(1)) + vals <- vapply(repos, `[[`, "URL", FUN.VALUE = character(1)) + names(vals) <- keys + + return(vals) + + } + + renv_bootstrap_download <- function(version) { + + sha <- attr(version, "sha", exact = TRUE) + + methods <- if (!is.null(sha)) { + + # attempting to bootstrap a development version of renv + c( + function() renv_bootstrap_download_tarball(sha), + function() renv_bootstrap_download_github(sha) + ) + + } else { + + # attempting to bootstrap a release version of renv + c( + function() renv_bootstrap_download_tarball(version), + function() renv_bootstrap_download_cran_latest(version), + function() renv_bootstrap_download_cran_archive(version) + ) + + } + + for (method in methods) { + path <- tryCatch(method(), error = identity) + if (is.character(path) && file.exists(path)) + return(path) + } + + stop("All download methods failed") + + } + + renv_bootstrap_download_impl <- function(url, destfile) { + + mode <- "wb" + + # https://bugs.r-project.org/bugzilla/show_bug.cgi?id=17715 + fixup <- + Sys.info()[["sysname"]] == "Windows" && + substring(url, 1L, 5L) == "file:" + + if (fixup) + mode <- "w+b" + + args <- list( + url = url, + destfile = destfile, + mode = mode, + quiet = TRUE + ) + + if ("headers" %in% names(formals(utils::download.file))) + args$headers <- renv_bootstrap_download_custom_headers(url) + + do.call(utils::download.file, args) + + } + + renv_bootstrap_download_custom_headers <- function(url) { + + headers <- getOption("renv.download.headers") + if (is.null(headers)) + return(character()) + + if (!is.function(headers)) + stopf("'renv.download.headers' is not a function") + + headers <- headers(url) + if (length(headers) == 0L) + return(character()) + + if (is.list(headers)) + headers <- unlist(headers, recursive = FALSE, use.names = TRUE) + + ok <- + is.character(headers) && + is.character(names(headers)) && + all(nzchar(names(headers))) + + if (!ok) + stop("invocation of 'renv.download.headers' did not return a named character vector") + + headers + + } + + renv_bootstrap_download_cran_latest <- function(version) { + + spec <- renv_bootstrap_download_cran_latest_find(version) + type <- spec$type + repos <- spec$repos + + baseurl <- utils::contrib.url(repos = repos, type = type) + ext <- if (identical(type, "source")) + ".tar.gz" + else if (Sys.info()[["sysname"]] == "Windows") + ".zip" + else + ".tgz" + name <- sprintf("renv_%s%s", version, ext) + url <- paste(baseurl, name, sep = "/") + + destfile <- file.path(tempdir(), name) + status <- tryCatch( + renv_bootstrap_download_impl(url, destfile), + condition = identity + ) + + if (inherits(status, "condition")) + return(FALSE) + + # report success and return + destfile + + } + + renv_bootstrap_download_cran_latest_find <- function(version) { + + # check whether binaries are supported on this system + binary <- + getOption("renv.bootstrap.binary", default = TRUE) && + !identical(.Platform$pkgType, "source") && + !identical(getOption("pkgType"), "source") && + Sys.info()[["sysname"]] %in% c("Darwin", "Windows") + + types <- c(if (binary) "binary", "source") + + # iterate over types + repositories + for (type in types) { + for (repos in renv_bootstrap_repos()) { + + # retrieve package database + db <- tryCatch( + as.data.frame( + utils::available.packages(type = type, repos = repos), + stringsAsFactors = FALSE + ), + error = identity + ) + + if (inherits(db, "error")) + next + + # check for compatible entry + entry <- db[db$Package %in% "renv" & db$Version %in% version, ] + if (nrow(entry) == 0) + next + + # found it; return spec to caller + spec <- list(entry = entry, type = type, repos = repos) + return(spec) + + } + } + + # if we got here, we failed to find renv + fmt <- "renv %s is not available from your declared package repositories" + stop(sprintf(fmt, version)) + + } + + renv_bootstrap_download_cran_archive <- function(version) { + + name <- sprintf("renv_%s.tar.gz", version) + repos <- renv_bootstrap_repos() + urls <- file.path(repos, "src/contrib/Archive/renv", name) + destfile <- file.path(tempdir(), name) + + for (url in urls) { + + status <- tryCatch( + renv_bootstrap_download_impl(url, destfile), + condition = identity + ) + + if (identical(status, 0L)) + return(destfile) + + } + + return(FALSE) + + } + + renv_bootstrap_download_tarball <- function(version) { + + # if the user has provided the path to a tarball via + # an environment variable, then use it + tarball <- Sys.getenv("RENV_BOOTSTRAP_TARBALL", unset = NA) + if (is.na(tarball)) + return() + + # allow directories + if (dir.exists(tarball)) { + name <- sprintf("renv_%s.tar.gz", version) + tarball <- file.path(tarball, name) + } + + # bail if it doesn't exist + if (!file.exists(tarball)) { + + # let the user know we weren't able to honour their request + fmt <- "- RENV_BOOTSTRAP_TARBALL is set (%s) but does not exist." + msg <- sprintf(fmt, tarball) + warning(msg) + + # bail + return() + + } + + catf("- Using local tarball '%s'.", tarball) + tarball + + } + + renv_bootstrap_download_github <- function(version) { + + enabled <- Sys.getenv("RENV_BOOTSTRAP_FROM_GITHUB", unset = "TRUE") + if (!identical(enabled, "TRUE")) + return(FALSE) + + # prepare download options + pat <- Sys.getenv("GITHUB_PAT") + if (nzchar(Sys.which("curl")) && nzchar(pat)) { + fmt <- "--location --fail --header \"Authorization: token %s\"" + extra <- sprintf(fmt, pat) + saved <- options("download.file.method", "download.file.extra") + options(download.file.method = "curl", download.file.extra = extra) + on.exit(do.call(base::options, saved), add = TRUE) + } else if (nzchar(Sys.which("wget")) && nzchar(pat)) { + fmt <- "--header=\"Authorization: token %s\"" + extra <- sprintf(fmt, pat) + saved <- options("download.file.method", "download.file.extra") + options(download.file.method = "wget", download.file.extra = extra) + on.exit(do.call(base::options, saved), add = TRUE) + } + + url <- file.path("https://api.github.com/repos/rstudio/renv/tarball", version) + name <- sprintf("renv_%s.tar.gz", version) + destfile <- file.path(tempdir(), name) + + status <- tryCatch( + renv_bootstrap_download_impl(url, destfile), + condition = identity + ) + + if (!identical(status, 0L)) + return(FALSE) + + renv_bootstrap_download_augment(destfile) + + return(destfile) + + } + + # Add Sha to DESCRIPTION. This is stop gap until #890, after which we + # can use renv::install() to fully capture metadata. + renv_bootstrap_download_augment <- function(destfile) { + sha <- renv_bootstrap_git_extract_sha1_tar(destfile) + if (is.null(sha)) { + return() + } + + # Untar + tempdir <- tempfile("renv-github-") + on.exit(unlink(tempdir, recursive = TRUE), add = TRUE) + untar(destfile, exdir = tempdir) + pkgdir <- dir(tempdir, full.names = TRUE)[[1]] + + # Modify description + desc_path <- file.path(pkgdir, "DESCRIPTION") + desc_lines <- readLines(desc_path) + remotes_fields <- c( + "RemoteType: github", + "RemoteHost: api.github.com", + "RemoteRepo: renv", + "RemoteUsername: rstudio", + "RemotePkgRef: rstudio/renv", + paste("RemoteRef: ", sha), + paste("RemoteSha: ", sha) + ) + writeLines(c(desc_lines[desc_lines != ""], remotes_fields), con = desc_path) + + # Re-tar + local({ + old <- setwd(tempdir) + on.exit(setwd(old), add = TRUE) + + tar(destfile, compression = "gzip") + }) + invisible() + } + + # Extract the commit hash from a git archive. Git archives include the SHA1 + # hash as the comment field of the tarball pax extended header + # (see https://www.kernel.org/pub/software/scm/git/docs/git-archive.html) + # For GitHub archives this should be the first header after the default one + # (512 byte) header. + renv_bootstrap_git_extract_sha1_tar <- function(bundle) { + + # open the bundle for reading + # We use gzcon for everything because (from ?gzcon) + # > Reading from a connection which does not supply a 'gzip' magic + # > header is equivalent to reading from the original connection + conn <- gzcon(file(bundle, open = "rb", raw = TRUE)) + on.exit(close(conn)) + + # The default pax header is 512 bytes long and the first pax extended header + # with the comment should be 51 bytes long + # `52 comment=` (11 chars) + 40 byte SHA1 hash + len <- 0x200 + 0x33 + res <- rawToChar(readBin(conn, "raw", n = len)[0x201:len]) + + if (grepl("^52 comment=", res)) { + sub("52 comment=", "", res) + } else { + NULL + } + } + + renv_bootstrap_install <- function(version, tarball, library) { + + # attempt to install it into project library + dir.create(library, showWarnings = FALSE, recursive = TRUE) + output <- renv_bootstrap_install_impl(library, tarball) + + # check for successful install + status <- attr(output, "status") + if (is.null(status) || identical(status, 0L)) + return(status) + + # an error occurred; report it + header <- "installation of renv failed" + lines <- paste(rep.int("=", nchar(header)), collapse = "") + text <- paste(c(header, lines, output), collapse = "\n") + stop(text) + + } + + renv_bootstrap_install_impl <- function(library, tarball) { + + # invoke using system2 so we can capture and report output + bin <- R.home("bin") + exe <- if (Sys.info()[["sysname"]] == "Windows") "R.exe" else "R" + R <- file.path(bin, exe) + + args <- c( + "--vanilla", "CMD", "INSTALL", "--no-multiarch", + "-l", shQuote(path.expand(library)), + shQuote(path.expand(tarball)) + ) + + system2(R, args, stdout = TRUE, stderr = TRUE) + + } + + renv_bootstrap_platform_prefix <- function() { + + # construct version prefix + version <- paste(R.version$major, R.version$minor, sep = ".") + prefix <- paste("R", numeric_version(version)[1, 1:2], sep = "-") + + # include SVN revision for development versions of R + # (to avoid sharing platform-specific artefacts with released versions of R) + devel <- + identical(R.version[["status"]], "Under development (unstable)") || + identical(R.version[["nickname"]], "Unsuffered Consequences") + + if (devel) + prefix <- paste(prefix, R.version[["svn rev"]], sep = "-r") + + # build list of path components + components <- c(prefix, R.version$platform) + + # include prefix if provided by user + prefix <- renv_bootstrap_platform_prefix_impl() + if (!is.na(prefix) && nzchar(prefix)) + components <- c(prefix, components) + + # build prefix + paste(components, collapse = "/") + + } + + renv_bootstrap_platform_prefix_impl <- function() { + + # if an explicit prefix has been supplied, use it + prefix <- Sys.getenv("RENV_PATHS_PREFIX", unset = NA) + if (!is.na(prefix)) + return(prefix) + + # if the user has requested an automatic prefix, generate it + auto <- Sys.getenv("RENV_PATHS_PREFIX_AUTO", unset = NA) + if (auto %in% c("TRUE", "True", "true", "1")) + return(renv_bootstrap_platform_prefix_auto()) + + # empty string on failure + "" + + } + + renv_bootstrap_platform_prefix_auto <- function() { + + prefix <- tryCatch(renv_bootstrap_platform_os(), error = identity) + if (inherits(prefix, "error") || prefix %in% "unknown") { + + msg <- paste( + "failed to infer current operating system", + "please file a bug report at https://github.com/rstudio/renv/issues", + sep = "; " + ) + + warning(msg) + + } + + prefix + + } + + renv_bootstrap_platform_os <- function() { + + sysinfo <- Sys.info() + sysname <- sysinfo[["sysname"]] + + # handle Windows + macOS up front + if (sysname == "Windows") + return("windows") + else if (sysname == "Darwin") + return("macos") + + # check for os-release files + for (file in c("/etc/os-release", "/usr/lib/os-release")) + if (file.exists(file)) + return(renv_bootstrap_platform_os_via_os_release(file, sysinfo)) + + # check for redhat-release files + if (file.exists("/etc/redhat-release")) + return(renv_bootstrap_platform_os_via_redhat_release()) + + "unknown" + + } + + renv_bootstrap_platform_os_via_os_release <- function(file, sysinfo) { + + # read /etc/os-release + release <- utils::read.table( + file = file, + sep = "=", + quote = c("\"", "'"), + col.names = c("Key", "Value"), + comment.char = "#", + stringsAsFactors = FALSE + ) + + vars <- as.list(release$Value) + names(vars) <- release$Key + + # get os name + os <- tolower(sysinfo[["sysname"]]) + + # read id + id <- "unknown" + for (field in c("ID", "ID_LIKE")) { + if (field %in% names(vars) && nzchar(vars[[field]])) { + id <- vars[[field]] + break + } + } + + # read version + version <- "unknown" + for (field in c("UBUNTU_CODENAME", "VERSION_CODENAME", "VERSION_ID", "BUILD_ID")) { + if (field %in% names(vars) && nzchar(vars[[field]])) { + version <- vars[[field]] + break + } + } + + # join together + paste(c(os, id, version), collapse = "-") + + } + + renv_bootstrap_platform_os_via_redhat_release <- function() { + + # read /etc/redhat-release + contents <- readLines("/etc/redhat-release", warn = FALSE) + + # infer id + id <- if (grepl("centos", contents, ignore.case = TRUE)) + "centos" + else if (grepl("redhat", contents, ignore.case = TRUE)) + "redhat" + else + "unknown" + + # try to find a version component (very hacky) + version <- "unknown" + + parts <- strsplit(contents, "[[:space:]]")[[1L]] + for (part in parts) { + + nv <- tryCatch(numeric_version(part), error = identity) + if (inherits(nv, "error")) + next + + version <- nv[1, 1] + break + + } + + paste(c("linux", id, version), collapse = "-") + + } + + renv_bootstrap_library_root_name <- function(project) { + + # use project name as-is if requested + asis <- Sys.getenv("RENV_PATHS_LIBRARY_ROOT_ASIS", unset = "FALSE") + if (asis) + return(basename(project)) + + # otherwise, disambiguate based on project's path + id <- substring(renv_bootstrap_hash_text(project), 1L, 8L) + paste(basename(project), id, sep = "-") + + } + + renv_bootstrap_library_root <- function(project) { + + prefix <- renv_bootstrap_profile_prefix() + + path <- Sys.getenv("RENV_PATHS_LIBRARY", unset = NA) + if (!is.na(path)) + return(paste(c(path, prefix), collapse = "/")) + + path <- renv_bootstrap_library_root_impl(project) + if (!is.null(path)) { + name <- renv_bootstrap_library_root_name(project) + return(paste(c(path, prefix, name), collapse = "/")) + } + + renv_bootstrap_paths_renv("library", project = project) + + } + + renv_bootstrap_library_root_impl <- function(project) { + + root <- Sys.getenv("RENV_PATHS_LIBRARY_ROOT", unset = NA) + if (!is.na(root)) + return(root) + + type <- renv_bootstrap_project_type(project) + if (identical(type, "package")) { + userdir <- renv_bootstrap_user_dir() + return(file.path(userdir, "library")) + } + + } + + renv_bootstrap_validate_version <- function(version, description = NULL) { + + # resolve description file + # + # avoid passing lib.loc to `packageDescription()` below, since R will + # use the loaded version of the package by default anyhow. note that + # this function should only be called after 'renv' is loaded + # https://github.com/rstudio/renv/issues/1625 + description <- description %||% packageDescription("renv") + + # check whether requested version 'version' matches loaded version of renv + sha <- attr(version, "sha", exact = TRUE) + valid <- if (!is.null(sha)) + renv_bootstrap_validate_version_dev(sha, description) + else + renv_bootstrap_validate_version_release(version, description) + + if (valid) + return(TRUE) + + # the loaded version of renv doesn't match the requested version; + # give the user instructions on how to proceed + remote <- if (!is.null(description[["RemoteSha"]])) { + paste("rstudio/renv", description[["RemoteSha"]], sep = "@") + } else { + paste("renv", description[["Version"]], sep = "@") + } + + # display both loaded version + sha if available + friendly <- renv_bootstrap_version_friendly( + version = description[["Version"]], + sha = description[["RemoteSha"]] + ) + + fmt <- paste( + "renv %1$s was loaded from project library, but this project is configured to use renv %2$s.", + "- Use `renv::record(\"%3$s\")` to record renv %1$s in the lockfile.", + "- Use `renv::restore(packages = \"renv\")` to install renv %2$s into the project library.", + sep = "\n" + ) + catf(fmt, friendly, renv_bootstrap_version_friendly(version), remote) + + FALSE + + } + + renv_bootstrap_validate_version_dev <- function(version, description) { + expected <- description[["RemoteSha"]] + is.character(expected) && startswith(expected, version) + } + + renv_bootstrap_validate_version_release <- function(version, description) { + expected <- description[["Version"]] + is.character(expected) && identical(expected, version) + } + + renv_bootstrap_hash_text <- function(text) { + + hashfile <- tempfile("renv-hash-") + on.exit(unlink(hashfile), add = TRUE) + + writeLines(text, con = hashfile) + tools::md5sum(hashfile) + + } + + renv_bootstrap_load <- function(project, libpath, version) { + + # try to load renv from the project library + if (!requireNamespace("renv", lib.loc = libpath, quietly = TRUE)) + return(FALSE) + + # warn if the version of renv loaded does not match + renv_bootstrap_validate_version(version) + + # execute renv load hooks, if any + hooks <- getHook("renv::autoload") + for (hook in hooks) + if (is.function(hook)) + tryCatch(hook(), error = warnify) + + # load the project + renv::load(project) + + TRUE + + } + + renv_bootstrap_profile_load <- function(project) { + + # if RENV_PROFILE is already set, just use that + profile <- Sys.getenv("RENV_PROFILE", unset = NA) + if (!is.na(profile) && nzchar(profile)) + return(profile) + + # check for a profile file (nothing to do if it doesn't exist) + path <- renv_bootstrap_paths_renv("profile", profile = FALSE, project = project) + if (!file.exists(path)) + return(NULL) + + # read the profile, and set it if it exists + contents <- readLines(path, warn = FALSE) + if (length(contents) == 0L) + return(NULL) + + # set RENV_PROFILE + profile <- contents[[1L]] + if (!profile %in% c("", "default")) + Sys.setenv(RENV_PROFILE = profile) + + profile + + } + + renv_bootstrap_profile_prefix <- function() { + profile <- renv_bootstrap_profile_get() + if (!is.null(profile)) + return(file.path("profiles", profile, "renv")) + } + + renv_bootstrap_profile_get <- function() { + profile <- Sys.getenv("RENV_PROFILE", unset = "") + renv_bootstrap_profile_normalize(profile) + } + + renv_bootstrap_profile_set <- function(profile) { + profile <- renv_bootstrap_profile_normalize(profile) + if (is.null(profile)) + Sys.unsetenv("RENV_PROFILE") + else + Sys.setenv(RENV_PROFILE = profile) + } + + renv_bootstrap_profile_normalize <- function(profile) { + + if (is.null(profile) || profile %in% c("", "default")) + return(NULL) + + profile + + } + + renv_bootstrap_path_absolute <- function(path) { + + substr(path, 1L, 1L) %in% c("~", "/", "\\") || ( + substr(path, 1L, 1L) %in% c(letters, LETTERS) && + substr(path, 2L, 3L) %in% c(":/", ":\\") + ) + + } + + renv_bootstrap_paths_renv <- function(..., profile = TRUE, project = NULL) { + renv <- Sys.getenv("RENV_PATHS_RENV", unset = "renv") + root <- if (renv_bootstrap_path_absolute(renv)) NULL else project + prefix <- if (profile) renv_bootstrap_profile_prefix() + components <- c(root, renv, prefix, ...) + paste(components, collapse = "/") + } + + renv_bootstrap_project_type <- function(path) { + + descpath <- file.path(path, "DESCRIPTION") + if (!file.exists(descpath)) + return("unknown") + + desc <- tryCatch( + read.dcf(descpath, all = TRUE), + error = identity + ) + + if (inherits(desc, "error")) + return("unknown") + + type <- desc$Type + if (!is.null(type)) + return(tolower(type)) + + package <- desc$Package + if (!is.null(package)) + return("package") + + "unknown" + + } + + renv_bootstrap_user_dir <- function() { + dir <- renv_bootstrap_user_dir_impl() + path.expand(chartr("\\", "/", dir)) + } + + renv_bootstrap_user_dir_impl <- function() { + + # use local override if set + override <- getOption("renv.userdir.override") + if (!is.null(override)) + return(override) + + # use R_user_dir if available + tools <- asNamespace("tools") + if (is.function(tools$R_user_dir)) + return(tools$R_user_dir("renv", "cache")) + + # try using our own backfill for older versions of R + envvars <- c("R_USER_CACHE_DIR", "XDG_CACHE_HOME") + for (envvar in envvars) { + root <- Sys.getenv(envvar, unset = NA) + if (!is.na(root)) + return(file.path(root, "R/renv")) + } + + # use platform-specific default fallbacks + if (Sys.info()[["sysname"]] == "Windows") + file.path(Sys.getenv("LOCALAPPDATA"), "R/cache/R/renv") + else if (Sys.info()[["sysname"]] == "Darwin") + "~/Library/Caches/org.R-project.R/R/renv" + else + "~/.cache/R/renv" + + } + + renv_bootstrap_version_friendly <- function(version, shafmt = NULL, sha = NULL) { + sha <- sha %||% attr(version, "sha", exact = TRUE) + parts <- c(version, sprintf(shafmt %||% " [sha: %s]", substring(sha, 1L, 7L))) + paste(parts, collapse = "") + } + + renv_bootstrap_exec <- function(project, libpath, version) { + if (!renv_bootstrap_load(project, libpath, version)) + renv_bootstrap_run(version, libpath) + } + + renv_bootstrap_run <- function(version, libpath) { + + # perform bootstrap + bootstrap(version, libpath) + + # exit early if we're just testing bootstrap + if (!is.na(Sys.getenv("RENV_BOOTSTRAP_INSTALL_ONLY", unset = NA))) + return(TRUE) + + # try again to load + if (requireNamespace("renv", lib.loc = libpath, quietly = TRUE)) { + return(renv::load(project = getwd())) + } + + # failed to download or load renv; warn the user + msg <- c( + "Failed to find an renv installation: the project will not be loaded.", + "Use `renv::activate()` to re-initialize the project." + ) + + warning(paste(msg, collapse = "\n"), call. = FALSE) + + } + + renv_json_read <- function(file = NULL, text = NULL) { + + jlerr <- NULL + + # if jsonlite is loaded, use that instead + if ("jsonlite" %in% loadedNamespaces()) { + + json <- catch(renv_json_read_jsonlite(file, text)) + if (!inherits(json, "error")) + return(json) + + jlerr <- json + + } + + # otherwise, fall back to the default JSON reader + json <- catch(renv_json_read_default(file, text)) + if (!inherits(json, "error")) + return(json) + + # report an error + if (!is.null(jlerr)) + stop(jlerr) + else + stop(json) + + } + + renv_json_read_jsonlite <- function(file = NULL, text = NULL) { + text <- paste(text %||% read(file), collapse = "\n") + jsonlite::fromJSON(txt = text, simplifyVector = FALSE) + } + + renv_json_read_default <- function(file = NULL, text = NULL) { + + # find strings in the JSON + text <- paste(text %||% read(file), collapse = "\n") + pattern <- '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]' + locs <- gregexpr(pattern, text, perl = TRUE)[[1]] + + # if any are found, replace them with placeholders + replaced <- text + strings <- character() + replacements <- character() + + if (!identical(c(locs), -1L)) { + + # get the string values + starts <- locs + ends <- locs + attr(locs, "match.length") - 1L + strings <- substring(text, starts, ends) + + # only keep those requiring escaping + strings <- grep("[[\\]{}:]", strings, perl = TRUE, value = TRUE) + + # compute replacements + replacements <- sprintf('"\032%i\032"', seq_along(strings)) + + # replace the strings + mapply(function(string, replacement) { + replaced <<- sub(string, replacement, replaced, fixed = TRUE) + }, strings, replacements) + + } + + # transform the JSON into something the R parser understands + transformed <- replaced + transformed <- gsub("{}", "`names<-`(list(), character())", transformed, fixed = TRUE) + transformed <- gsub("[[{]", "list(", transformed, perl = TRUE) + transformed <- gsub("[]}]", ")", transformed, perl = TRUE) + transformed <- gsub(":", "=", transformed, fixed = TRUE) + text <- paste(transformed, collapse = "\n") + + # parse it + json <- parse(text = text, keep.source = FALSE, srcfile = NULL)[[1L]] + + # construct map between source strings, replaced strings + map <- as.character(parse(text = strings)) + names(map) <- as.character(parse(text = replacements)) + + # convert to list + map <- as.list(map) + + # remap strings in object + remapped <- renv_json_remap(json, map) + + # evaluate + eval(remapped, envir = baseenv()) + + } + + renv_json_remap <- function(json, map) { + + # fix names + if (!is.null(names(json))) { + lhs <- match(names(json), names(map), nomatch = 0L) + rhs <- match(names(map), names(json), nomatch = 0L) + names(json)[rhs] <- map[lhs] + } + + # fix values + if (is.character(json)) + return(map[[json]] %||% json) + + # handle true, false, null + if (is.name(json)) { + text <- as.character(json) + if (text == "true") + return(TRUE) + else if (text == "false") + return(FALSE) + else if (text == "null") + return(NULL) + } + + # recurse + if (is.recursive(json)) { + for (i in seq_along(json)) { + json[i] <- list(renv_json_remap(json[[i]], map)) + } + } + + json + + } + + # load the renv profile, if any + renv_bootstrap_profile_load(project) + + # construct path to library root + root <- renv_bootstrap_library_root(project) + + # construct library prefix for platform + prefix <- renv_bootstrap_platform_prefix() + + # construct full libpath + libpath <- file.path(root, prefix) + + # run bootstrap code + renv_bootstrap_exec(project, libpath, version) + + invisible() + +}) diff --git a/source/targets/mas_steekproef_weidestreek/renv/settings.json b/source/targets/mas_steekproef_weidestreek/renv/settings.json new file mode 100644 index 0000000..ffdbb32 --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/renv/settings.json @@ -0,0 +1,19 @@ +{ + "bioconductor.version": null, + "external.libraries": [], + "ignored.packages": [], + "package.dependency.fields": [ + "Imports", + "Depends", + "LinkingTo" + ], + "ppm.enabled": null, + "ppm.ignored.urls": [], + "r.version": null, + "snapshot.type": "implicit", + "use.cache": true, + "vcs.ignore.cellar": true, + "vcs.ignore.library": true, + "vcs.ignore.local": true, + "vcs.manage.ignores": true +} diff --git a/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd b/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd new file mode 100644 index 0000000..94010cd --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd @@ -0,0 +1,505 @@ +--- +title: "MAS steekproeftrekking voor de Weidestreek" +author: "Ward Langeraert, Emma Cartuyvels, Hans Van Calster" +date: "`r Sys.Date()`" +output: + bookdown::html_document2: + code_folding: hide + toc: true + toc_float: true + toc_collapsed: true +editor_options: + chunk_output_type: console +--- + +```{r setup, include = FALSE} +knitr::opts_chunk$set( + collapse = TRUE, + comment = "#>", + echo = TRUE, + warning = FALSE, + message = FALSE) +target_dir <- rprojroot::find_root_file( + "source", "targets", "mas_steekproef_za_kp_po", + criterion = rprojroot::is_git_root) +knitr::opts_knit$set( + root.dir = target_dir) +``` + +# Inleiding + +Dit document beschrijft de analyse workflow voor het opstellen van het steekproefkader en de steekproeftrekking voor de Weidestreek in kader van het MAS project. +De Weidestreek is een kleiner gebied en heeft dus licht andere instellingen in de code in vergelijking met de andere landbouwstreken. + +We maken voor het steekproefontwerp gebruik van het `targets` package in combinatie met `RMarkdown`. + + +# Packages + +TO DO + +Installeren van de vereiste R packages. +Extra reproduceerbaarheid van het analysestramien wordt verzekerd door het `renv` package. +Voor compatibiliteit tussen `renv` en `targets`, zie `?targets::tar_renv`. +Het bijhorende R-project heeft een `.Rprofile` bestand waarmee bij opstart van het project hetzelfde `renv` project geladen wordt als van het hoofd `mbag` R-project. +Het `renv` package zorgt ervoor dat de analyses gebeuren in een geïsoleerd R-project met gespecificeerde versies van alle benodigde R packages (zowel de packages die expliciet geladen worden als de packages waarvan deze afhankelijk zijn). + +De onderstaande chunk wordt best in interactieve modus uitgevoerd. + +```{r renv-restore, eval = FALSE} +options(pkgType = "source") +renv::restore() +``` + + +# Setup + +In onderstaande chunk laden we R packages die we nodig hebben in interactieve modus. +Verderop beschrijven we elk van de rekenstappen in Target Markdown chunks. +Deze target-chunks worden weggeschreven naar een `_targets.R` bestand en de hulpscripts worden opgeslagen in een bestandsmap `_targets_r/`. +De functie `tar_unscript()` in de chunk hieronder verwijdert alle hulpscripts uit de `_targets_r` bestandsmap. +Dit is om te voorkomen dat er per ongeluk code naar deze map werd weggeschreven wanneer de target chunks in interactieve modus worden uitgevoerd. + +```{r} +library(targets) +library(tarchetypes) +library(tidyverse) +library(tibble) +library(sf) +tar_unscript(script = file.path(target_dir, "_targets.R")) +``` + + + + +```{r eval = interactive() && osmextract::oe_download_directory() != "C:\\R\\osmdata"} +usethis::edit_r_environ() +``` + + +# Globale instellingen + +Eerst definiëren we globale opties en functies die voor alle targets gelden. + +We gebruiken standaard "qs" als opslagformaat omdat dit zowel voor data.frames als voor andere R objecten toepasbaar is, resulteert in kleinere bestanden en sneller kan gelezen en weggeschreven worden in vergelijking met "rds" bestanden. + + +```{targets mas-globals, tar_globals = TRUE} +options(tidyverse.quiet = TRUE) +tar_option_set(packages = c("dplyr", + "readr", + "tidyr", + "tibble", + "nngeo", + "osmextract", + "terra", + "exactextractr", + "arrow", + "httr", + "sf", + "GVI"), + format = "qs", + memory = "transient", + garbage_collection = TRUE, + workspace_on_error = TRUE) + +target_dir <- rprojroot::find_root_file( + "source", "targets", "mas_steekproef_zl_lm_za_kp_po", + criterion = rprojroot::is_git_root) +mbag_dir <- rprojroot::find_root_file( + criterion = rprojroot::is_git_root) + +source(file.path(mbag_dir, "source", "R", "landuse_maps.R")) +source(file.path(mbag_dir, "source", "R", "geocomputations.R")) +source(file.path(mbag_dir, "source", "R", "draw_sample.R")) +source(file.path(mbag_dir, "source", "R", "steekproefkader.R")) +source(file.path(mbag_dir, "source", "R", "berekening_hulpvariabelen.R")) +source(file.path(mbag_dir, "source", "R", "steekproeftrekking_nabehandeling.R")) +source(file.path(mbag_dir, "source", "R", "wfs_wcs.R")) +``` + + +# Targets + +In dit hoofdstuk worden alle targets gedefinieerd, maar er worden nog geen berekeningen uitgevoerd. + +We beginnen met het inlezen van bestanden. +Alle targets voor bestanden zijn op zo'n manier opgebouwd dat ze detecteren wanneer de inhoud van het bestand wijzigt. +Als de inhoud wijzigt, zal de target vervallen en bij uitvoering van het analysestramien opnieuw uitgevoerd worden. +Dit geldt dan eveneens voor alle stroomafwaartse targets die ervan afhankelijk zijn. + +```{targets raw-data} +list( + tarchetypes::tar_file( + perimeters_file, + path_to_perimeters("za_kp_po_perimeters.gpkg") + ), + tar_target( + perimeters_data, + st_read(perimeters_file) %>% + arrange(Naam) + ), + tarchetypes::tar_file( + osm_belgium, + path_to_osm_download() + ), + tarchetypes::tar_file( + vito_lum_2019_file, + path_to_lum(jaar = 2019) + ), + tarchetypes::tar_file( + legend_lum_file, + path_to_legend_lum() + ), + tar_target( + legend_lum, + read_legend_lum(file = legend_lum_file) + ), + tarchetypes::tar_file( + openheid_landschap_file, + path_to_openheid_landschap() + ), + tarchetypes::tar_file( + bo_file, + path_to_bo(jaar = 2022) + ), + tarchetypes::tar_file( + sbp_akkervogels_file, + path_to_sbp_akkervogels(file = "akkervogelgebieden2022.shp") + ), + tarchetypes::tar_file( + sbp_overige_file, + path_to_sbp_akkervogels(file = "sbp_overige_soorten.shp") + ), + tarchetypes::tar_file( + existing_file, + path_to_existing(file = "avimap_601_0_MAS_Vlaanderen_telpunten_xy.shp") + ), + tar_target( + existing_data, + st_read(existing_file) +) + ) +``` + +```{targets steekproefkader} +list( + tar_target( + name = selectie_openheid_klasses, + command = selectie_openheid( + gebied = perimeters_data, + ol_strata = c("OL", "HOL") + ), + pattern = map(perimeters_data), + iteration = "list" + ), + tar_target( + name = exclusie_osm_landgebruiken, + command = exclusie_landgebruik_osm( + gebied = selectie_openheid_klasses, + osmdata = osm_belgium, + landuse = c("residential", "military", "industrial", "cemetery", + "railway", "commercial", "farmyard"), + leisure = c("park"), + buffer_poly = 0, + layer_poly = list(aeroway = c("aerodrome")), + buffer_line = 100, + layer_line = list(highway = c("motorway", "motorway_link")), + update_osm_layer = FALSE + ), + pattern = map(selectie_openheid_klasses), + iteration = "list" + ), + tar_target( + name = paden, + command = extract_osm_paden( + gebied = selectie_openheid_klasses, + exclusie = exclusie_osm_landgebruiken, + osmdata = osm_belgium, + paths_include = c("track", "tertiary", "tertiary_link", "unclassified"), + cutting_exclude = NULL, + historic_exclude = NULL, + waterway = NULL, + update_osm_layer = FALSE + ), + pattern = map(selectie_openheid_klasses, exclusie_osm_landgebruiken), + iteration = "list" + ), + tar_target( + name = punten, + command = paden_naar_punten( + data_paden = paden, + gebieden = perimeters_data, + interpoint_distance = 50, + border_distance = 300 + ), + pattern = map(perimeters_data, paden), + iteration = "list" + ) , + tar_target( + name = telcirkels_landgebruik, + command = punten_lum_buffer( + punten_sf = punten, + radius = 300, + file = vito_lum_2019_file, + legend = legend_lum + ), + pattern = map(punten), + iteration = "list" + ), + tar_target( + name = telcirkels_selectie_landgebruik, + command = punten_selectie_landgebruik( + lum_extract_result = telcirkels_landgebruik, + legend_rast = legend_lum, + max_prop_overige = 0.5, + min_prop_akker = 0.3, + min_prop_akker_grasland = 0.4 + ), + pattern = map(telcirkels_landgebruik) + ), + tar_target( + name = selectie_landgebruik, + command = selectie_landgebruik_vito( + punten_sf = punten, + selectie_df = telcirkels_selectie_landgebruik + ), + pattern = map(punten, telcirkels_selectie_landgebruik), + iteration = "list" + ), + tarchetypes::tar_group_size( + name = selectie_landgebruik_per_size, + command = do.call(rbind.data.frame, selectie_landgebruik), + size = 200 + ), + tar_target( + name = punten_zichtbaarheid, + command = add_visibility_to_frame( + punten_sf = selectie_landgebruik_per_size, + resolution = 5, + spacing = 10 + ), + pattern = map(selectie_landgebruik_per_size), + iteration = "list" + ), + tarchetypes::tar_group_by( + name = punten_zichtbaarheid_per_regio, + command = do.call(rbind.data.frame, punten_zichtbaarheid), + Naam + ), + tar_target( + name = punten_selectie_zichtbaarheid, + command = filter_zichtbaarheid( + punten_sf = punten_zichtbaarheid_per_regio, + min_cvvi = 0.1 + ), + pattern = map(punten_zichtbaarheid_per_regio), + iteration = "list" + ) +) +``` + +```{targets hulpvariabelen} +list( + tar_target( + name = plus_sb, + command = add_bo_to_frame( + punten_df = punten_selectie_zichtbaarheid, + path_bo = bo_file + ), + pattern = map(punten_selectie_zichtbaarheid), + iteration = "list" + ), + tar_target( + name = plus_openheid_landschap, + command = add_openheid_landschap_to_frame( + path = openheid_landschap_file, + punten_sf = plus_sb, + gebied = perimeters_data, + cutlevels = c(1.25, 1.35, 1.51), + class_labels = c("GL", "HGL", "HOL", "OL") + ), + pattern = map(perimeters_data, plus_sb), + iteration = "list" + ), + tar_target( + name = sbp_akkervogels, + command = read_sbp_akkervogels( + path = sbp_akkervogels_file, + gebied = perimeters_data, + path_extra_soorten = sbp_overige_file, + extra_soorten = c("hamster", "bruine kiekendief", "zomertortel", + "grauwe kiekendief") + ), + pattern = map(perimeters_data), + iteration = "list" + ), + tar_target( + name = steekproefkader_finaal, + command = add_stratum_sbp( + punten_sf = plus_openheid_landschap, + sbp = do.call(rbind.data.frame, sbp_akkervogels) + ), + pattern = map(plus_openheid_landschap), + iteration = "list" + ) +) +``` + +```{targets steekproeftrekking} +list( + tar_target( + name = target_size, + command = calc_target_samplesize(gebied = selectie_openheid_klasses), + pattern = map(selectie_openheid_klasses) + ), + tar_target( + allocatie_df, + allocatie( + steekproefkader = steekproefkader_finaal, + min_samplesize = 200, + target_samplesize = target_size, + popsize_minimum = 200, + allocatie_binnen_sbp = 0.5, + allocatie_leemstreek = 0, + ol_strata = c("OL", "HOL") + ), + pattern = map(steekproefkader_finaal, target_size) + ), + tarchetypes::tar_group_by( + allocatie_per_stratum, + allocatie_df, + Naam, + is_sbp, + openheid_klasse + ), + tarchetypes::tar_group_by( + steekproefkader_per_stratum, + do.call(rbind.data.frame, steekproefkader_finaal) %>% + semi_join(allocatie_df %>% + select(Naam, is_sbp, openheid_klasse), + by = c("Naam", "is_sbp", "openheid_klasse")), + Naam, + is_sbp, + openheid_klasse + ), + tar_target( + steekproef, + draw_sample( + sampling_frame = steekproefkader_per_stratum, + sample_size_multiplication = 1, + balance = c("X", "Y", "area_prop_sb") + ), + pattern = map(steekproefkader_per_stratum, allocatie_per_stratum), + iteration = "list" + ) +) +``` + +```{targets nabehandeling} +list( + tar_target( + steekproef_thinned, + thin_sample( + sample = steekproef, + thin_dist = 600 + ), + pattern = map(steekproef), + iteration = "list" + ), + tar_target( + steekproef_final, + replace_by_existing( + sample = steekproef_thinned, + existing_points = existing_data, + id_existing_points = as.name("naam"), + gebied = perimeters_data, + overlap_prop = 0.5, + sbp_file = do.call(rbind.data.frame, sbp_akkervogels) + ), + pattern = map(steekproef_thinned), + iteration = "list" + ) +) +``` + +```{targets version-control} +list( + tar_target( + output_objecten, + output_finaal( + files = list(steekproefkader = do.call(rbind.data.frame, + steekproefkader_finaal), + steekproef = do.call(rbind.data.frame, + steekproef_final)), + write_out = TRUE + ) + ) +) +``` + +# Analysestramien uitvoeren + +Nadat alle `{targets}` chunks in niet-interactieve modus zijn uitgevoerd, kan je de pijplijn laten lopen m.b.v. tar_make(). + +```{r} +tar_make() +``` + +Om de status van de berekening van targets via `tar_make()` op te volgen kan je `tar_progress()`, `tar_progress_summary()` of `tar_poll()` gebruiken. + + +# Debug + +```{r eval=FALSE} +#debug mode +tar_load_globals() +tar_make(callr_function = NULL) +``` + +```{r eval=FALSE} +failed <- tar_meta(fields = error) %>% + na.omit() %>% + pull(name) + +failed + +tar_load_globals() +tar_workspace("steekproef_98295cec") +tar_traceback(failed, characters = 80) +``` + + +# Output + +Alle resultaten worden opgeslagen in `_targets/objects` en de lijst van bestanden kan je bekijken met `tar_objects()`. + +```{r} +tar_objects() +``` + +Ze kunnen individueel ingelezen worden met `tar_read()` of ingeladen worden met `tar_load()`. + +```{r} +``` + +Handig is dat targets afkomstig van dynamic branching ook automatisch geaggregeerd worden. + +In de bestandsmap `_targets/meta` zitten alle metadata, die met `tar_meta()` bekeken kunnen worden. + +```{r} +tar_meta() +tar_errored() #om te zien of welke targets een foutmelding hebben +tar_meta(fields = warnings) %>% + filter(!is.na(warnings)) +``` + +De `targets` grafiek met onderlinge afhankelijkheden van de targets: + +```{r} +tar_visnetwork(targets_only = TRUE) +``` From b61e378a18eed286cf97f30f82dce4120b1a79cd Mon Sep 17 00:00:00 2001 From: wlangera Date: Tue, 12 Mar 2024 15:01:17 +0100 Subject: [PATCH 11/19] adjust code for weidestreek --- .../targets_steekproef_weidestreek.Rmd | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd b/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd index 94010cd..40858bc 100644 --- a/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd +++ b/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd @@ -136,7 +136,7 @@ Dit geldt dan eveneens voor alle stroomafwaartse targets die ervan afhankelijk z list( tarchetypes::tar_file( perimeters_file, - path_to_perimeters("za_kp_po_perimeters.gpkg") + path_to_perimeters("weidestreek_perimeters.gpkg") ), tar_target( perimeters_data, @@ -186,6 +186,8 @@ list( ) ``` +Er zijn in de Weidestreek geen snelwegen noch een vliegveldaanwezig, dus dit wordt niet in de functie gespecifieerd (anders krijgen we een error). De code verschilt dus licht van de code in de andere targets pipeline, maar zal hetzelfde resultaat geven. + ```{targets steekproefkader} list( tar_target( @@ -205,10 +207,6 @@ list( landuse = c("residential", "military", "industrial", "cemetery", "railway", "commercial", "farmyard"), leisure = c("park"), - buffer_poly = 0, - layer_poly = list(aeroway = c("aerodrome")), - buffer_line = 100, - layer_line = list(highway = c("motorway", "motorway_link")), update_osm_layer = FALSE ), pattern = map(selectie_openheid_klasses), From fbeb5b47e791af74e3f14747d944263d7204b7c6 Mon Sep 17 00:00:00 2001 From: wlangera Date: Tue, 12 Mar 2024 15:14:47 +0100 Subject: [PATCH 12/19] allocation code --- .../targets_steekproef_weidestreek.Rmd | 31 ++++++++++++------- 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd b/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd index 40858bc..bf738a4 100644 --- a/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd +++ b/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd @@ -348,25 +348,29 @@ list( ) ``` +Om toch een voldoende grote steekproef te krijgen per landbouwstreek, kunnen we opteren om een allocatie te doen evenredig aan de oppervlakte van elk stratum. Het zal dan niet mogelijk zijn uitspraken te doen over elk stratum apart, maar wel over elke landbouwstreek als geheel en bijgevolg een aanvulling met de andere (grote) landbouwstreken om een uitspraak over Vlaanderen te kunnen doen. + +Er is geen gebalanceerde steekproef m.b.t. proportie soortbeschermingsmaatregelen omdat er geen overlap was in deze landbouwstreek. De code verschilt dus licht van de code in de andere targets pipeline, maar zal hetzelfde resultaat geven. + ```{targets steekproeftrekking} list( - tar_target( - name = target_size, - command = calc_target_samplesize(gebied = selectie_openheid_klasses), - pattern = map(selectie_openheid_klasses) - ), tar_target( allocatie_df, allocatie( steekproefkader = steekproefkader_finaal, - min_samplesize = 200, - target_samplesize = target_size, - popsize_minimum = 200, - allocatie_binnen_sbp = 0.5, + min_samplesize = 0, + target_samplesize = 91, + popsize_minimum = 0, + allocatie_binnen_sbp = steekproefkader_finaal %>% + st_drop_geometry() %>% + count(is_sbp) %>% + mutate(prop = n / sum(n)) %>% + filter(is_sbp) %>% + pull(prop), allocatie_leemstreek = 0, ol_strata = c("OL", "HOL") ), - pattern = map(steekproefkader_finaal, target_size) + pattern = map(steekproefkader_finaal) ), tarchetypes::tar_group_by( allocatie_per_stratum, @@ -389,8 +393,9 @@ list( steekproef, draw_sample( sampling_frame = steekproefkader_per_stratum, + sample_size = 91, sample_size_multiplication = 1, - balance = c("X", "Y", "area_prop_sb") + balance = c("X", "Y") ), pattern = map(steekproefkader_per_stratum, allocatie_per_stratum), iteration = "list" @@ -398,13 +403,15 @@ list( ) ``` +We verlagen de thinning distance naar 400. + ```{targets nabehandeling} list( tar_target( steekproef_thinned, thin_sample( sample = steekproef, - thin_dist = 600 + thin_dist = 400 ), pattern = map(steekproef), iteration = "list" From c35e1cf9dda735eb318ed9097a5926d3cd7a089e Mon Sep 17 00:00:00 2001 From: wlangera Date: Tue, 12 Mar 2024 15:14:55 +0100 Subject: [PATCH 13/19] spelling --- source/markdown/exploratie_duinen_weidestreek.Rmd | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/source/markdown/exploratie_duinen_weidestreek.Rmd b/source/markdown/exploratie_duinen_weidestreek.Rmd index c25bd5b..513db6b 100644 --- a/source/markdown/exploratie_duinen_weidestreek.Rmd +++ b/source/markdown/exploratie_duinen_weidestreek.Rmd @@ -171,9 +171,9 @@ openheid_sf$Weidestreek %>% We sluiten bepaalde landgebruiken uit op basis van OpenStreetMap (OSM). OSM kaart gedownload op 27/02/2024. -> Er zijn in beide gebieden geen snelwegen aanwezig dus dit wordt niet in de functie gespecifieerd (anders krijgen we een error). De code verschilt dus ligt van de code in de targets pipeline, maar zal hetzelfde resultaat geven. +> Er zijn in beide gebieden geen snelwegen aanwezig dus dit wordt niet in de functie gespecifieerd (anders krijgen we een error). De code verschilt dus licht van de code in de targets pipeline, maar zal hetzelfde resultaat geven. -> Er is in de Weidestreek geen vliegveld aanwezig dus dit wordt niet in de functie gespecifieerd (anders krijgen we een error). De code verschilt dus ligt van de code in de targets pipeline, maar zal hetzelfde resultaat geven. +> Er is in de Weidestreek geen vliegveld aanwezig dus dit wordt niet in de functie gespecifieerd (anders krijgen we een error). De code verschilt dus licht van de code in de targets pipeline, maar zal hetzelfde resultaat geven. ```{r, cache=TRUE, results="hide"} exclusie_osm_duinen <- exclusie_landgebruik_osm( @@ -985,7 +985,7 @@ Het zal dan niet mogelijk zijn uitspraken te doen over elk stratum apart, maar w We nemen een ruimtelijk gebalanceerde steekproef van 50 punten en 50 reservepunten per landbouwstreek. -> Er is geen gebalanceerde steekproef m.b.t. proportie soortbeschermingsmaatregelen omdat er geen overlap was in deze landbouwstreken. De code verschilt dus ligt van de code in de targets pipeline, maar zal hetzelfde resultaat geven. +> Er is geen gebalanceerde steekproef m.b.t. proportie soortbeschermingsmaatregelen omdat er geen overlap was in deze landbouwstreken. De code verschilt dus licht van de code in de targets pipeline, maar zal hetzelfde resultaat geven. ```{r} # Bereken allocatiefactor binnen SBP From a33a36f9b4aaca3af155c31b07ddcd478515bd24 Mon Sep 17 00:00:00 2001 From: wlangera Date: Wed, 13 Mar 2024 10:00:18 +0100 Subject: [PATCH 14/19] hide print results for loop --- source/markdown/exploratie_duinen_weidestreek.Rmd | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/markdown/exploratie_duinen_weidestreek.Rmd b/source/markdown/exploratie_duinen_weidestreek.Rmd index 513db6b..5a1afd2 100644 --- a/source/markdown/exploratie_duinen_weidestreek.Rmd +++ b/source/markdown/exploratie_duinen_weidestreek.Rmd @@ -1420,7 +1420,7 @@ Wat als we spelen met de thinning? thinning <- seq(400, 550, by = 50) ``` -```{r} +```{r, results='hide'} out_list_thinning <- vector(mode = "list", length = length(sizes) * length(thinning)) From b36915fef85692ea97216fc169b8342b7105f8f1 Mon Sep 17 00:00:00 2001 From: wlangera Date: Wed, 13 Mar 2024 10:23:03 +0100 Subject: [PATCH 15/19] finalise comparison sample sizes weidestreek --- .../exploratie_duinen_weidestreek.Rmd | 108 +++++++++++++++++- 1 file changed, 107 insertions(+), 1 deletion(-) diff --git a/source/markdown/exploratie_duinen_weidestreek.Rmd b/source/markdown/exploratie_duinen_weidestreek.Rmd index 5a1afd2..d9fdf7d 100644 --- a/source/markdown/exploratie_duinen_weidestreek.Rmd +++ b/source/markdown/exploratie_duinen_weidestreek.Rmd @@ -1353,7 +1353,7 @@ calc_chisq <- function(observed, expected) { } ``` -```{r} +```{r, cache=TRUE} out_list <- vector(mode = "list", length = length(sizes)) for (i in seq_along(sizes)) { @@ -1489,3 +1489,109 @@ ggplot(chi_squared_df_thinning, aes(x = steekproef_grootte, y = chisq)) + y = "Chi-kwadraattoetsingsgrootheid", fill = "Finale\nsteekproef-\ngrootte") ``` + +We bekijken de steekproefgroottes met Chi-kwadraattoetsingsgrootheid kleiner dan 1 en finale steekproefgrootte minstens 50: + +```{r} +chi_squared_df_thinning %>% + filter(chisq < 1, + finale_grootte >= 50) %>% + arrange(desc(finale_grootte)) %>% + kable() +``` + +We besluiten een steekproeftrekking van 91 punten te nemen om 58 punten over te houden bij een thinning van 400 m. + +```{r} +allocatie_extended <- allocatie( + steekproefkader = steekproefkader_finaal$Weidestreek, + min_samplesize = 0, + target_samplesize = 91, + popsize_minimum = 0, + allocatie_binnen_sbp = allocatie_binnen_sbp$Weidestreek, + allocatie_leemstreek = 0, + ol_strata = c("OL", "HOL") + ) + +steekproef_extended <- draw_sample( + sampling_frame = steekproefkader_per_stratum$Weidestreek, + sample_size = 91, + sample_size_multiplication = 1, + balance = c("X", "Y") + ) + +steekproef_extended_thinned <- thin_sample( + sample = steekproef_extended, + thin_dist = 400 + ) +``` + +Er is inderdaad een goede overeenkomst tussen de proporties in de steekproef (`prop_steekproef`) en de originele allocatie (`allocatie`). + +```{r} +steekproef_extended_thinned %>% + st_drop_geometry() %>% + filter(batch == "eerste set") %>% + count(openheid_klasse, is_sbp) %>% + mutate(prop = n / sum(n)) %>% + full_join(allocatie_extended) %>% + select(Naam, openheid_klasse, is_sbp, allocatie, samplesize, + prop_steekproef = prop, n_steekproef = n) %>% + kable() +``` + +```{r} +balansvergelijking_weidestreek2 <- steekproef_extended_thinned %>% + select_at(names(steekproefkader_finaal$Weidestreek)) %>% + mutate(fill_var = "steekproef") %>% + bind_rows(steekproefkader_finaal$Weidestreek %>% mutate(fill_var = "steekproefkader")) %>% + mutate(sbp_akkervogels = ifelse(is_sbp, "binnen SBP", "buiten SBP")) %>% + cbind(st_coordinates(.)) %>% + st_drop_geometry() %>% + mutate(fill_var = factor(fill_var, levels = c("steekproefkader", "steekproef"))) + +count_df_weidestreek2 <- balansvergelijking_weidestreek2 %>% + group_by(fill_var, openheid_klasse, sbp_akkervogels) %>% + summarise(max_openheid = max(openheid_waarde), + max_x = max(X), + max_y = max(Y), + n = n(), + .groups = "drop") +``` + +We zien vooral dat de steekproef relatief goed overeenkomt met het steekproefkader op vlak van openheid. + +```{r} +balansvergelijking_weidestreek2 %>% + ggplot(aes(x = sbp_akkervogels, y = openheid_waarde)) + + geom_boxplot(aes(fill = fill_var)) + + geom_label(data = count_df_weidestreek2, + aes(y = max_openheid + 0.01, label = paste("n =", n)), + size = 3, position = position_dodge2(width = 0.75)) + + facet_grid(~ openheid_klasse) + + labs(fill = "Legende") +``` + +Als we naar longitude en latitude kijken, lijkt dit wel min of meer ok. Opnieuw is er voor OL buiten SBP niet zo'n goede match, maar dit is ook maar 1 punt dus het is onmogelijk een goede vergelijking te maken. + +```{r} +balansvergelijking_weidestreek2 %>% + ggplot(aes(x = sbp_akkervogels, y = X)) + + geom_boxplot(aes(fill = fill_var)) + + geom_label(data = count_df_weidestreek2, + aes(y = max_x + 2000, label = paste("n =", n)), + size = 3, position = position_dodge2(width = 0.75)) + + facet_grid(~ openheid_klasse) + + labs(fill = "Legende") +``` + +```{r} +balansvergelijking_weidestreek2 %>% + ggplot(aes(x = sbp_akkervogels, y = Y)) + + geom_boxplot(aes(fill = fill_var)) + + geom_label(data = count_df_weidestreek2, + aes(y = max_y + 2000, label = paste("n =", n)), + size = 3, position = position_dodge2(width = 0.75)) + + facet_grid(~ openheid_klasse) + + labs(fill = "Legende") +``` From 45508d604c81a851e00e9dcf021eb0ad83b9b128 Mon Sep 17 00:00:00 2001 From: wlangera Date: Wed, 13 Mar 2024 13:22:53 +0100 Subject: [PATCH 16/19] fix targets dir --- .../targets_steekproef_weidestreek.Rmd | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd b/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd index bf738a4..e7a5df9 100644 --- a/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd +++ b/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd @@ -20,7 +20,7 @@ knitr::opts_chunk$set( warning = FALSE, message = FALSE) target_dir <- rprojroot::find_root_file( - "source", "targets", "mas_steekproef_za_kp_po", + "source", "targets", "mas_steekproef_weidestreek", criterion = rprojroot::is_git_root) knitr::opts_knit$set( root.dir = target_dir) From 023a711304d285a4ab7b8fb68e036e35b843614d Mon Sep 17 00:00:00 2001 From: wlangera Date: Wed, 13 Mar 2024 13:23:21 +0100 Subject: [PATCH 17/19] do not write out yet --- .../targets_steekproef_weidestreek.Rmd | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd b/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd index e7a5df9..d3aada8 100644 --- a/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd +++ b/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd @@ -441,7 +441,7 @@ list( steekproefkader_finaal), steekproef = do.call(rbind.data.frame, steekproef_final)), - write_out = TRUE + write_out = FALSE ) ) ) From 9461ac0cf87397be54778df44812f0f47815da79 Mon Sep 17 00:00:00 2001 From: EmmaCartuyvels1 Date: Wed, 13 Mar 2024 17:04:50 +0100 Subject: [PATCH 18/19] Update targets weidestreek and run --- .../_targets/.gitignore | 5 + .../_targets/meta/meta | 112 ++++++++++++++++++ .../_targets_r/globals/mas-globals.R | 31 +++++ .../_targets_r/targets/hulpvariabelen.R | 42 +++++++ .../_targets_r/targets/nabehandeling.R | 24 ++++ .../_targets_r/targets/raw-data.R | 51 ++++++++ .../_targets_r/targets/steekproefkader.R | 110 +++++++++++++++++ .../_targets_r/targets/steekproeftrekking.R | 44 +++++++ .../_targets_r/targets/version-control.R | 12 ++ .../targets_steekproef_weidestreek.Rmd | 22 ++-- 10 files changed, 440 insertions(+), 13 deletions(-) create mode 100644 source/targets/mas_steekproef_weidestreek/_targets/.gitignore create mode 100644 source/targets/mas_steekproef_weidestreek/_targets/meta/meta create mode 100644 source/targets/mas_steekproef_weidestreek/_targets_r/globals/mas-globals.R create mode 100644 source/targets/mas_steekproef_weidestreek/_targets_r/targets/hulpvariabelen.R create mode 100644 source/targets/mas_steekproef_weidestreek/_targets_r/targets/nabehandeling.R create mode 100644 source/targets/mas_steekproef_weidestreek/_targets_r/targets/raw-data.R create mode 100644 source/targets/mas_steekproef_weidestreek/_targets_r/targets/steekproefkader.R create mode 100644 source/targets/mas_steekproef_weidestreek/_targets_r/targets/steekproeftrekking.R create mode 100644 source/targets/mas_steekproef_weidestreek/_targets_r/targets/version-control.R diff --git a/source/targets/mas_steekproef_weidestreek/_targets/.gitignore b/source/targets/mas_steekproef_weidestreek/_targets/.gitignore new file mode 100644 index 0000000..a8c51cd --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/_targets/.gitignore @@ -0,0 +1,5 @@ +* +!.gitignore +!meta +meta/* +!meta/meta diff --git a/source/targets/mas_steekproef_weidestreek/_targets/meta/meta b/source/targets/mas_steekproef_weidestreek/_targets/meta/meta new file mode 100644 index 0000000..2351b29 --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/_targets/meta/meta @@ -0,0 +1,112 @@ +name|type|data|command|depend|seed|path|time|size|bytes|format|repository|iteration|parent|children|seconds|warnings|error +.Random.seed|object|dbf35755fdc1692b||||||||||||||| +add_bo_to_frame|function|6e7c637516eda95c||||||||||||||| +add_bo2021_to_frame|function|8fa67a77604e8f02||||||||||||||| +add_openheid_landschap_to_frame|function|e8372aad7792bbf7||||||||||||||| +add_stratum_sbp|function|5efe81c83361ea90||||||||||||||| +add_visibility_to_frame|function|ee41a39251d6f1c2||||||||||||||| +allocatie|function|41bddde22d780063||||||||||||||| +allocatie_df|pattern|3792faa93a7c7c3c|b57e23716d60cdc4||-1687481692||||408|qs|local|vector||allocatie_df_8e5ebead|0.08|| +allocatie_df_8e5ebead|branch|8e9bfd11d325cd0a|b57e23716d60cdc4|3fff4836f635324f|1022389371||t19795.6585100268s|ac227466d022b892|408|qs|local|vector|allocatie_df||0.08|| +allocatie_per_stratum|stem|83b7dc8e1b467f4a|8146117815007abf|5d7e631a6a17d16e|-355702975||t19795.6683525006s|d66a5224e01e4f0c|425|qs|local|group||allocatie_per_stratum_086826c4|0.01|| +bereken_vvi|function|0abbdeccbbd13eed||||||||||||||| +bereken_zichtbaarheid|function|2bd3034a1edb1525||||||||||||||| +bo_file|stem|7e0d21cf5606c794|359c1b4c7990a9fd|9b9db394958c0f85|665821918|C:/R/git_repositories/mbag-mas/data/bo_vlm/BO_2022_VLM_EXTERN.shp|t19017.4542939815s|ad0af8073b51b807|10303232|file|local|vector|||0|| +calc_lbg|function|4bd8328de31b952f||||||||||||||| +calc_target_samplesize|function|9a42e00e97b67225||||||||||||||| +check_osm_data|function|5f8ba81fe1582ba0||||||||||||||| +draw_sample|function|e1df96192ac18541||||||||||||||| +exclusie_buffer_osm|function|b12f445c455246d2||||||||||||||| +exclusie_landgebruik_osm|function|d62477921f46efda||||||||||||||| +exclusie_osm_landgebruiken|pattern|d1fb45a8af7a876e|803ffe5163c47b22||1325409374||||23125|qs|local|list||exclusie_osm_landgebruiken_895b026c|117.82|| +exclusie_osm_landgebruiken_895b026c|branch|f624b1fa75721926|803ffe5163c47b22|30ae25622c95481d|-1855072501||t19795.6568763781s|fdbb65c86a9fce82|23125|qs|local|list|exclusie_osm_landgebruiken||117.82|GDAL Message 1 Non closed ring detected. To avoid accepting it, set the OGR_GEOMETRY_ACCEPT_UNCLOSED_RING configuration option to NO. GDAL Message 1 Non closed ring detected. To avoid accepting it, set the OGR_GEOMETRY_ACCEPT_UNCLOSED_RING configuration option to NO| +existing_data|stem|3c7e0d01669810ce|d263cd3b4a96e9aa|62acbc236c408a05|518108294||t19795.6460148434s|34a425cb5d886c1e|31145|qs|local|vector|||0.05|| +existing_file|stem|b8a846b5028f34a5|9d55f7f13b5b4b2e|723760d54ae5f00c|-924525405|C:/R/git_repositories/mbag-mas/data/SOVON/avimap_601_0_MAS_Vlaanderen_telpunten_xy.shp|t19753.359068548s|75c340b0b5227ada|36136|file|local|vector|||0|| +extract_osm_paden|function|46502b4426347d82||||||||||||||| +filter_zichtbaarheid|function|aa60da97b0febc80||||||||||||||| +get_coverage_wcs|function|17e6b10e4b6cda2e||||||||||||||| +get_feature_wfs|function|867bf0bf51023891||||||||||||||| +landusemetrics_grid_cell|function|7ce5f6dbb4d702f0||||||||||||||| +legend_lum|stem|e5ddac36525a46b6|1a84f4c749b9099b|8e12c9a99758e245|806634||t19795.6460104011s|5c9527f6accbdfd1|1341|qs|local|vector|||0.65|| +legend_lum_file|stem|2fd1e804a10c6e7c|2255d422802ce21e|c18b4a40a0fcf5e7|253755819|C:/R/git_repositories/mbag-mas/data/landgebruik/legende_landgebruik.csv|t19731.3869515252s|e685cd6549872275|5726|file|local|vector|||0|| +lum_download|function|6824f1f1ddc0e360||||||||||||||| +lum_read_from_inbo|function|adfa6bb3e812df82||||||||||||||| +lum_read_from_vito|function|e0da637d68abe823||||||||||||||| +mbag_dir|object|73add2da6d24990f||||||||||||||| +nn_steekproef|function|04e18ded90bdbb1c||||||||||||||| +openheid_landschap_file|stem|209fc30a2f51ca7a|5747555e9d5be752|8eb83b1e1e992a99|474982239|C:/R/git_repositories/mbag-mas/data/dem/openness300m_chm_res25_c300_mean_vlaanderen.tif|t19072.3925462963s|67065bf5b4b15cab|120678615|file|local|vector|||0|| +osm_belgium|stem|7adcf9d0141fc3f9|b6dad0f51c49b73b|404f59bf50dfbf49|1842276490|C:\R\osmdata/geofabrik_belgium-latest.osm.pbf|t19684.5739786934s|e8bfed3764c576c7|570313121|file|local|vector|||0|| +output_finaal|function|f66171e257589a97||||||||||||||| +output_objecten|stem|d72ac04fb815ea70|774d311bc07f846c|d5366e1bbd53d74e|380841559||t19795.6684780456s|506f9f6b3747f807|42|qs|local|vector|||0.02|| +paden|pattern|b97f98299a6bd906|1dcd3de79261e01b||-581244374||||46893|qs|local|list||paden_265998d8|38.22|| +paden_265998d8|branch|141b30a28b815bad|1dcd3de79261e01b|22a7bb6c82c7ee88|1022568184||t19795.6573224632s|2f0958f061b6a1b5|46893|qs|local|list|paden||38.22|attribute variables are assumed to be spatially constant throughout all geometries. attribute variables are assumed to be spatially constant throughout all geometries| +paden_naar_punten|function|9e5b98188bb1c603||||||||||||||| +path_to_bo|function|bcff15dc4b79c7e2||||||||||||||| +path_to_bo2021|function|4499a9363a6088d5||||||||||||||| +path_to_existing|function|25c9bc64400737b8||||||||||||||| +path_to_lbg|function|0922d05d9993a839||||||||||||||| +path_to_legend_lum|function|add62ebd90e5ab78||||||||||||||| +path_to_lum|function|c76ba3b6c3939e05||||||||||||||| +path_to_openheid_landschap|function|88104e89aa3233cf||||||||||||||| +path_to_osm_download|function|6ad7e48367119170||||||||||||||| +path_to_perimeters|function|b147a6716922625e||||||||||||||| +path_to_sbp_akkervogels|function|cac6b2448137d71f||||||||||||||| +perimeters_data|stem|a5becdf21555f676|92b9f7239f656e30|911c4ba972ff0f6c|482934140||t19795.645999586s|2e1b50271b75ccab|16791|qs|local|vector||perimeters_data_a6dde57b|0.09|| +perimeters_file|stem|8185f03c71760df9|479abb72b15cbe4e|92a98b7dcf7efa79|-462535867|C:/R/git_repositories/mbag-mas/data/processed/weidestreek_perimeters.gpkg|t19795.6065508983s|443dfd17f08af477|118784|file|local|vector|||4.65|| +plus_openheid_landschap|pattern|0a04843c37a59497|1685890019eb64eb||544945405||||26752|qs|local|list||plus_openheid_landschap_f3919923|0.25|| +plus_openheid_landschap_f3919923|branch|6914ed75a7bde0ab|1685890019eb64eb|ba5518d903c2ac09|18242006||t19795.6584999802s|716e7cddb2ab8b71|26752|qs|local|list|plus_openheid_landschap||0.25|| +plus_sb|pattern|283567ff09e66e8b|c28211e1abe1ce96||-818901959||||23435|qs|local|list||plus_sb_92730d14|3.8|| +plus_sb_92730d14|branch|d8c90e129a3e38de|c28211e1abe1ce96|ecc40e4728c501bf|1478852772||t19795.6584927816s|70e83a306ad4a18a|23435|qs|local|list|plus_sb||3.8|attribute variables are assumed to be spatially constant throughout all geometries. Missing values are always removed in SQL aggregation functions.Use na.rm TRUE to silence this warningThis warning is displayed once every 8 hours.| +point_to_gridcell|function|27bb10730048677c||||||||||||||| +punten|pattern|72bf0460b61cbe05|5ff6cabb84dc0334||1803019928||||16943|qs|local|list||punten_3959e4d5|1.42|| +punten_3959e4d5|branch|85c33d30299d6788|5ff6cabb84dc0334|17c59bc98be08cba|-693338051||t19795.6573419516s|add75ef7cf49e6e5|16943|qs|local|list|punten||1.42|attribute variables are assumed to be spatially constant throughout all geometries| +punten_lum_buffer|function|42b3f1a87d582385||||||||||||||| +punten_selectie_landgebruik|function|4c2aaf8166092a1b||||||||||||||| +punten_selectie_zichtbaarheid|pattern|9848765afe038a32|e139012b6e10af88||713434337||||23413|qs|local|list||punten_selectie_zichtbaarheid_2f0b5928|0|| +punten_selectie_zichtbaarheid_2f0b5928|branch|d00b9f915caba4ab|e139012b6e10af88|c40d22717821dcb8|1888647491||t19795.6584451106s|31cc446c3f2b58ff|23413|qs|local|list|punten_selectie_zichtbaarheid||0|| +punten_zichtbaarheid|pattern|df79ecaeda0a8bbd|7a88d498f38b793c||1672937974||||28504|qs|local|list||punten_zichtbaarheid_bd016819*punten_zichtbaarheid_b7ae421a*punten_zichtbaarheid_84b32894*punten_zichtbaarheid_689dca3a*punten_zichtbaarheid_af20f028|73.93|| +punten_zichtbaarheid_689dca3a|branch|dfe590af09633785|7a88d498f38b793c|bba2d0b4176e9cf9|-1661549243||t19795.6582945837s|6fcac13524cdfbb7|5974|qs|local|list|punten_zichtbaarheid||15.96|| +punten_zichtbaarheid_84b32894|branch|afdd3f3c123eae0d|7a88d498f38b793c|bba2d0b4176e9cf9|1221093215||t19795.6581060073s|abf2532054072d95|5998|qs|local|list|punten_zichtbaarheid||15.21|| +punten_zichtbaarheid_af20f028|branch|4b77fbfb15ba1a79|7a88d498f38b793c|bba2d0b4176e9cf9|1796131792||t19795.6584377185s|ee072c847f5f29fa|4805|qs|local|list|punten_zichtbaarheid||12.09|| +punten_zichtbaarheid_b7ae421a|branch|ca3667b982593db6|7a88d498f38b793c|bba2d0b4176e9cf9|-1516911428||t19795.6579266983s|e45209df98b91f96|5861|qs|local|list|punten_zichtbaarheid||15.51|| +punten_zichtbaarheid_bd016819|branch|f72b1b1ddda827c6|7a88d498f38b793c|bba2d0b4176e9cf9|-515518418||t19795.6577439383s|518fb5e454703407|5866|qs|local|list|punten_zichtbaarheid||15.16|| +punten_zichtbaarheid_per_regio|stem|b84975f02c4f5385|27eaaf21946cda83|1649978409b711a7|-1283385352||t19795.6584413775s|078ac4c55581bf03|23520|qs|local|group||punten_zichtbaarheid_per_regio_0d21a419|0.03|| +read_bo|function|13920fd20ecbac61||||||||||||||| +read_legend_lum|function|5493f2158a71d708||||||||||||||| +read_lum_rast|function|ab1941e8592097df||||||||||||||| +read_sbp_akkervogels|function|97bbcf9562e58a8d||||||||||||||| +read_sbp_others|function|4e5c111a040493f3||||||||||||||| +replace_by_existing|function|13e7b4a856a4caf2||||||||||||||| +sbp_akkervogels|pattern|64503db6dbd03bb6|2bee582e6b56c9db||1814220675||||2481|qs|local|list||sbp_akkervogels_8683e670|0.26|| +sbp_akkervogels_8683e670|branch|2a8ccb4f84862a46|2bee582e6b56c9db|7cfc755524b5f8e2|1525544027||t19795.6554701695s|4098b1e9dbb2eceb|2481|qs|local|list|sbp_akkervogels||0.26|attribute variables are assumed to be spatially constant throughout all geometries| +sbp_akkervogels_file|stem|e4d1a382c5fe78ff|c2c2b2b64539feb0|5da110fa07ae5214|-1887182577|C:/R/git_repositories/mbag-mas/data/bo_vlm/akkervogelgebieden2022.shp|t19384.4746064815s|9c077e0f051b9344|531772|file|local|vector|||0|| +sbp_overige_file|stem|20fed4c3e7b206dd|0c4f6aaa26c31dbf|5da110fa07ae5214|-492924753|C:/R/git_repositories/mbag-mas/data/bo_vlm/sbp_overige_soorten.shp|t19403.3764351852s|c7c17bd310f21b5f|3904168|file|local|vector|||0|| +selectie_landgebruik|pattern|caeded2c51ccb59f|1096316cc1a384e8||1227678439||||16788|qs|local|list||selectie_landgebruik_f46d19a9|0.02|| +selectie_landgebruik_f46d19a9|branch|1fceeb3b1ab55eeb|1096316cc1a384e8|ba8f4f4776ad60d5|112979712||t19795.6575610433s|1ff2774caa0889d9|16788|qs|local|list|selectie_landgebruik||0.02|| +selectie_landgebruik_per_size|stem|aafbc5f49746d5a9|cdab8ef96200ef33|d6e6deb0dd154a86|1762846177||t19795.6575646676s|f435025ed59f5e93|16827|qs|local|group||selectie_landgebruik_per_size_dec8164a*selectie_landgebruik_per_size_7ea61f4d*selectie_landgebruik_per_size_28173fe3*selectie_landgebruik_per_size_5cc79cdf*selectie_landgebruik_per_size_5f8cbdb0|0|| +selectie_landgebruik_vito|function|48a4042b1ae57018||||||||||||||| +selectie_openheid|function|8501b91c522b695f||||||||||||||| +selectie_openheid_klasses|pattern|7259756e43502132|9c52396bdcb089cf||-2082970765||||18785|qs|local|list||selectie_openheid_klasses_8683e670|3.03|| +selectie_openheid_klasses_8683e670|branch|c8ecf30fe134183a|9c52396bdcb089cf|b54de136b668e541|-1420375076||t19795.6555085284s|399e9034771e2d41|18785|qs|local|list|selectie_openheid_klasses||3.03|attribute variables are assumed to be spatially constant throughout all geometries| +st_bbox.SpatRaster|function|076f7dae436454bf||||||||||||||| +st_crs.SpatRaster|function|70c89432d6566dd5||||||||||||||| +steekproef|pattern|5d338aee2ca993ce|b9cdc19da181de89||437593439||||4177|qs|local|list||steekproef_c6616f14|0.11|| +steekproef_78a4c2ad|branch||b9cdc19da181de89|28853a0511be352d|-868114751||t19795.6585290974s||0|qs|local|list|steekproef||0.03||sample_size_extra not less than nrowsampling_frame +steekproef_c6616f14|branch|ec820d8a29d0f338|b9cdc19da181de89|28853a0511be352d|-529847067||t19795.6683619918s|3ccca40a7f23d47d|4177|qs|local|list|steekproef||0.11|| +steekproef_dad84c97|branch|31472ac202a10dd9|b9cdc19da181de89|28853a0511be352d|2120782023||t19795.6585245713s|11f39a9e6d5001fd|4064|qs|local|list|steekproef||0.11|| +steekproef_final|pattern|e2eccfd3e7b695ad|9bd022e5861d4617||608845280||||3158|qs|local|list||steekproef_final_96ab6eee|6.27|| +steekproef_final_96ab6eee|branch|176feea06e40ad71|9bd022e5861d4617|0de0df685cc2375a|-347353345||t19795.6684749022s|4c431b8a6f89e2a7|3158|qs|local|list|steekproef_final||6.27|attribute variables are assumed to be spatially constant throughout all geometries. attribute variables are assumed to be spatially constant throughout all geometries. Using an external vector in selections was deprecated in tidyselect 1.1.0.ℹ Please use all_of or any_of instead. Was data selectid_existing_points Now data selectall_ofid_existing_pointsSee httpstidyselect.rlib.orgreferencefaqexternalvector.html.. attribute variables are assumed to be spatially constant throughout all geometries. There was 1 warning in filter.ℹ In argument intersect_area maxintersect_area.Caused by warning in max no nonmissing arguments to max returning Inf| +steekproef_thinned|pattern|33caca81ff24ace9|515fbea4aa34999f||-855907396||||3155|qs|local|list||steekproef_thinned_9cc0acad|2.83|| +steekproef_thinned_9cc0acad|branch|224ef0d398924264|515fbea4aa34999f|9fa801b10faa8438|-2088007850||t19795.6683984394s|08dc7b39c268235e|3155|qs|local|list|steekproef_thinned||2.83|| +steekproef_uitdunnen|function|150bfcd4f4b84182||||||||||||||| +steekproefkader_finaal|pattern|14eeb173553e4e3d|dc0a6b19ec1b4fcf||1233885034||||26836|qs|local|list||steekproefkader_finaal_9c7dcc77|0.03|| +steekproefkader_finaal_9c7dcc77|branch|3ccd4fe9557ac7f8|dc0a6b19ec1b4fcf|d2cdc15d21288834|-1745507742||t19795.6585047351s|83afce9b1ec2ce0d|26836|qs|local|list|steekproefkader_finaal||0.03|| +steekproefkader_per_stratum|stem|641271162e8666f7|a55013c3689ebdb6|d5e124734735598d|-609136819||t19795.6683571914s|dd9506876d2c5df4|26435|qs|local|group||steekproefkader_per_stratum_bc12f6fa|0.06|| +target_dir|object|44d67b35f3d6162f||||||||||||||| +telcirkels_landgebruik|pattern|e63bf95548d6294a|07b4a731c4824f5d||1989720068||||76829|qs|local|list||telcirkels_landgebruik_1da4ba57|17.3|| +telcirkels_landgebruik_1da4ba57|branch|c3db40a1406e4aa9|07b4a731c4824f5d|81a351a78717a31c|1187196762||t19795.6575454925s|83e37b04818755d2|76829|qs|local|list|telcirkels_landgebruik||17.3|| +telcirkels_selectie_landgebruik|pattern|16806aeae6797861|ef4f2279b6344c96||553012287||||36467|qs|local|vector||telcirkels_selectie_landgebruik_029b923a|0.78|| +telcirkels_selectie_landgebruik_029b923a|branch|85be9c4a6811587c|ef4f2279b6344c96|34fed908953fb4a8|916995886||t19795.6575578682s|a9da779629c352c8|36467|qs|local|vector|telcirkels_selectie_landgebruik||0.78|| +thin_sample|function|c3189d7a55cf76f5||||||||||||||| +unpack_mht|function|6460af0636392b31||||||||||||||| +vito_lum_2019_file|stem|e562a9788de76291|6200b6036f557b4d|f9ddfd99ea9d564c|1885293617|C:/R/git_repositories/mbag-mas/data/landgebruik/vito/lu_landgebruik_vlaa_2019_v2.tif|t18823.6266666667s|51d7bcac44afca0a|57051741|file|local|vector|||0|| diff --git a/source/targets/mas_steekproef_weidestreek/_targets_r/globals/mas-globals.R b/source/targets/mas_steekproef_weidestreek/_targets_r/globals/mas-globals.R new file mode 100644 index 0000000..7fecb45 --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/_targets_r/globals/mas-globals.R @@ -0,0 +1,31 @@ +options(tidyverse.quiet = TRUE) +tar_option_set(packages = c("dplyr", + "readr", + "tidyr", + "tibble", + "nngeo", + "osmextract", + "terra", + "exactextractr", + "arrow", + "httr", + "sf", + "GVI"), + format = "qs", + memory = "transient", + garbage_collection = TRUE, + workspace_on_error = TRUE) + +target_dir <- rprojroot::find_root_file( + "source", "targets", "mas_steekproef_weidestreek", + criterion = rprojroot::is_git_root) +mbag_dir <- rprojroot::find_root_file( + criterion = rprojroot::is_git_root) + +source(file.path(mbag_dir, "source", "R", "landuse_maps.R")) +source(file.path(mbag_dir, "source", "R", "geocomputations.R")) +source(file.path(mbag_dir, "source", "R", "draw_sample.R")) +source(file.path(mbag_dir, "source", "R", "steekproefkader.R")) +source(file.path(mbag_dir, "source", "R", "berekening_hulpvariabelen.R")) +source(file.path(mbag_dir, "source", "R", "steekproeftrekking_nabehandeling.R")) +source(file.path(mbag_dir, "source", "R", "wfs_wcs.R")) diff --git a/source/targets/mas_steekproef_weidestreek/_targets_r/targets/hulpvariabelen.R b/source/targets/mas_steekproef_weidestreek/_targets_r/targets/hulpvariabelen.R new file mode 100644 index 0000000..2a32b19 --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/_targets_r/targets/hulpvariabelen.R @@ -0,0 +1,42 @@ +list( + tar_target( + name = plus_sb, + command = add_bo_to_frame( + punten_df = punten_selectie_zichtbaarheid, + path_bo = bo_file + ), + pattern = map(punten_selectie_zichtbaarheid), + iteration = "list" + ), + tar_target( + name = plus_openheid_landschap, + command = add_openheid_landschap_to_frame( + path = openheid_landschap_file, + punten_sf = plus_sb, + gebied = perimeters_data, + cutlevels = c(1.25, 1.35, 1.51), + class_labels = c("GL", "HGL", "HOL", "OL") + ), + pattern = map(perimeters_data, plus_sb), + iteration = "list" + ), + tar_target( + name = sbp_akkervogels, + command = read_sbp_others( + path = sbp_overige_file, + soorten = c("hamster", "bruine kiekendief", "zomertortel", "grauwe kiekendief"), + gebied = perimeters_data + ), + pattern = map(perimeters_data), + iteration = "list" + ), + tar_target( + name = steekproefkader_finaal, + command = add_stratum_sbp( + punten_sf = plus_openheid_landschap, + sbp = do.call(rbind.data.frame, sbp_akkervogels) + ), + pattern = map(plus_openheid_landschap), + iteration = "list" + ) +) diff --git a/source/targets/mas_steekproef_weidestreek/_targets_r/targets/nabehandeling.R b/source/targets/mas_steekproef_weidestreek/_targets_r/targets/nabehandeling.R new file mode 100644 index 0000000..6704cfb --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/_targets_r/targets/nabehandeling.R @@ -0,0 +1,24 @@ +list( + tar_target( + steekproef_thinned, + thin_sample( + sample = steekproef, + thin_dist = 400 + ), + pattern = map(steekproef), + iteration = "list" + ), + tar_target( + steekproef_final, + replace_by_existing( + sample = steekproef_thinned, + existing_points = existing_data, + id_existing_points = as.name("naam"), + gebied = perimeters_data, + overlap_prop = 0.5, + sbp_file = do.call(rbind.data.frame, sbp_akkervogels) + ), + pattern = map(steekproef_thinned), + iteration = "list" + ) +) diff --git a/source/targets/mas_steekproef_weidestreek/_targets_r/targets/raw-data.R b/source/targets/mas_steekproef_weidestreek/_targets_r/targets/raw-data.R new file mode 100644 index 0000000..681dece --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/_targets_r/targets/raw-data.R @@ -0,0 +1,51 @@ +list( + tarchetypes::tar_file( + perimeters_file, + path_to_perimeters("weidestreek_perimeters.gpkg") + ), + tar_target( + perimeters_data, + st_read(perimeters_file) %>% + arrange(Naam) + ), + tarchetypes::tar_file( + osm_belgium, + path_to_osm_download() + ), + tarchetypes::tar_file( + vito_lum_2019_file, + path_to_lum(jaar = 2019) + ), + tarchetypes::tar_file( + legend_lum_file, + path_to_legend_lum() + ), + tar_target( + legend_lum, + read_legend_lum(file = legend_lum_file) + ), + tarchetypes::tar_file( + openheid_landschap_file, + path_to_openheid_landschap() + ), + tarchetypes::tar_file( + bo_file, + path_to_bo(jaar = 2022) + ), + tarchetypes::tar_file( + sbp_akkervogels_file, + path_to_sbp_akkervogels(file = "akkervogelgebieden2022.shp") + ), + tarchetypes::tar_file( + sbp_overige_file, + path_to_sbp_akkervogels(file = "sbp_overige_soorten.shp") + ), + tarchetypes::tar_file( + existing_file, + path_to_existing(file = "avimap_601_0_MAS_Vlaanderen_telpunten_xy.shp") + ), + tar_target( + existing_data, + st_read(existing_file) +) + ) diff --git a/source/targets/mas_steekproef_weidestreek/_targets_r/targets/steekproefkader.R b/source/targets/mas_steekproef_weidestreek/_targets_r/targets/steekproefkader.R new file mode 100644 index 0000000..1550e3b --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/_targets_r/targets/steekproefkader.R @@ -0,0 +1,110 @@ +list( + tar_target( + name = selectie_openheid_klasses, + command = selectie_openheid( + gebied = perimeters_data, + ol_strata = c("OL", "HOL") + ), + pattern = map(perimeters_data), + iteration = "list" + ), + tar_target( + name = exclusie_osm_landgebruiken, + command = exclusie_landgebruik_osm( + gebied = selectie_openheid_klasses, + osmdata = osm_belgium, + landuse = c("residential", "military", "industrial", "cemetery", + "railway", "commercial", "farmyard"), + leisure = c("park"), + update_osm_layer = FALSE + ), + pattern = map(selectie_openheid_klasses), + iteration = "list" + ), + tar_target( + name = paden, + command = extract_osm_paden( + gebied = selectie_openheid_klasses, + exclusie = exclusie_osm_landgebruiken, + osmdata = osm_belgium, + paths_include = c("track", "tertiary", "tertiary_link", "unclassified"), + cutting_exclude = NULL, + historic_exclude = NULL, + waterway = NULL, + update_osm_layer = FALSE + ), + pattern = map(selectie_openheid_klasses, exclusie_osm_landgebruiken), + iteration = "list" + ), + tar_target( + name = punten, + command = paden_naar_punten( + data_paden = paden, + gebieden = perimeters_data, + interpoint_distance = 50, + border_distance = 300 + ), + pattern = map(perimeters_data, paden), + iteration = "list" + ) , + tar_target( + name = telcirkels_landgebruik, + command = punten_lum_buffer( + punten_sf = punten, + radius = 300, + file = vito_lum_2019_file, + legend = legend_lum + ), + pattern = map(punten), + iteration = "list" + ), + tar_target( + name = telcirkels_selectie_landgebruik, + command = punten_selectie_landgebruik( + lum_extract_result = telcirkels_landgebruik, + legend_rast = legend_lum, + max_prop_overige = 0.5, + min_prop_akker = 0.3, + min_prop_akker_grasland = 0.4 + ), + pattern = map(telcirkels_landgebruik) + ), + tar_target( + name = selectie_landgebruik, + command = selectie_landgebruik_vito( + punten_sf = punten, + selectie_df = telcirkels_selectie_landgebruik + ), + pattern = map(punten, telcirkels_selectie_landgebruik), + iteration = "list" + ), + tarchetypes::tar_group_size( + name = selectie_landgebruik_per_size, + command = do.call(rbind.data.frame, selectie_landgebruik), + size = 200 + ), + tar_target( + name = punten_zichtbaarheid, + command = add_visibility_to_frame( + punten_sf = selectie_landgebruik_per_size, + resolution = 5, + spacing = 10 + ), + pattern = map(selectie_landgebruik_per_size), + iteration = "list" + ), + tarchetypes::tar_group_by( + name = punten_zichtbaarheid_per_regio, + command = do.call(rbind.data.frame, punten_zichtbaarheid), + Naam + ), + tar_target( + name = punten_selectie_zichtbaarheid, + command = filter_zichtbaarheid( + punten_sf = punten_zichtbaarheid_per_regio, + min_cvvi = 0.1 + ), + pattern = map(punten_zichtbaarheid_per_regio), + iteration = "list" + ) +) diff --git a/source/targets/mas_steekproef_weidestreek/_targets_r/targets/steekproeftrekking.R b/source/targets/mas_steekproef_weidestreek/_targets_r/targets/steekproeftrekking.R new file mode 100644 index 0000000..d73e137 --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/_targets_r/targets/steekproeftrekking.R @@ -0,0 +1,44 @@ +list( + tar_target( + allocatie_df, + allocatie( + steekproefkader = steekproefkader_finaal, + min_samplesize = 0, + target_samplesize = 91, + popsize_minimum = 0, + allocatie_binnen_sbp = steekproefkader_finaal %>% + st_drop_geometry() %>% + count(is_sbp) %>% + mutate(prop = n / sum(n)) %>% + filter(is_sbp) %>% + pull(prop), + allocatie_leemstreek = 0, + ol_strata = c("OL", "HOL") + ), + pattern = map(steekproefkader_finaal) + ), + tarchetypes::tar_group_by( + allocatie_per_stratum, + allocatie_df, + Naam + ), + tarchetypes::tar_group_by( + steekproefkader_per_stratum, + do.call(rbind.data.frame, steekproefkader_finaal) %>% + semi_join(allocatie_df %>% + select(Naam, is_sbp, openheid_klasse), + by = c("Naam", "is_sbp", "openheid_klasse")), + Naam + ), + tar_target( + steekproef, + draw_sample( + sampling_frame = steekproefkader_per_stratum, + sample_size = 91, + sample_size_multiplication = 1, + balance = c("X", "Y") + ), + pattern = map(steekproefkader_per_stratum, allocatie_per_stratum), + iteration = "list" + ) +) diff --git a/source/targets/mas_steekproef_weidestreek/_targets_r/targets/version-control.R b/source/targets/mas_steekproef_weidestreek/_targets_r/targets/version-control.R new file mode 100644 index 0000000..b13a4b2 --- /dev/null +++ b/source/targets/mas_steekproef_weidestreek/_targets_r/targets/version-control.R @@ -0,0 +1,12 @@ +list( + tar_target( + output_objecten, + output_finaal( + files = list(steekproefkader = do.call(rbind.data.frame, + steekproefkader_finaal), + steekproef = do.call(rbind.data.frame, + steekproef_final)), + write_out = FALSE + ) + ) +) diff --git a/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd b/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd index d3aada8..e778c4c 100644 --- a/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd +++ b/source/targets/mas_steekproef_weidestreek/targets_steekproef_weidestreek.Rmd @@ -108,7 +108,7 @@ tar_option_set(packages = c("dplyr", workspace_on_error = TRUE) target_dir <- rprojroot::find_root_file( - "source", "targets", "mas_steekproef_zl_lm_za_kp_po", + "source", "targets", "mas_steekproef_weidestreek", criterion = rprojroot::is_git_root) mbag_dir <- rprojroot::find_root_file( criterion = rprojroot::is_git_root) @@ -301,6 +301,8 @@ list( ) ``` +Er is geen overlap met SBP akkervogels dus we gebruiken de functie read_sbp_other in plaats van read_sbp_akkervogels. + ```{targets hulpvariabelen} list( tar_target( @@ -326,12 +328,10 @@ list( ), tar_target( name = sbp_akkervogels, - command = read_sbp_akkervogels( - path = sbp_akkervogels_file, - gebied = perimeters_data, - path_extra_soorten = sbp_overige_file, - extra_soorten = c("hamster", "bruine kiekendief", "zomertortel", - "grauwe kiekendief") + command = read_sbp_others( + path = sbp_overige_file, + soorten = c("hamster", "bruine kiekendief", "zomertortel", "grauwe kiekendief"), + gebied = perimeters_data ), pattern = map(perimeters_data), iteration = "list" @@ -375,9 +375,7 @@ list( tarchetypes::tar_group_by( allocatie_per_stratum, allocatie_df, - Naam, - is_sbp, - openheid_klasse + Naam ), tarchetypes::tar_group_by( steekproefkader_per_stratum, @@ -385,9 +383,7 @@ list( semi_join(allocatie_df %>% select(Naam, is_sbp, openheid_klasse), by = c("Naam", "is_sbp", "openheid_klasse")), - Naam, - is_sbp, - openheid_klasse + Naam ), tar_target( steekproef, From e08758a9c69033e1c23349de1a84f8592e2b9b81 Mon Sep 17 00:00:00 2001 From: EmmaCartuyvels1 Date: Thu, 14 Mar 2024 15:10:19 +0100 Subject: [PATCH 19/19] Create markdown weidestreek --- .../steekproefontwerp_weidestreek.Rmd | 1088 +++++++++++++++++ 1 file changed, 1088 insertions(+) create mode 100644 source/markdown/steekproefontwerp_weidestreek.Rmd diff --git a/source/markdown/steekproefontwerp_weidestreek.Rmd b/source/markdown/steekproefontwerp_weidestreek.Rmd new file mode 100644 index 0000000..b5f1459 --- /dev/null +++ b/source/markdown/steekproefontwerp_weidestreek.Rmd @@ -0,0 +1,1088 @@ +--- +title: "MAS steekproefontwerp weidestreek" +author: "Emma Cartuyvels, Ward Langeraert, Hans Van Calster" +date: "`r Sys.Date()`" +output: + bookdown::html_document2: + code_folding: hide + toc: true + toc_float: true + toc_collapsed: true +editor_options: + chunk_output_type: console +--- + +```{r setup, include=FALSE} +# set up +library(knitr) +library(here) +opts_chunk$set( + echo = TRUE, + warning = FALSE, + message = FALSE, + out.width = "100%" +) +opts_knit$set(root.dir = here::here()) +``` + +```{r} +# packages +library(tidyverse) +library(targets) +library(sf) +library(mapview) +library(terra) + +# globals +mbag_dir <- here() +source(here("source", "R", "steekproefkader.R")) +source(here("source", "R", "berekening_hulpvariabelen.R")) +source(here("source", "R", "wfs_wcs.R")) +targets_store <- here("source", "targets", "mas_steekproef_weidestreek", "_targets") +``` + +# Vooraf + +Voeg dit toe aan het `.Renviron` bestand: +`OSMEXT_DOWNLOAD_DIRECTORY="C:/R/osmdata"` + +Dat bestand kan je openen met de volgende code: + +`usethis::edit_r_environ()` + +# Afbakening steekproefkader + +```{r} +perimeters_data <- tar_read(perimeters_data, store = targets_store) + +mapview(perimeters_data, color = "red", alpha.regions = 0, legend = FALSE) +``` + +## Selectie openheid landschap + +We maken gebruik van het DSM (digitaal oppervlakte model - DHMV II Vlaanderen) en DTM (digitaal terrein model) op 5 m resolutie. +Werkwijze: + +- berekening "canopy height model" (CHM) door verschil te berekenen tussen DSM en DTM. Dit geeft dan hoogte boven het maaiveld (gebouwen, bodem, struiken, ...). +- berekening van "positive topographic openness" (dit is een waarde tussen 0 en 2 in radialen) door voor elke rastercel van het CHM in 8 kijk richtingen na te gaan wat de gemiddelde hoek is t.o.v. zenit binnen een straal van 300 m. Deze hoek geeft aan hoe plat het landschap is. Indien volledig plat is de hoek 90° (of 1.57 radialen). +- met dit resultaat de gemiddelde (van de gemiddelde) topografische openheid berekenen in een cirkelvormig landschap rond elke cel met straal 300 m. +- deze gemiddelden zijn daarna ingedeeld in drie klassen: + - OL: open landschap (\> 86,5°), + - HOL: halfopen landschap (77,3° - 86,5°), + - HGL: halfgesloten landschap (71,6° - 77,3°) + - GL: (\< 71,6°) gesloten landschap + +We selecteren OL en HOL binnen de perimeter. + +```{r} +selectie_openheid_klasses <- tar_read(selectie_openheid_klasses, + store = targets_store) %>% + reduce(rbind) + +mapview(perimeters_data, color = "red", alpha.regions = 0, legend = FALSE) + + mapview(selectie_openheid_klasses, col.regions = "red", legend = FALSE) +``` + +## Exclusie van bepaalde landgebruiken + +We gebruiken kenmerken uit [OpenStreetMap](https://www.openstreetmap.org) om bepaalde landgebruiken uit te sluiten voor de steekproeftrekking. +We gebruiken hiervoor de kenmerken [landuse](https://wiki.openstreetmap.org/wiki/NL:Key:landuse) (grondgebruik), [leisure](https://wiki.openstreetmap.org/wiki/NL:Key:leisure) (vrije tijd), [aeroway](https://wiki.openstreetmap.org/wiki/Key:aeroway) (luchthaven) en [highway](https://wiki.openstreetmap.org/wiki/Key:highway) (wegen). +De links in voorgaande zin verwijzen naar de volledige lijst van mogelijke klassen. + +We knippen onderstaande landgebruiken uit voorgaande selectie. +Rond autosnelwegen en invoegstroken en afritten van autosnelwegen trekken we een buffer van 100 m. + +### Woongebied + +- OSM definitie: `landuse = residential` +- Objecttype: woongebied +- OSM Wiki: + +### Militair terrein + +- OSM definitie: `landuse = military` +- Objecttype: militair terrein +- OSM Wiki: + +### Industriegebied + +- OSM definitie: `landuse = industrial` +- Objecttype: industriegebied +- OSM Wiki: + +### Begraafplaats + +- OSM definitie: `landuse = cemetary` +- Objecttype: begraafplaats +- OSM Wiki: + +### Spoorwegemplacement, spoorbedding + +- OSM definitie: `landuse = railway` +- Objecttype: spoorwegemplacement, spoorbedding +- OSM Wiki: + +### Commercieel + +- OSM definitie: `landuse = commercial` +- Objecttype: commercieel +- OSM Wiki: + +### Boerenerf + +- OSM definitie: `landuse = farmyard` +- Objecttype: boerenerf +- OSM Wiki: + +### Park + +- OSM definitie: `leisure = park` +- Objecttype: park +- OSM Wiki: + +### Vliegveld + +- OSM definitie: `aeroway = aerodrome` +- Objecttype: vliegveld +- OSM Wiki: + +### Autosnelweg + +- OSM definitie: `highway = motorway` +- Objecttype: autosnelweg +- OSM Wiki: + +### Invoegstroken en afritten van autosnelwegen + +- OSM definitie: `highway = motorway_link` +- Objecttype: invoegstroken en afritten van autosnelwegen +- OSM Wiki: + +Verder vereenvoudigen van de polygonenkaart door: + +- alle polygonen samen te voegen tot 1 multipolygon (union) +- bufferen met straal 20 m +- overtollige vertices verwijderen met tolerantie 10 m +- alle gaten (polygon holes) verwijderen + +In groen de exclusiekaart en rood OL en HOL binnen de perimeter. + +```{r} +exclusie_osm_landgebruiken <- tar_read(exclusie_osm_landgebruiken, + store = targets_store) %>% + reduce(rbind) +``` + +```{r} +mapview(perimeters_data, + color = "red", alpha.regions = 0, + legend = FALSE +) + + mapview(selectie_openheid_klasses, + col.regions = "red", + legend = FALSE + ) + + mapview(exclusie_osm_landgebruiken, + col.regions = "green", + legend = FALSE + ) +``` + +## Bepalen geldige plaatsen waar telling kan uitgevoerd worden + +We gebruiken kenmerken uit [OpenStreetMap](https://www.openstreetmap.org) om geldige locaties te extraheren waar tellingen kunnen uitgevoerd worden. +We gebruiken hiervoor het kenmerk [highway](https://wiki.openstreetmap.org/wiki/Key:highway) (wegen). + +We selecteren de volgende wegen. + +### Veldwegen en boswegen + +- OSM definitie: `highway = track` +- Object type: veldwegen en boswegen +- OSM Wiki: + +### Tertiaire wegen + +- OSM definitie: `highway = tertiary` +- Object type: tertiaire wegen +- OSM Wiki: + +### Afslagen tertiare wegen + +- OSM definitie: `highway = tertiary_link` +- Object type: afslagen tertiare wegen +- OSM Wiki: + +### Lokale wegen + +- OSM definitie: `highway = unclassified` +- Object type: lokale wegen +- OSM Wiki: + +We verwijderen wegen die overlappen met de exclusiekaart en verwijderen overlappende wegen. + +```{r} +paden <- tar_read(paden, store = targets_store) %>% + reduce(rbind) + +mapview(perimeters_data, + color = "red", alpha.regions = 0, + legend = FALSE +) + + mapview(selectie_openheid_klasses, + col.regions = "red", + legend = FALSE + ) + + mapview(exclusie_osm_landgebruiken, + col.regions = "green", + legend = FALSE + ) + + mapview(paden, legend = FALSE) +``` + +Overzicht lengte per categorie: + +```{r lengte-paden} +paden_tabel <- paden %>% + group_by(Naam, key, value) %>% + summarise(.groups = "drop") %>% + mutate(lengte_km = as.numeric(st_length(.)) / 1e3) %>% + st_drop_geometry() + +paden_tabel %>% + kable(digits = 1) +``` + +De totale lengte aan paden is `r sum(paden_tabel$lengte_km)` km. + +## Punten langs de wegen en paden + +Werkwijze: + +- Langs alle paden worden op regelmatige afstanden van 50 m punten gelegd +- Daarna worden punten die op minder dan 40 m van elkaar liggen ruimtelijk gegroepeerd (dit gebeurt wanneer verschillende paden elkaar kruisen of op korte afstand parallel aan elkaar liggen) en uit elk van deze clusters wordt één punt overgehouden +- Potentiële telpunten moeten op minstens 300 m van de grens van de perimeter gelegen zijn + +```{r} +punten <- tar_read(punten, store = targets_store) %>% + reduce(rbind) + +mapview(perimeters_data, + color = "red", alpha.regions = 0, + legend = FALSE +) + + mapview(selectie_openheid_klasses, + col.regions = "red", + legend = FALSE + ) + + mapview(exclusie_osm_landgebruiken, + col.regions = "green", + legend = FALSE + ) + + mapview(paden, legend = FALSE) + + mapview(punten, zcol = "value", layer = "Type weg of pad") +``` + +Overzicht aantal punten per categorie: + +```{r} +punten %>% + st_drop_geometry() %>% + count(Naam, key, value, name = "Aantal punten") %>% + kable() +``` + +## Exclusie van potentiële telpunten / telcirkels + +### Exclusie op basis van landgebruiksamenstelling + +Voor elk potentieel telpunt / telcirkel: + +- landgebruik oppervlaktes + +> VITO 2019 landgebruikskaart (update elke 3 jaar) + +```{r} +telcirkels_selectie_landgebruik <- tar_read(telcirkels_selectie_landgebruik, + store = targets_store) +``` + +We gebruiken volgende regel als criterium voor telpunten die in aanmerkingen komen voor wat betreft de samenstelling van het landgebruik in een buffer van 300 m rond het punt: + +- Akker + Grasland \> 40% én Grasland + Bos + Struikgewas + Akker \> 50% + +De gebruikte landgebruikskaart dekt enkel het Vlaamse grondgebied. +Indien de telcirkel deels in een andere gewest / land gelegen is, zal het landgebruik daar ontbreken. +In de momenteel gebruikte berekening is dit "ontbrekend" landgebruik weggefilterd en slaat het oppervlakte-aandeel enkel op het deel van de telcirkel waar we data voor hebben. +Het kan dus zijn dat op de volledige telcirkel deze oppervlakte-aandelen verschillend zijn (en al dan niet zouden moeten uitgesloten worden volgens het criterium). + +```{r} +telcirkels_selectie_landgebruik %>% + ggtern::ggtern(aes( + x = Akker + Grasland, + y = Bos + Struikgewas, + z = Overige + )) + + geom_point( + alpha = 0.1, + aes(colour = selectie2) + ) +``` + +De kaart toont de punten die op deze manier niet meer in aanmerkingen komen. + +```{r map-exclusie-landgebruik-vito} +exclusie_punten <- punten %>% + left_join( + telcirkels_selectie_landgebruik %>% + group_by(pointid) %>% + summarize(selectie2 = any(selectie2)), + by = "pointid" + ) %>% + filter(!selectie2) + +mapview(perimeters_data, + color = "red", alpha.regions = 0, + legend = FALSE +) + + mapview(selectie_openheid_klasses, + col.regions = "red", + legend = FALSE + ) + + mapview(exclusie_osm_landgebruiken, + col.regions = "green", + legend = FALSE + ) + + mapview(paden, legend = FALSE) + + mapview(exclusie_punten, col.regions = "black", + legend = FALSE) +``` + +### Exclusie op basis van zichtbaarheid + +We berekenen de cumulatieve zichtbaarheidsindex waarbij de waarnemer een bewegingsvrijheid heeft binnen een straal van 25 m rondom het telpunt. +De zichtbaarheidsindex wordt berekend vanaf een set van locaties die 10 m van elkaar liggen in deze zone van bewegingsvrijheid en geeft de proportie aan van zichtbare rastercellen in de telcirkel met een straal van 300 m. +De cumulatieve zichtbaarheidsindex is dan de som van alle rastercellen die zichtbaar zijn vanuit minstens één locatie binnen de zone van bewegingsvrijheid. + +We verwijderen telpunten waar de cumulatieve "viewshed visibility index" (cvvi) kleiner is dan 0.10 om extreme locaties uit te sluiten. + +```{r} +punten_zichtbaarheid <- tar_read(punten_zichtbaarheid, + store = targets_store) %>% + reduce(rbind) + +plus_visibility <- add_openheid_landschap_to_frame( + path = path_to_openheid_landschap(), + punten_sf = punten_zichtbaarheid, + gebied = perimeters_data, + cutlevels = c(1.25, 1.35, 1.51), + class_labels = c("GL", "HGL", "HOL", "OL") +) +``` + +```{r} +ggplot(plus_visibility) + + geom_histogram(aes(x = cvvi, fill = openheid_klasse)) + + geom_vline(xintercept = 0.1, colour = "firebrick") + + scale_x_continuous(breaks = seq(0, 1, 0.1)) +``` + +## Berekening volledig gekende variabelen die relatie hebben met respons + +Dit zijn interessante variabelen om in rekening te brengen bij het steekproefdesign. +Dit kan bijvoorbeeld door middel van stratificatie of door te zorgen dat de steekproef op een homogene manier de gradiënt van deze hulpvariabele(n) afdekt. + +Voor elk potentieel telpunt / telcirkel: + +- Beheerovereenkomst oppervlaktes: vooral de soortbeschermingsmaatregelen +- maat voor openheid van het landschap (cf. OLA, HOLA, KLA) +- oppervlakte-aandelen van hoofdteelten (landbouwgebruikspercelen) + +### Oppervlakte-aandeel beheerovereenkomsten + +Er waren geen beheerovereenkomsten afgesloten in het weidegebied in 2022: + +```{r} +steekproefkader_finaal <- tar_read(steekproefkader_finaal, + store = targets_store) %>% + reduce(rbind) +``` + +```{r} +summary(steekproefkader_finaal %>% select(area_prop_sb)) +``` + +### Openheid landschap + +We maken gebruik van het DSM (digitaal oppervlakte model - DHMV II Vlaanderen) en DTM (digitaal terrein model) op 5 m resolutie. +Werkwijze: + +- berekening "canopy height model" (CHM) door verschil te berekenen tussen DSM en DTM. Dit geeft dan hoogte boven het maaiveld (gebouwen, bodem, struiken, ...). +- berekening van "positive topographic openness" (dit is een waarde tussen 0 en 2 in radialen) door voor elke rastercel van het CHM in 8 kijkrichtingen na te gaan wat de gemiddelde hoek is t.o.v. zenit binnen een straal van 300 m. Deze hoek geeft aan hoe plat het landschap is. Indien volledig plat is de hoek 90° (of 1.57 radialen). +- met dit resultaat de gemiddelde (van de gemiddelde) topografische openheid berekenen in een cirkelvormig landschap rond elke cel met straal 300 m. +- deze gemiddelden zijn daarna ingedeeld in drie klassen: + - OL open landschap (\> 86,5°), + - HOL halfopen landschap (77,3° - 86,5°), + - HGL halfgesloten landschap (71,6° - 77,3°) + - GL (\< 71,6°) gesloten landschap + +Akkervogelgemeenschappen worden vaak ingedeeld volgens hun affiniteit met open landschap (OLA - Open landschap Akkervogels), half-open landschap (HOLA) en kleinschalig landschap (KLA). +Onder kleinschalig landschap verstaat men een landschap waar de percelen relatief klein zijn en het landschap in sterke mate dooraderd is door hagen, rietkragen en andere lijn- of puntvormige kleine landschapselementen (KLE's). +De manier waarop we openheid van het landschap hebben bepaald laat niet toe om KLA te bepalen zonder bijkomende berekeningen. +KLA zullen een subset zijn van wat wij HOL noemen, met name HOL waar de gemiddelde perceelsgrootte relatief klein is. + +We hadden in de eerste stap al OL en HOL geselecteerd. +Toch is er nog een beetje HGL over maar in de allocatie zullen deze punten wegvallen. + +```{r landschap-openheid} +openheid_classified <- rast( + here("data", "dem", + "openness300m_chm_res25_c300_mean_vlaanderen_classified.tif")) %>% + crop(perimeters_data) %>% + mask(terra::vect(perimeters_data)) +``` + +```{r landschapsopenheid, warning=FALSE} +openheid_raster <- raster::raster(openheid_classified) +openheid_raster <- raster::ratify(openheid_raster) +levels(openheid_raster)[[1]]$LO <- c("GL", "HGL", "HOL", "OL") + +openheid_raster %>% + mapview(alpha = 0.3, layer = "openheid_klasse") +``` + +```{r openheid-points} +steekproefkader_finaal %>% + ggplot() + + geom_histogram( + aes( + x = openheid_waarde * 180 / pi, + fill = openheid_klasse + ), + binwidth = 0.5 + ) + + facet_wrap(~Naam, scales = "free_y") + + labs( + x = "Gemiddelde openheid landschap binnen 300 m buffer (in graden)", + y = "Aantal potentiële telpunten (steekproefkader)" + ) +``` + +### Soortbeschermingsplan + +Zowel binnen kerngebied als zoekzones zijn er soortbeschermende maatregelen (SB BO's) gelegd (zie kaart VLM BO's). +In theorie waren deze maatregelen vooral bedoeld voor kerngebied, en zal daar een hogere dichtheid (bedekkingsgraad) liggen, maar de VLM heeft het toegelaten om ook in zoekzones deze maatregelen te sluiten (al was dat minder de prioriteit). + +We nemen kerngebieden en zoekzones samen als onderzoeksgebied en alles hierbuiten beschouwen we als controle. +Als SBP laag gebruiken we perimeter SBP akkervogels, SBP grauwe kiekendief, SBP bruine kiekendief, SBP zomertortel en SBP hamster. + + +```{r} +sbp_overig <- + st_read(path_to_sbp_akkervogels("sbp_overige_soorten.shp"), + quiet = TRUE + ) %>% + st_transform(31370) %>% + filter(soort %in% c( + "Hamster", "Bruine kiekendief", "Grauwe kiekendief", + "Zomertortel" + )) %>% + mutate(soort = ifelse(soort == "Grauwe kiekendief" & gebied == "nieuw 2023", + "Grauwe kiekendief 2023", soort + )) %>% + select(soort) +sbp_akkergvogels <- + st_read(path_to_sbp_akkervogels("akkervogelgebieden2022.shp"), + quiet = TRUE + ) %>% + st_transform(31370) %>% + mutate(soort = "akkervogels2022") %>% + select(soort) + +mapview(bind_rows(sbp_overig, sbp_akkergvogels), + zcol = "soort", + layer = "soort(engroep)" +) +``` + +In de weidestreek hebben we: + +```{r} +mapview(perimeters_data, color = "red", alpha.regions = 0, legend = FALSE) + + mapview( + st_intersection( + bind_rows(sbp_overig, sbp_akkergvogels), + perimeters_data + ), + zcol = "soort", layer = "soort(engroep)" + ) +``` + +```{r} +sbp_akkervogels <- tar_read(sbp_akkervogels, store = targets_store) %>% + reduce(rbind) +``` + +Het oppervlakte aandeel aan SBP's binnen de weidestreek: + +```{r} +binnen_sbp <- perimeters_data %>% + st_intersection(sbp_akkervogels) %>% + select(Naam) %>% + mutate( + opp = st_area(.), + is_sbp = "binnen sbp" + ) + +buiten_sbp <- perimeters_data %>% + st_difference(sbp_akkervogels %>% + st_union() %>% + st_combine()) %>% + select(Naam) %>% + mutate( + opp = st_area(.), + is_sbp = "buiten sbp" + ) + +opps <- bind_rows(buiten_sbp, binnen_sbp) %>% + st_drop_geometry() + +opps %>% + mutate(opp = units::set_units(opp, "ha")) %>% + group_by(Naam) %>% + mutate(opp_aandeel = opp / sum(opp)) %>% + units::drop_units() %>% + rename(opp_ha = opp) %>% + relocate(is_sbp, .before = opp_ha) %>% + arrange(Naam, is_sbp) %>% + kable(digits = 2) +``` + +Het oppervlakte aandeel aan SBP's binnen OL en HOL in de weidestreek: + +```{r} +binnen_sbp <- selectie_openheid_klasses %>% + st_intersection(sbp_akkervogels) %>% + select(Naam) %>% + mutate( + opp = st_area(.), + is_sbp = "binnen sbp" + ) + +buiten_sbp <- selectie_openheid_klasses %>% + st_difference(sbp_akkervogels %>% + st_union() %>% + st_combine()) %>% + select(Naam) %>% + mutate( + opp = st_area(.), + is_sbp = "buiten sbp" + ) + +opps <- bind_rows(buiten_sbp, binnen_sbp) %>% + st_drop_geometry() + +opps %>% + mutate( + opp = units::set_units(opp, "ha"), + Naam = "Weidestreek (OL en HOL)" + ) %>% + group_by(Naam) %>% + mutate(opp_aandeel = opp / sum(opp)) %>% + units::drop_units() %>% + rename(opp_ha = opp) %>% + relocate(is_sbp, .before = opp_ha) %>% + arrange(Naam, is_sbp) %>% + kable(digits = 2) +``` + +Het oppervlakte aandeel aan SBP's binnen het steekproefkader. +Som per telcirkel: + +```{r} +binnen_sbp <- st_buffer(steekproefkader_finaal, 300) %>% + st_intersection(sbp_akkervogels) %>% + select(Naam) %>% + mutate( + opp = st_area(.), + is_sbp = "binnen sbp" + ) + +buiten_sbp <- st_buffer(steekproefkader_finaal, 300) %>% + st_difference(sbp_akkervogels %>% + st_union() %>% + st_combine()) %>% + select(Naam) %>% + mutate( + opp = st_area(.), + is_sbp = "buiten sbp" + ) + +opps <- bind_rows(buiten_sbp, binnen_sbp) %>% + st_drop_geometry() %>% + group_by(Naam, is_sbp) %>% + summarise(opp = sum(opp)) %>% + ungroup() + +opps %>% + mutate( + opp = units::set_units(opp, "ha"), + Naam = "Steekproefkader" + ) %>% + group_by(Naam) %>% + mutate(opp_aandeel = opp / sum(opp)) %>% + units::drop_units() %>% + rename(opp_ha = opp) %>% + relocate(is_sbp, .before = opp_ha) %>% + arrange(Naam, is_sbp) %>% + kable(digits = 2) +``` + +Het oppervlakte aandeel aan SBP's binnen het steekproefkader. +Union van telcirkels: + +```{r} +binnen_sbp <- st_buffer(steekproefkader_finaal, 300) %>% + group_by(Naam) %>% + summarise(.groups = "drop") %>% + st_intersection(sbp_akkervogels) %>% + select(Naam) %>% + mutate( + opp = st_area(.), + is_sbp = "binnen sbp" + ) + +buiten_sbp <- st_buffer(steekproefkader_finaal, 300) %>% + group_by(Naam) %>% + summarise(.groups = "drop") %>% + st_difference(sbp_akkervogels %>% + st_union() %>% + st_combine()) %>% + select(Naam) %>% + mutate( + opp = st_area(.), + is_sbp = "buiten sbp" + ) + +opps <- bind_rows(buiten_sbp, binnen_sbp) %>% + st_drop_geometry() %>% + group_by(Naam, is_sbp) %>% + summarise(opp = sum(opp)) %>% + ungroup() + +opps %>% + mutate( + opp = units::set_units(opp, "ha"), + Naam = "Steekproefkader" + ) %>% + group_by(Naam) %>% + mutate(opp_aandeel = opp / sum(opp)) %>% + units::drop_units() %>% + rename(opp_ha = opp) %>% + relocate(is_sbp, .before = opp_ha) %>% + arrange(Naam, is_sbp) %>% + kable(digits = 2) +``` + +### Overzicht deel van steekproefkader + +```{r} +steekproefkader_finaal_strata <- steekproefkader_finaal %>% + mutate(stratum = ifelse(is_sbp, paste0(openheid_klasse, " binnen sbp"), + paste0(openheid_klasse, " buiten sbp") + )) + +mapview(perimeters_data, + color = "red", alpha.regions = 0, + legend = FALSE +) + + mapview(selectie_openheid_klasses, + col.regions = "red", + legend = FALSE + ) + + mapview(exclusie_osm_landgebruiken, + col.regions = "green", + legend = FALSE + ) + + mapview(paden, legend = FALSE) + + mapview(steekproefkader_finaal_strata, + zcol = "stratum", + layer = "stratum" + ) +``` + +# Trekking steekproef weidestreek + +## Stratificatie steekproef + +Om toch een voldoende grote steekproef te krijgen voor de weidestreek, opteren we om een allocatie te doen evenredig aan de oppervlakte van elk stratum. +Het zal dan niet mogelijk zijn uitspraken te doen over elk stratum apart, maar wel over de landbouwstreek als geheel en bijgevolg een aanvulling van de andere (grote) landbouwstreken om een uitspraak over Vlaanderen te kunnen doen. + +- Stratificatie: + - binnen versus buiten SBP perimeter + - allocatiefactor proportioneel aan aantal potentiële telpunten (\~ stratumoppervlakte) + - OL versus HOL landschap + - allocatiefactor proportioneel aan aantal potentiële telpunten (\~ stratumoppervlakte) +- Gebalanceerde en goed gespreide trekking: + - ruimtelijk (x- en y-coördinaten) + - oppervlakte aandeel beheerovereenkomsten + + + +```{r} +allocatie <- tar_read(allocatie_df, store = targets_store) %>% + mutate(openheid_sbp = paste( + openheid_klasse, + ifelse(is_sbp, + "binnen plan", + "buiten plan" + ) + )) + +allocatie %>% + select(-c(openheid_sbp, targetsize, excess)) %>% + kable(digits = 3) +``` + +## Steekproeftrekking + +We trekken een steekproef volgens de allocatie evenredig aan de oppervlakte van elk stratum. + +```{r trekking} +steekproef <- tar_read(steekproef_final, store = targets_store) %>% + reduce(rbind) %>% + mutate(openheid_sbp = paste( + openheid_klasse, + ifelse(is_sbp, + "binnen plan", + "buiten plan" + ) + )) +``` + +Kaart van de steekproef: + +```{r kaart-steekproef, warning=FALSE} +steekproef[] %>% + st_buffer(dist = 300) %>% + mapview(zcol = "openheid_sbp", layer = "stratum") + + mapview(perimeters_data, color = "red", alpha.regions = 0, legend = FALSE) +``` + +```{r} +balansvergelijking <- steekproefkader_finaal %>% + filter(openheid_klasse %in% c("OL", "HOL")) %>% + mutate(puntenset = "volledig steekproefkader") %>% + mutate(sbp_akkervogels = ifelse(is_sbp, + "binnen sbp", + "buiten sbp")) %>% + bind_rows(steekproef %>% + mutate(puntenset = "steekproef") %>% + mutate(sbp_akkervogels = ifelse(is_sbp, + "binnen sbp", + "buiten sbp"))) %>% + cbind(st_coordinates(.)) %>% + mutate(puntenset = factor(puntenset, levels = c("volledig steekproefkader", "steekproef"))) + +count_df_weidestreek <- balansvergelijking %>% + group_by(puntenset, openheid_klasse, sbp_akkervogels) %>% + summarise(max_openheid = max(openheid_waarde), + max_x = max(X), + max_y = max(Y), + n = n(), + .groups = "drop") +``` + +```{r} +balansvergelijking %>% + ggplot(aes(x = sbp_akkervogels, y = openheid_waarde)) + + geom_boxplot(aes(fill = puntenset)) + + geom_label(data = count_df_weidestreek, + aes(y = max_openheid + 0.01, label = paste("n =", n)), + size = 3, position = position_dodge2(width = 0.75)) + + facet_grid(~ openheid_klasse) + + labs(fill = "Legende") +``` + +```{r} +balansvergelijking %>% + ggplot(aes(x = sbp_akkervogels, y = X)) + + geom_boxplot(aes(fill = puntenset)) + + geom_label(data = count_df_weidestreek, + aes(y = max_x + 2000, label = paste("n =", n)), + size = 3, position = position_dodge2(width = 0.75)) + + facet_grid(~ openheid_klasse) + + labs(fill = "Legende") +``` + +```{r} +balansvergelijking %>% + ggplot(aes(x = sbp_akkervogels, y = Y)) + + geom_boxplot(aes(fill = puntenset)) + + geom_label(data = count_df_weidestreek, + aes(y = max_y + 2000, label = paste("n =", n)), + size = 3, position = position_dodge2(width = 0.75)) + + facet_grid(~ openheid_klasse) + + labs(fill = "Legende") +``` + +We zien dat de steekproef een goede afspiegeling is van de volledige populatie (boxplots voor steekproef en volledig steekproefkader zijn gelijkend). + +# Nabehandeling steekproef + +## Version control steekproef(kader) + +Er zijn verschillende opties voor version control in de `targets` pipeline. +Enkele nuttige links:\ +\ +\ +\ +\ + + +1. Hard coding + - Voeg op einde target toe met argument `TRUE` of `FALSE` om bepaalde bestanden weg te schrijven + - Verander argument naar `TRUE` als je finale steekproef wil runnen en zet daarna eventueel terug naar `FALSE` + - Versiecontrole met git (check .gitignore) +2. Cloud storage + - Amazon of Google + - Account? + - Kosten? + - Lange termijn? + - Vooral voor grote projecten +3. Gittargets + - Kan ook voor specifieke objecten: + - Is het de moeite? Manueel werk --\> waarom niet ineens hard coden? Komt op zelfde neer? + +We kiezen voor optie 1. We gebruiken hiervoor de package [git2rdata](https://ropensci.github.io/git2rdata/). +De package maakt het opslaan van dataframes onder versiebeheer efficiënter en handiger. +Bovendien zijn de data en de metadata in een standaard en open formaat, waardoor ze leesbaar zijn voor andere software. + + +## Overlap met bestaande telpunten + +We vervangen alle telpunten uit de steekproef van de weidestreek door reeds bestaande punten indien ze voor minstens 50 % overlappen en ze tot hetzelfde stratum behoren. +Indien er meerdere bestaande punten overlappen, nemen we het bestaande punt dat het meest overlapt. +Omdat we nu een nieuwe laag van SBP gebruiken, moeten we dit stratum opnieuw berekenen voor de bestaande punten. + +```{r} +ol <- selectie_openheid( + gebied = perimeters_data, + ol_strata = c("OL")) %>% + mutate(openheid_klasse = "OL") + +hol <- selectie_openheid( + gebied = perimeters_data, + ol_strata = c("HOL")) %>% + mutate(openheid_klasse = "HOL") + +ol_hol <- rbind(ol, hol) %>% + select(openheid_klasse) + +# inlezen bestaande punten +oude_cirkels <- read_sf(here( + "data", + "SOVON", + "avimap_601_0_MAS_Vlaanderen_telpunten_xy.shp" +)) %>% + st_transform(crs = 31370) %>% + st_filter(perimeters_data) %>% + mutate(is_sbp = st_intersects(., + st_union(sbp_akkervogels), + sparse = FALSE) %>% + as.logical() + ) %>% + st_join(ol_hol) %>% + rename(definitief_punt = naam) %>% + select(definitief_punt, openheid_klasse, is_sbp) %>% + mutate(sbp = ifelse(is_sbp == TRUE, "binnen", "buiten"), + openheid_sbp = paste(openheid_klasse, sbp, "plan", sep = " ")) + +oude_cirkels_buffer <- oude_cirkels %>% + st_buffer(300) + +# buffer nieuwe punten +steekproef_raw <- tar_read(steekproef_thinned, store = targets_store) %>% + reduce(rbind) %>% + mutate(openheid_sbp = paste( + openheid_klasse, + ifelse(is_sbp, + "binnen plan", + "buiten plan" + ) + )) + +cirkels_weidestreek <- steekproef_raw %>% + st_buffer(300) +``` + +Er zijn geen punten die overlappen voor minstens 50 % en tot hetzelfde stratum behoren. + +```{r} +# welke punten overlappen minstens 50 % +intersect <- st_intersection(oude_cirkels_buffer, cirkels_weidestreek) %>% + mutate(intersect_area = st_area(.) %>% + units::drop_units()) %>% + filter( + intersect_area >= 0.5 * 300 * 300 * pi, # 50 % + openheid_sbp == openheid_sbp.1 + ) %>% # zelfde stratum + select(definitief_punt, pointid, intersect_area) %>% + st_drop_geometry() %>% + group_by(pointid) %>% + filter(intersect_area == max(intersect_area)) %>% + ungroup() + +intersect %>% + mutate(intersect_prop = intersect_area / (300 * 300 * pi)) %>% + kable( + col.names = c("bestaand", "nieuw", "intersect_area", "intersect_prop"), + digits = 2 + ) +``` + +## Output als KML + +We hebben voor deze streek enkel de steekproef, geen reserve punten. + +```{r} +steekproef_out <- steekproef %>% + select(pointid, Naam, openheid_sbp, sample_order, batch, + zichtbaarheid = cvvi, wegtype = value + ) +``` + +```{r} +steekproef_out %>% + st_drop_geometry() %>% + count(openheid_sbp, batch) %>% + kable() +``` + +```{r} +# telpunten +steekproef_out %>% + st_write( + dsn = file.path( + "data", + "processed", + "steekproef_weidestreek_telpunten.geojson" + ), + delete_dsn = TRUE + ) + +steekproef_out %>% + st_transform(crs = 4326) %>% + # KML kan niet overweg met NA waarden + mutate(across( + .cols = -c(geometry), + ~ ifelse(is.na(.), + "", + . + ) + )) %>% + st_write( + dsn = file.path( + "data", + "processed", + "steekproef_weidestreek_telpunten.kml" + ), + delete_dsn = TRUE + ) + +# telcirkels +steekproef_out %>% + st_buffer(dist = 300) %>% + st_write( + dsn = file.path( + "data", + "processed", + "steekproef_weidestreek_telcirkels.geojson" + ), + delete_dsn = TRUE + ) + +steekproef_out %>% + st_buffer(dist = 300) %>% + st_transform(crs = 4326) %>% + # KML kan niet overweg met NA waarden + mutate(across( + .cols = -c(geometry), + ~ ifelse(is.na(.), + "", + . + ) + )) %>% + st_write( + dsn = file.path( + "data", + "processed", + "steekproef_weidestreek_telcirkels.kml" + ), + delete_dsn = TRUE + ) +``` + + +## Manuele controle + +Johannes doet manuele controle van de puntenset. + +Het resultaat wordt als CSV en KML teruggestuurd. Een eerste kolom `beslissing` wordt toegevoegd met de volgende zaken: + +- *behouden*: als punt prima te tellen valt +- *vervangen door reserve*: punt kan niet geteld worden en moet vervangen worden door eerstvolgende punt uit reserveset +- *vervanging*: reservepunt dat dient als vervanging voor geschrapt punt + +Een tweede kolom wordt toegevoegd `vervangen door`. Dit is enkel ingevuld bij een geschrapt punt uit de eerste set met de pointid van het punt waardoor het vervangen word uit de reserve set. + +Uiteindelijk moeten we tot een CSV komen waarbij enkel de punten *behouden* van de eerste batch en *vervanging* van de reserve batch geüpload worden in Avimap (met tellerscode erbij). Overlappen met reeds getelde MAS punten worden niet meegegeven (0 punten). + +```{r, eval=FALSE} +weidestreek_avimap_df <- read_csv(file.path( + "data", + "processed", + "MAS netwerk Vlaanderen- steekproef_weidestreek_telpunten-final.csv" +)) + +weidestreek_avimap_sf <- st_as_sf(weidestreek_avimap_df, + wkt = "WKT", + crs = st_crs(4326) +) %>% + st_zm() %>% + st_transform(31370) %>% + rename("geometry" = WKT) + +weidestreek_avimap_sf %>% + st_write( + dsn = file.path( + "data", + "processed", + "steekproef_weidestreek_avimap.gpkg" + ), + delete_dsn = TRUE + ) + +weidestreek_avimap_sf %>% + st_write( + dsn = file.path( + "data", + "processed", + "steekproef_weidestreek_avimap.geojson" + ), + delete_dsn = TRUE + ) +``` + +Voor reproduceerbaarheid houden we deze onder versiecontrole met de **git2rdata** package. + +```{r, eval=FALSE} +git2rdata::write_vc(weidestreek_avimap_df, + file = file.path( + "data", + "processed", + "steekproef_weidestreek_avimap" + ), + sorting = "pointid" +) +```