From 687c12922bd5d8917a072b07fa56028bfbb758f6 Mon Sep 17 00:00:00 2001 From: h_edelhoff Date: Tue, 18 Aug 2026 22:48:02 +0000 Subject: [PATCH] Dateien nach "/" hochladen --- README_fotofallen_shiny_gui.md | 58 + ...fallen_power_simulation_schalenwild_grid.R | 1363 +++++++++ fotofallen_shiny_gui_app.R | 1316 +++++++++ simulationsstudie_fotofallen_schalenwild.Rmd | 692 +++++ simulationsstudie_fotofallen_schalenwild.html | 2435 +++++++++++++++++ 5 files changed, 5864 insertions(+) create mode 100644 README_fotofallen_shiny_gui.md create mode 100644 fotofallen_power_simulation_schalenwild_grid.R create mode 100644 fotofallen_shiny_gui_app.R create mode 100644 simulationsstudie_fotofallen_schalenwild.Rmd create mode 100644 simulationsstudie_fotofallen_schalenwild.html diff --git a/README_fotofallen_shiny_gui.md b/README_fotofallen_shiny_gui.md new file mode 100644 index 0000000..9cf1d1a --- /dev/null +++ b/README_fotofallen_shiny_gui.md @@ -0,0 +1,58 @@ +# Shiny-GUI für die Fotofallen-Simulationsstudie + +## Start + +```r +install.packages(c("shiny", "sf", "data.table", "ggplot2", "DT")) +shiny::runApp("app.R") +``` + +## Funktionen + +Die GUI erlaubt die Konfiguration von: + +- globalen `CFG`-Parametern, +- Artprofilen für Rehwild, Rotwild und Gamswild, +- Study Area mit generierter Fokusfläche oder eigener Vektordatei, +- Buffer und Landschaftspuffer, +- Grid- oder Zufallsdesign für Fotofallen, +- synthetischer Habitatgewichtung, +- Sample Tracks für jede Wildart, +- exemplarischem Kameradesign. + +## Eigene Fokusfläche + +Unter **Study Area** kann ein GeoPackage, GeoJSON oder Shapefile hochgeladen werden. + +Für ein Shapefile bitte mindestens gemeinsam auswählen: + +- `.shp` +- `.shx` +- `.dbf` +- `.prj` + +Die Fokusfläche wird in das in der GUI angegebene Projektions-CRS transformiert. Für Abstände und Buffer sollte ein metrisches projiziertes CRS verwendet werden. + +## Export + +Über **Speichern** wird eine `.RData`-Datei erzeugt. Sie enthält: + +```r +CFG +AREA +SPECIES +HABITAT +``` + +Später: + +```r +load("simulations_setup_YYYYMMDD.RData") + +str(CFG) +names(AREA) +SPECIES$Rehwild +HABITAT +``` + +Damit die Habitatparameter tatsächlich in der späteren Poweranalyse wirken, muss deren `habitat_weight_function()` die Werte aus `HABITAT` verwenden. Die GUI speichert diese Parameter bewusst separat, damit sie nachvollziehbar und reproduzierbar bleiben. diff --git a/fotofallen_power_simulation_schalenwild_grid.R b/fotofallen_power_simulation_schalenwild_grid.R new file mode 100644 index 0000000..39e260d --- /dev/null +++ b/fotofallen_power_simulation_schalenwild_grid.R @@ -0,0 +1,1363 @@ +# ============================================================================ +# Fotofallen-Poweranalyse fuer Reh-, Rot- und Gamswild +# ---------------------------------------------------------------------------- +# Ziel: +# Ermitteln, mit welcher Anzahl und raeumlichen Verteilung von Kameras eine +# zeitliche Abnahme der Nutzung einer Fokusflaeche gegenueber einem Buffer +# verlaesslich erkannt werden kann. +# +# Methodische Idee (nach Calenge et al. 2026, Appendix S1): +# 1) Bewegungen einzelner Tiere mit raeumlicher Bindung an Streifgebiete +# und Attraktionspunkte simulieren. +# 2) Kameras mit entfernungsabhaengiger Detektion simulieren. +# 3) wiederholte Stichproben-Designs vergleichen. +# 4) Power fuer eine Zeit x Zone-Interaktion bestimmen. +# +# WICHTIG: +# - Die voreingestellten Artparameter sind plausible STARTWERTE, keine +# belastbaren lokalen Schaetzungen. Bitte mit GPS-/Literaturdaten kalibrieren. +# - "Dichte" ist bei nicht individuell erkennbaren Tieren nur unter weiteren +# Annahmen schaetzbar. Das Skript berichtet daher primaer relative +# Detektionsrate (RAI) und optional eine REM-artige Dichtekennzahl. +# ============================================================================ + +# ---- 0. Pakete -------------------------------------------------------------- +required <- c("sf", "data.table", "ggplot2", "MASS", "future", "future.apply") +missing <- required[!vapply(required, requireNamespace, logical(1), quietly = TRUE)] +if (length(missing) > 0) { + stop("Bitte zuerst installieren: install.packages(c(", + paste(sprintf('"%s"', missing), collapse = ", "), "))") +} + +library(sf) +library(data.table) +library(ggplot2) +library(MASS) +library(future) +library(future.apply) + +# Optional fuer robuste Negativ-Binomial-Modelle: +has_glmmTMB <- requireNamespace("glmmTMB", quietly = TRUE) + +set.seed(20260730) + +# ---- 1. Globale Einstellungen ---------------------------------------------- +# CFG <- list( +# crs = 32632, # Beispiel: UTM 32N; an Projektgebiet anpassen +# years = 1:5, +# survey_days = 30, +# fixes_per_day = 48, # 30-min Schritte; fuer feinere Detektion erhoehen +# n_replicates = 200, # fuer finale Analyse eher 500-1000 +# alpha = 0.05, +# target_power = 0.80, +# # Kameradesign: "random" = vorgegebene Anzahl zufaelliger Standorte; +# # "grid" = zufaellig verschobenes/gedrehtes Raster. +# camera_design_mode = "grid", +# camera_numbers = c(12, 20, 30, 40, 60), +# allocations_focus = c(0.35, 0.50, 0.65, 0.80), +# min_camera_spacing_m = 300, +# # Bei Grid-Design bestimmt der Rasterabstand direkt die Kamerazahl. +# # Mehrere Werte koennen in der Poweranalyse verglichen werden. +# grid_spacings_m = c(300, 400, 500, 700), +# grid_random_rotation = TRUE, +# grid_clip_to = "outer", # "outer", "focus" oder "buffer" +# +# focus_radius_m = 1000, +# buffer_width_m = 1500, +# landscape_margin_m = 1800, +# detection_radius_m = 20, +# p_detect_5m = 0.95, +# p_detect_18m = 0.05, +# independence_minutes = 30, +# # relative Aenderung der Nutzung der Fokusflaeche von Jahr 1 bis Jahr 5: +# focus_use_multiplier_end = 0.60, +# # Gesamtpopulation konstant (=0) oder jaehrliche proportionale Aenderung: +# annual_population_change = 0.00, +# # gleiche Kamerastandorte ueber die Jahre erhoehen Vergleichbarkeit: +# permanent_cameras = TRUE +# ) +# +# # ---- 2. Artprofile ---------------------------------------------------------- +# # home_range_ha beeinflusst die Streuung um das Streifgebietszentrum. +# # step_scale_m beeinflusst kurzfristige Bewegung; attraction_strength die +# # Rueckkehr zu Attraktionspunkten. Gamswild kann zusaetzlich durch ein +# # Habitat-/Topographie-Raster gewichtet werden (siehe habitat_weight_function). +# SPECIES <- list( +# Rehwild = list( +# n_animals = 20, +# home_range_ha = 70, +# step_scale_m = 38, +# n_attraction_points = 7, +# attraction_strength = 0.10, +# resting_probability = 0.22, +# speed_km_day = 3.5, +# group_size_mean = 1.3 +# ), +# Rotwild = list( +# n_animals = 40, +# home_range_ha = 300, +# step_scale_m = 105, +# n_attraction_points = 10, +# attraction_strength = 0.055, +# resting_probability = 0.16, +# speed_km_day = 7.0, +# group_size_mean = 3.5 +# ), +# Gamswild = list( +# n_animals = 50, +# home_range_ha = 150, +# step_scale_m = 70, +# n_attraction_points = 8, +# attraction_strength = 0.075, +# resting_probability = 0.18, +# speed_km_day = 5.0, +# group_size_mean = 4.2 +# ) +# ) + +# ---- 3. Untersuchungsraum: Fokusflaeche, Buffer, Landschaft ---------------- +make_study_area <- function(cfg = CFG) { + center <- st_sfc(st_point(c(0, 0)), crs = cfg$crs) + focus <- st_buffer(center, cfg$focus_radius_m) + outer <- st_buffer(focus, cfg$buffer_width_m) + buffer <- st_difference(outer, focus) + landscape <- st_buffer(outer, cfg$landscape_margin_m) + + zones <- st_sf( + zone = c("Fokus", "Buffer"), + geometry = st_sfc(st_geometry(focus)[[1]], st_geometry(buffer)[[1]]), + crs = cfg$crs + ) + list(center = center, focus = focus, buffer = buffer, + outer = outer, landscape = landscape, zones = zones) +} + +#AREA <- make_study_area() + +# ---- 4. Hilfsfunktionen ----------------------------------------------------- +random_points_min_distance <- function(polygon, n, min_dist, max_tries = 5000) { + if (n == 0) return(st_sf(geometry = st_sfc(crs = st_crs(polygon)))) + accepted <- NULL + tries <- 0 + while ((is.null(accepted) || nrow(accepted) < n) && tries < max_tries) { + tries <- tries + 1 + cand <- st_sample(polygon, size = max(5, n), type = "random") + if (length(cand) == 0) next + cand_sf <- st_sf(geometry = cand) + for (i in seq_len(nrow(cand_sf))) { + p <- cand_sf[i, ] + if (is.null(accepted)) { + accepted <- p + } else { + d <- as.numeric(st_distance(p, accepted)) + if (all(d >= min_dist)) accepted <- rbind(accepted, p) + } + if (nrow(accepted) >= n) break + } + } + if (is.null(accepted) || nrow(accepted) < n) { + stop("Kamerazahl/Minimalabstand fuer die Flaeche nicht realisierbar. ", + "Minimalabstand reduzieren oder Flaeche vergroessern.") + } + accepted[seq_len(n), ] +} + +# Regelmaessiges Raster mit zufaelligem Versatz und optional zufaelliger Drehung. +# Der Abstand grid_spacing_m bestimmt die Zahl der Kameras; n_cameras und +# prop_focus werden im Grid-Modus nicht zur Standortwahl verwendet. +make_randomized_grid <- function(area = AREA, grid_spacing_m, cfg = CFG) { + stopifnot(is.numeric(grid_spacing_m), length(grid_spacing_m) == 1, + is.finite(grid_spacing_m), grid_spacing_m > 0) + + target <- switch(cfg$grid_clip_to, + outer = area$outer, + focus = area$focus, + buffer = area$buffer, + stop("cfg$grid_clip_to muss 'outer', 'focus' oder 'buffer' sein.")) + + bb <- st_bbox(target) + # Grosszuegige Ausgangsausdehnung, damit nach Drehung die Zielflaeche abgedeckt ist. + cx <- mean(c(bb["xmin"], bb["xmax"])) + cy <- mean(c(bb["ymin"], bb["ymax"])) + diagonal <- sqrt((bb["xmax"] - bb["xmin"])^2 + + (bb["ymax"] - bb["ymin"])^2) + + # Zufaelliger Rasterursprung innerhalb einer Rasterzelle. + off_x <- runif(1, 0, grid_spacing_m) + off_y <- runif(1, 0, grid_spacing_m) + lim <- as.numeric(diagonal / 2 + 2 * grid_spacing_m) + xs <- seq(cx - lim + off_x, cx + lim, by = grid_spacing_m) + ys <- seq(cy - lim + off_y, cy + lim, by = grid_spacing_m) + xy <- as.matrix(expand.grid(x = xs, y = ys)) + + angle <- if (isTRUE(cfg$grid_random_rotation)) runif(1, 0, pi / 2) else 0 + if (angle != 0) { + centered <- sweep(xy, 2, c(cx, cy), "-") + rot <- matrix(c(cos(angle), -sin(angle), + sin(angle), cos(angle)), nrow = 2, byrow = TRUE) + xy <- centered %*% t(rot) + xy <- sweep(xy, 2, c(cx, cy), "+") + } + + pts <- st_as_sf(data.frame(x = xy[,1], y = xy[,2]), + coords = c("x", "y"), crs = cfg$crs) + pts <- pts[lengths(st_within(pts, target)) > 0, , drop = FALSE] + if (nrow(pts) == 0) stop("Das Raster erzeugt keine Kamerastandorte in der Zielflaeche.") + + pts$zone <- ifelse(lengths(st_within(pts, area$focus)) > 0, + "Fokus", "Buffer") + pts$grid_spacing_m <- grid_spacing_m + pts$grid_angle_deg <- angle * 180 / pi + pts$grid_offset_x_m <- off_x + pts$grid_offset_y_m <- off_y + pts +} + +make_camera_design <- function(n_cameras = NULL, prop_focus = NULL, area = AREA, + cfg = CFG, grid_spacing_m = NULL) { + if (identical(cfg$camera_design_mode, "grid")) { + if (is.null(grid_spacing_m)) { + if (length(cfg$grid_spacings_m) != 1) + stop("Im Einzelaufruf grid_spacing_m angeben oder nur einen Wert in cfg$grid_spacings_m setzen.") + grid_spacing_m <- cfg$grid_spacings_m + } + cams <- make_randomized_grid(area, grid_spacing_m, cfg) + } else if (identical(cfg$camera_design_mode, "random")) { + if (is.null(n_cameras) || is.null(prop_focus)) + stop("Im Random-Modus muessen n_cameras und prop_focus angegeben werden.") + n_focus <- round(n_cameras * prop_focus) + n_buffer <- n_cameras - n_focus + cf <- random_points_min_distance(area$focus, n_focus, cfg$min_camera_spacing_m) + cb <- random_points_min_distance(area$buffer, n_buffer, cfg$min_camera_spacing_m) + cf$zone <- "Fokus"; cb$zone <- "Buffer" + cams <- rbind(cf, cb) + cams$grid_spacing_m <- NA_real_ + cams$grid_angle_deg <- NA_real_ + cams$grid_offset_x_m <- NA_real_ + cams$grid_offset_y_m <- NA_real_ + } else { + stop("cfg$camera_design_mode muss 'random' oder 'grid' sein.") + } + + cams$camera_id <- sprintf("K%03d", seq_len(nrow(cams))) + cams[, c("camera_id", "zone", "grid_spacing_m", "grid_angle_deg", + "grid_offset_x_m", "grid_offset_y_m", "geometry")] +} + +home_range_sd <- function(home_range_ha) { + # Kreisflaeche A = pi*r^2; ca. 95%-Radius ~ 2.45*SD bei isotroper Normalverteilung + radius <- sqrt(home_range_ha * 10000 / pi) + radius / 2.45 +} + +focus_multiplier_by_year <- function(year, cfg = CFG) { + # geometrische Interpolation; Jahr 1 = 1, letztes Jahr = Endmultiplikator + n <- length(cfg$years) + cfg$focus_use_multiplier_end ^ ((year - min(cfg$years)) / max(1, n - 1)) +} + +population_multiplier_by_year <- function(year, cfg = CFG) { + (1 + cfg$annual_population_change) ^ (year - min(cfg$years)) +} + +# Gamswild-Anpassung: hier koennen Hangneigung, Hoehe, Exposition, Felsanteil etc. +# aus Rasterdaten eingebaut werden. Ohne externe Raster wird ein synthetischer +# alpiner Gradientenfaktor verwendet. Rueckgabewert muss zwischen 0 und 1 liegen. +habitat_weight_function <- function(x, y, species) { + if (species != "Gamswild") return(rep(1, length(x))) + ridge <- exp(-((y - 0.35 * x - 500)^2) / (2 * 850^2)) + rugged <- 0.55 + 0.45 * (sin(x / 230) * cos(y / 270) + 1) / 2 + pmin(1, pmax(0.05, ridge * rugged)) +} + +sample_centers <- function(n, species, year, area = AREA, cfg = CFG) { + # Ablehnungssampling: Nutzung der Fokusflaeche kann im Zeitverlauf sinken. + pts <- vector("list", n) + focus_mult <- focus_multiplier_by_year(year, cfg) + i <- 1; tries <- 0 + while (i <= n && tries < 100000) { + tries <- tries + 1 + cand <- st_sample(area$outer, 1) + xy <- st_coordinates(cand) + inside_focus <- lengths(st_intersects(cand, area$focus)) > 0 + w_zone <- ifelse(inside_focus, focus_mult, 1) + w_hab <- habitat_weight_function(xy[,1], xy[,2], species) + if (runif(1) < w_zone * w_hab) { + pts[[i]] <- cand[[1]] + i <- i + 1 + } + } + if (i <= n) stop("Zu wenige Streifgebietszentren akzeptiert.") + st_sf(animal_id = sprintf("A%04d", seq_len(n)), + geometry = st_sfc(pts, crs = cfg$crs)) +} + +simulate_tracks <- function(species, year, pars, area = AREA, cfg = CFG) { + n <- max(1, round(pars$n_animals * population_multiplier_by_year(year, cfg))) + centers <- sample_centers(n, species, year, area, cfg) + center_xy <- st_coordinates(centers) + hr_sd <- home_range_sd(pars$home_range_ha) + n_steps <- cfg$survey_days * cfg$fixes_per_day + dt_hours <- 24 / cfg$fixes_per_day + + out <- vector("list", n) + for (a in seq_len(n)) { + # Attraktionspunkte innerhalb des Streifgebietes + att <- cbind( + rnorm(pars$n_attraction_points, center_xy[a,1], hr_sd), + rnorm(pars$n_attraction_points, center_xy[a,2], hr_sd) + ) + pos <- matrix(NA_real_, n_steps, 2) + pos[1, ] <- center_xy[a, ] + target <- sample.int(nrow(att), 1) + active <- rep(TRUE, n_steps) + + for (t in 2:n_steps) { + if (runif(1) < 0.025) target <- sample.int(nrow(att), 1) + active[t] <- runif(1) > pars$resting_probability + if (!active[t]) { + pos[t, ] <- pos[t-1, ] + } else { + pull_att <- pars$attraction_strength * (att[target, ] - pos[t-1, ]) + pull_ctr <- 0.012 * (center_xy[a, ] - pos[t-1, ]) + eps <- rnorm(2, 0, pars$step_scale_m) + proposed <- pos[t-1, ] + pull_att + pull_ctr + eps + + # Bei Gamswild: ungeeignete Punkte werden haeufig verworfen. + hw <- habitat_weight_function(proposed[1], proposed[2], species) + if (runif(1) > hw) proposed <- pos[t-1, ] + 0.35 * eps + pull_ctr + pos[t, ] <- proposed + } + } + + out[[a]] <- data.table( + species = species, year = year, + animal_id = centers$animal_id[a], + step = seq_len(n_steps), + time_hours = (seq_len(n_steps) - 1) * dt_hours, + x = pos[,1], y = pos[,2], active = active + ) + } + rbindlist(out) +} + +# Kalibrierung der Distanz-Detektionsfunktion analog zum Tutorial: +detection_coefficients <- function(p1, d1, p2, d2) { + beta_d <- (log(-log(1-p1)) - log(-log(1-p2))) / (d1-d2) + beta_0 <- log(-log(1-p2)) - beta_d*d2 + c(beta0 = beta_0, beta_d = beta_d) +} + +# simulate_detections <- function(tracks, cameras, cfg = CFG) { +# cam_xy <- st_coordinates(cameras) +# beta <- detection_coefficients(cfg$p_detect_5m, 5, +# cfg$p_detect_18m, 18) +# tr <- copy(tracks) +# # Pro Kamerapunkt nur Positionen innerhalb des Maximalradius pruefen. +# detections <- vector("list", nrow(cameras)) +# for (k in seq_len(nrow(cameras))) { +# dx <- tr$x - cam_xy[k,1] +# dy <- tr$y - cam_xy[k,2] +# d <- sqrt(dx^2 + dy^2) +# idx <- which(d <= cfg$detection_radius_m & tr$active) +# if (length(idx) == 0) next +# hazard <- exp(beta["beta0"] + beta["beta_d"] * d[idx]) +# p <- 1 - exp(-hazard) +# hit <- runif(length(idx)) < p +# idx <- idx[hit] +# if (length(idx) == 0) next +# detections[[k]] <- tr[idx, .( +# species, year, animal_id, step, time_hours +# )][, `:=`( +# camera_id = cameras$camera_id[k], +# zone = cameras$zone[k] +# )] +# } +# det <- rbindlist(detections, fill = TRUE) +# if (nrow(det) == 0) return(det) +# +# # Unabhaengige Ereignisse je Tier x Kamera mit Mindestabstand +# gap_steps <- max(1, ceiling(cfg$independence_minutes / 60 * cfg$fixes_per_day / 24)) +# setorder(det, camera_id, animal_id, step) +# det[, new_event := is.na(shift(step)) | (step - shift(step) > gap_steps), +# by = .(camera_id, animal_id, year)] +# det <- det[new_event == TRUE] +# +# det[, new_event := NULL] +# +# } + +simulate_detections <- function(tracks, cameras, cfg = CFG, verbose = TRUE) { + + stopifnot( + all(c("x", "y", "active", "species", "year", + "animal_id", "step", "time_hours") %in% names(tracks)), + inherits(cameras, "sf"), + nrow(cameras) > 0 + ) + + cam_xy <- sf::st_coordinates(cameras) + + beta <- detection_coefficients( + p1 = cfg$p_detect_5m, + d1 = 5, + p2 = cfg$p_detect_18m, + d2 = 18 + ) + + tr <- data.table::as.data.table(data.table::copy(tracks)) + + # Immer einen definierten Datentyp zurückgeben + empty_result <- data.table::data.table( + species = character(), + year = integer(), + animal_id = character(), + step = integer(), + time_hours = numeric(), + camera_id = character(), + zone = character(), + distance_m = numeric(), + p_detect = numeric() + ) + + if (nrow(tr) == 0) { + if (verbose) message("Keine Bewegungspositionen vorhanden.") + return(empty_result) + } + + detections <- vector("list", nrow(cameras)) + + n_positions_in_radius <- 0L + n_stochastic_hits <- 0L + + for (k in seq_len(nrow(cameras))) { + + dx <- tr$x - cam_xy[k, 1] + dy <- tr$y - cam_xy[k, 2] + distance_m <- sqrt(dx^2 + dy^2) + + # isTRUE funktioniert hier nicht, da active ein Vektor ist + active_idx <- !is.na(tr$active) & tr$active == TRUE + + idx <- which( + distance_m <= cfg$detection_radius_m & + active_idx + ) + + if (length(idx) == 0L) { + next + } + + n_positions_in_radius <- n_positions_in_radius + length(idx) + + hazard <- exp( + beta["beta0"] + + beta["beta_d"] * distance_m[idx] + ) + + p_detect <- 1 - exp(-hazard) + p_detect <- pmin(pmax(p_detect, 0), 1) + + detected <- stats::runif(length(idx)) < p_detect + + idx_detected <- idx[detected] + + if (length(idx_detected) == 0L) { + next + } + + n_stochastic_hits <- n_stochastic_hits + length(idx_detected) + + detections[[k]] <- tr[idx_detected, .( + species, + year, + animal_id, + step, + time_hours, + distance_m = distance_m[idx_detected], + p_detect = p_detect[detected] + )][, `:=`( + camera_id = as.character(cameras$camera_id[k]), + zone = as.character(cameras$zone[k]) + )] + } + + detections <- Filter(Negate(is.null), detections) + + if (length(detections) == 0L) { + if (verbose) { + message( + "Keine Detektionen erzeugt. ", + "Aktive Positionen im Detektionsradius: ", + n_positions_in_radius, + "; stochastische Treffer: 0." + ) + } + + return(empty_result) + } + + det <- data.table::rbindlist( + detections, + use.names = TRUE, + fill = TRUE + ) + + # Zeitabstand der simulierten Positionen in Minuten + fix_interval_minutes <- 24 * 60 / cfg$fixes_per_day + + gap_steps <- max( + 1L, + ceiling( + cfg$independence_minutes / + fix_interval_minutes + ) + ) + + data.table::setorder( + det, + camera_id, + animal_id, + year, + step + ) + + det[, previous_step := data.table::shift(step), + by = .(camera_id, animal_id, year)] + + det[, new_event := + is.na(previous_step) | + step - previous_step > gap_steps] + + det <- det[new_event == TRUE] + + det[, c("previous_step", "new_event") := NULL] + + if (verbose) { + message( + "Detektionssimulation abgeschlossen: ", + n_positions_in_radius, + " aktive Positionen im Radius, ", + n_stochastic_hits, + " einzelne Treffer und ", + nrow(det), + " unabhängige Ereignisse." + ) + } + + det[] +} + +# summarise_camera_counts <- function(det, cameras, year, species, cfg = CFG) { +# base <- data.table( +# camera_id = cameras$camera_id, +# zone = cameras$zone, +# year = year, +# species = species, +# effort_days = cfg$survey_days +# ) +# if (nrow(det) == 0) { +# base[, events := 0L] +# } else { +# cnt <- det[, .(events = .N), by = .(camera_id, zone, year, species)] +# base <- merge(base, cnt, by = c("camera_id", "zone", "year", "species"), +# all.x = TRUE) +# base[is.na(events), events := 0L] +# } +# base[, RAI_100_days := 100 * events / effort_days] +# base +# } + +summarise_camera_counts <- function( + det, + cameras, + year, + species, + cfg = CFG, + verbose = TRUE +) { + + # Eingaben prüfen + if (!inherits(cameras, "sf")) { + stop("'cameras' muss ein sf-Objekt sein.") + } + + if (nrow(cameras) == 0L) { + stop("'cameras' enthält keine Kamerastandorte.") + } + + required_camera_columns <- c("camera_id", "zone") + missing_camera_columns <- setdiff( + required_camera_columns, + names(cameras) + ) + + if (length(missing_camera_columns) > 0L) { + stop( + "In 'cameras' fehlen folgende Spalten: ", + paste(missing_camera_columns, collapse = ", ") + ) + } + + # Geometrie entfernen und Datentypen vereinheitlichen + camera_data <- data.table::as.data.table( + sf::st_drop_geometry(cameras) + ) + + base <- camera_data[, .( + camera_id = as.character(camera_id), + zone = as.character(zone) + )] + + # Doppelte Kamera-IDs verhindern + if (anyDuplicated(base$camera_id)) { + stop("Die Spalte 'camera_id' enthält doppelte Werte.") + } + + base[, `:=`( + year = as.integer(year), + species = as.character(species), + effort_days = as.numeric(cfg$survey_days), + events = 0L + )] + + # NULL oder vollständig leere Detektionstabelle behandeln + if (!is.null(det) && NROW(det) > 0L) { + + det_dt <- data.table::as.data.table( + data.table::copy(det) + ) + + required_detection_columns <- c( + "camera_id", + "zone", + "year", + "species" + ) + + missing_detection_columns <- setdiff( + required_detection_columns, + names(det_dt) + ) + + if (length(missing_detection_columns) > 0L) { + stop( + "In 'det' fehlen folgende Spalten: ", + paste(missing_detection_columns, collapse = ", ") + ) + } + + # Einheitliche Datentypen sind wichtig für den Join + det_dt[, `:=`( + camera_id = as.character(camera_id), + zone = as.character(zone), + year = as.integer(year), + species = as.character(species) + )] + + counts <- det_dt[ + , + .(events = .N), + by = .(camera_id, zone, year, species) + ] + + # Update-Join: vorhandene Nullen werden durch Ereigniszahlen ersetzt + base[ + counts, + on = .(camera_id, zone, year, species), + events := i.events + ] + } + + base[, RAI_100_days := data.table::fifelse( + effort_days > 0, + 100 * events / effort_days, + NA_real_ + )] + + data.table::setorder(base, zone, camera_id) + + if (verbose) { + message( + "Zusammenfassung erstellt: ", + nrow(base), " Kameras, ", + sum(base$events), " Ereignisse, Jahr ", + year, ", Art ", species, "." + ) + } + + return(base[]) +} + +# ---- 5. Statistischer Test: nimmt Fokus relativ zum Buffer ab? -------------- +fit_change_test <- function(camera_counts) { + dat <- copy(camera_counts) + dat[, year_c := year - min(year)] + dat[, zone := factor(zone, levels = c("Buffer", "Fokus"))] + + # Zielparameter: year_c:zoneFokus < 0 + if (has_glmmTMB) { + fit <- try(glmmTMB::glmmTMB( + events ~ year_c * zone + offset(log(effort_days)) + (1 | camera_id), + family = glmmTMB::nbinom2(), data = dat + ), silent = TRUE) + if (!inherits(fit, "try-error")) { + sm <- summary(fit)$coefficients$cond + term <- "year_c:zoneFokus" + if (term %in% rownames(sm)) { + est <- sm[term, "Estimate"] + p_two <- sm[term, "Pr(>|z|)"] + p_one <- if (est < 0) p_two / 2 else 1 - p_two / 2 + return(list(estimate = est, p_one_sided = p_one, + detected = is.finite(p_one) && p_one < CFG$alpha && est < 0, + method = "NB-GLMM")) + } + } + } + + # Robuster Fallback: NB-GLM mit Kamera als fixer Effekt + fit <- try(MASS::glm.nb( + events ~ year_c * zone + factor(camera_id) + offset(log(effort_days)), + data = dat + ), silent = TRUE) + if (inherits(fit, "try-error")) { + return(list(estimate = NA_real_, p_one_sided = NA_real_, + detected = FALSE, method = "failed")) + } + sm <- coef(summary(fit)); term <- "year_c:zoneFokus" + if (!term %in% rownames(sm)) { + return(list(estimate = NA_real_, p_one_sided = NA_real_, + detected = FALSE, method = "term missing")) + } + est <- sm[term, "Estimate"] + p_two <- sm[term, "Pr(>|z|)"] + p_one <- if (est < 0) p_two / 2 else 1 - p_two / 2 + list(estimate = est, p_one_sided = p_one, + detected = is.finite(p_one) && p_one < CFG$alpha && est < 0, + method = "NB-GLM") +} + +# Einfache REM-artige Kennzahl; nur als Sensitivitaetsanalyse verwenden. +# D proportional zu Ereignisrate / (Geschwindigkeit * Detektionsbreite). +rem_density_index <- function(camera_counts, species_pars, cfg = CFG) { + effective_width_km <- 2 * cfg$detection_radius_m / 1000 + camera_counts[, density_index := + (events / effort_days) / + pmax(1e-9, species_pars$speed_km_day * effective_width_km)] + camera_counts +} + +# `%||%` <- function(x, y) { +# if (!is.null(x)) x else y +# } + + +`%||%` <- function(x, y) { + if (is.null(x) || length(x) == 0L) y else x +} +# ---- 6. Eine Simulationswiederholung --------------------------------------- +run_one_replicate <- function(species, pars, n_cameras = NA_integer_, + prop_focus = NA_real_, grid_spacing_m = NA_real_, + replicate_id, cfg = CFG) { + make_cams <- function() make_camera_design( + n_cameras = n_cameras, prop_focus = prop_focus, area = AREA, cfg = cfg, + grid_spacing_m = if (is.finite(grid_spacing_m)) grid_spacing_m else NULL + ) + cams_fixed <- if (cfg$permanent_cameras) make_cams() else NULL + + yearly <- vector("list", length(cfg$years)) + for (j in seq_along(cfg$years)) { + yr <- cfg$years[j] + cams <- if (cfg$permanent_cameras) cams_fixed else make_cams() + tracks <- simulate_tracks(species, yr, pars, AREA, cfg) + det <- simulate_detections(tracks, cams, cfg) + yearly[[j]] <- summarise_camera_counts(det, cams, yr, species, cfg) + } + counts <- rbindlist(yearly) + counts <- rem_density_index(counts, pars, cfg) + tst <- fit_change_test(counts) + + data.table( + species = species, + replicate = replicate_id, + n_cameras = nrow(cams_fixed %||% cams), + prop_focus = mean((cams_fixed %||% cams)$zone == "Fokus"), + grid_spacing_m = if (identical(cfg$camera_design_mode, "grid")) grid_spacing_m else NA_real_, + estimate_interaction = tst$estimate, + p_one_sided = tst$p_one_sided, + detected_decline = tst$detected, + method = tst$method, + mean_events = mean(counts$events), + zero_fraction = mean(counts$events == 0) + ) +} + +# ---- 7. Vollstaendige Poweranalyse ----------------------------------------- +run_power_analysis <- function(species_names = names(SPECIES), cfg = CFG) { + if (identical(cfg$camera_design_mode, "grid")) { + design <- CJ( + species = species_names, + grid_spacing_m = cfg$grid_spacings_m, + replicate = seq_len(cfg$n_replicates), + unique = TRUE + ) + design[, `:=`(n_cameras = NA_integer_, prop_focus = NA_real_)] + } else { + design <- CJ( + species = species_names, + n_cameras = cfg$camera_numbers, + prop_focus = cfg$allocations_focus, + replicate = seq_len(cfg$n_replicates), + unique = TRUE + ) + design[, grid_spacing_m := NA_real_] + } + results <- vector("list", nrow(design)) + + for (i in seq_len(nrow(design))) { + d <- design[i] + if (identical(cfg$camera_design_mode, "grid")) { + message(sprintf("%d/%d: %s, Grid %.0f m, Rep %d", + i, nrow(design), d$species, d$grid_spacing_m, d$replicate)) + } else { + message(sprintf("%d/%d: %s, %d Kameras, %.0f%% Fokus, Rep %d", + i, nrow(design), d$species, d$n_cameras, + 100*d$prop_focus, d$replicate)) + } + results[[i]] <- tryCatch( + run_one_replicate(d$species, SPECIES[[d$species]], + n_cameras = d$n_cameras, prop_focus = d$prop_focus, + grid_spacing_m = d$grid_spacing_m, + replicate_id = d$replicate, cfg = cfg), + error = function(e) data.table( + species=d$species, replicate=d$replicate, + n_cameras=d$n_cameras, prop_focus=d$prop_focus, + grid_spacing_m=d$grid_spacing_m, + estimate_interaction=NA_real_, p_one_sided=NA_real_, + detected_decline=FALSE, method=paste("ERROR:", e$message), + mean_events=NA_real_, zero_fraction=NA_real_ + ) + ) + } + raw <- rbindlist(results, fill = TRUE) + if (identical(cfg$camera_design_mode, "grid")) { + summary <- raw[, .( + power = mean(detected_decline, na.rm = TRUE), + valid_runs = sum(is.finite(p_one_sided)), + mean_effect = mean(estimate_interaction, na.rm = TRUE), + n_cameras = mean(n_cameras, na.rm = TRUE), + n_cameras_min = min(n_cameras, na.rm = TRUE), + n_cameras_max = max(n_cameras, na.rm = TRUE), + prop_focus = mean(prop_focus, na.rm = TRUE), + median_events_per_camera_year = median(mean_events, na.rm = TRUE), + mean_zero_fraction = mean(zero_fraction, na.rm = TRUE) + ), by = .(species, grid_spacing_m)] + } else { + summary <- raw[, .( + power = mean(detected_decline, na.rm = TRUE), + valid_runs = sum(is.finite(p_one_sided)), + mean_effect = mean(estimate_interaction, na.rm = TRUE), + median_events_per_camera_year = median(mean_events, na.rm = TRUE), + mean_zero_fraction = mean(zero_fraction, na.rm = TRUE) + ), by = .(species, n_cameras, prop_focus)] + summary[, grid_spacing_m := NA_real_] + } + summary[, reaches_target := power >= cfg$target_power] + list(raw = raw, summary = summary) +} + + +# Run Power Analysis in Parallel ------------------------------------------ + +run_power_analysis_parallel <- function( + species_names = names(SPECIES), + cfg = CFG, + species_profiles = SPECIES, + n_cores = max(1, parallel::detectCores() - 1), + seed = 777 +) { + + requireNamespace("future", quietly = TRUE) + requireNamespace("future.apply", quietly = TRUE) + requireNamespace("data.table", quietly = TRUE) + + future::plan( + future::multisession, + workers = n_cores + ) + + on.exit( + future::plan(future::sequential), + add = TRUE + ) + + # ------------------------------------------------------------ + # Szenarien definieren + # ------------------------------------------------------------ + + if (cfg$camera_design_mode == "grid") { + + scenarios <- expand.grid( + species = species_names, + grid_spacing_m = cfg$grid_spacings_m, + stringsAsFactors = FALSE + ) + + } else { + + scenarios <- expand.grid( + species = species_names, + n_cameras = cfg$camera_numbers, + prop_focus = cfg$allocations_focus, + stringsAsFactors = FALSE + ) + } + + all_results <- vector( + "list", + nrow(scenarios) + ) + + # ------------------------------------------------------------ + # Szenarien + # ------------------------------------------------------------ + + for (s in seq_len(nrow(scenarios))) { + + species <- scenarios$species[s] + + if (cfg$camera_design_mode == "grid") { + + grid_spacing_m <- scenarios$grid_spacing_m[s] + + message( + "Szenario ", + s, "/", nrow(scenarios), + ": ", + species, + " | Grid ", + grid_spacing_m, + " m" + ) + + } else { + + n_cameras <- scenarios$n_cameras[s] + prop_focus <- scenarios$prop_focus[s] + + message( + "Szenario ", + s, "/", nrow(scenarios), + ": ", + species, + " | ", + n_cameras, + " Kameras | Fokusanteil ", + prop_focus + ) + } + + # ---------------------------------------------------------- + # Replikate parallel ausführen + # ---------------------------------------------------------- + + reps <- future.apply::future_lapply( + + seq_len(cfg$n_replicates), + + function(rep_id) { + + tryCatch({ + + if (cfg$camera_design_mode == "grid") { + + res <- run_one_replicate( + species = species, + pars = species_profiles[[species]], + grid_spacing_m = grid_spacing_m, + replicate_id = rep_id, + cfg = cfg + ) + + } else { + + res <- run_one_replicate( + species = species, + pars = species_profiles[[species]], + n_cameras = n_cameras, + allocation_focus = prop_focus, + replicate_id = rep_id, + cfg = cfg + ) + } + + res <- data.table::as.data.table(res) + + # Erfolgreicher Lauf + res[, `:=`( + error = FALSE, + error_message = NA_character_ + )] + + res + + }, error = function(e) { + + # Fehlgeschlagener Lauf erhält exakt dieselbe Struktur + data.table::data.table( + + species = species, + + replicate = rep_id, + + n_cameras = + if (cfg$camera_design_mode == "random") + as.numeric(n_cameras) + else + NA_real_, + + prop_focus = + if (cfg$camera_design_mode == "random") + as.numeric(prop_focus) + else + NA_real_, + + grid_spacing_m = + if (cfg$camera_design_mode == "grid") + as.numeric(grid_spacing_m) + else + NA_real_, + + estimate_interaction = NA_real_, + + p_one_sided = NA_real_, + + detected_decline = NA, + + method = NA_character_, + + mean_events = NA_real_, + + zero_fraction = NA_real_, + + error = TRUE, + + error_message = conditionMessage(e) + ) + }) + + }, + + future.seed = seed + s + ) + + all_results[[s]] <- data.table::rbindlist( + reps, + use.names = TRUE, + fill = TRUE + ) + } + + # ------------------------------------------------------------ + # Alle Ergebnisse zusammenführen + # ------------------------------------------------------------ + + raw <- data.table::rbindlist( + all_results, + use.names = TRUE, + fill = TRUE + ) + + # Sicherheitsnetz + if (!"error" %in% names(raw)) { + raw[, error := FALSE] + } + + if (!"error_message" %in% names(raw)) { + raw[, error_message := NA_character_] + } + + # ------------------------------------------------------------ + # POWER-ZUSAMMENFASSUNG + # ------------------------------------------------------------ + + if (cfg$camera_design_mode == "grid") { + + summary <- raw[ + , + .( + n_requested = .N, + + n_valid = sum( + !error & + !is.na(detected_decline) + ), + + n_errors = sum(error), + + error_rate = mean(error), + + power = { + z <- detected_decline[ + !error & + !is.na(detected_decline) + ] + + if (!length(z)) { + NA_real_ + } else { + mean(z) + } + }, + + mean_n_cameras = { + z <- n_cameras[!error] + + if (!length(z) || all(is.na(z))) { + NA_real_ + } else { + mean(z, na.rm = TRUE) + } + }, + + min_n_cameras = { + z <- n_cameras[!error] + + if (!length(z) || all(is.na(z))) { + NA_real_ + } else { + min(z, na.rm = TRUE) + } + }, + + max_n_cameras = { + z <- n_cameras[!error] + + if (!length(z) || all(is.na(z))) { + NA_real_ + } else { + max(z, na.rm = TRUE) + } + }, + + mean_prop_focus = { + z <- prop_focus[!error] + + if (!length(z) || all(is.na(z))) { + NA_real_ + } else { + mean(z, na.rm = TRUE) + } + }, + + mean_interaction = { + z <- estimate_interaction[!error] + + if (!length(z) || all(is.na(z))) { + NA_real_ + } else { + mean(z, na.rm = TRUE) + } + }, + + mean_p_one_sided = { + z <- p_one_sided[!error] + + if (!length(z) || all(is.na(z))) { + NA_real_ + } else { + mean(z, na.rm = TRUE) + } + }, + + mean_events = { + z <- mean_events[!error] + + if (!length(z) || all(is.na(z))) { + NA_real_ + } else { + mean(z, na.rm = TRUE) + } + }, + + mean_zero_fraction = { + z <- zero_fraction[!error] + + if (!length(z) || all(is.na(z))) { + NA_real_ + } else { + mean(z, na.rm = TRUE) + } + } + ), + + by = .( + species, + grid_spacing_m + ) + ] + + } else { + + summary <- raw[ + , + .( + n_requested = .N, + + n_valid = sum( + !error & + !is.na(detected_decline) + ), + + n_errors = sum(error), + + error_rate = mean(error), + + power = { + z <- detected_decline[ + !error & + !is.na(detected_decline) + ] + + if (!length(z)) NA_real_ else mean(z) + }, + + mean_interaction = { + z <- estimate_interaction[!error] + + if (!length(z) || all(is.na(z))) { + NA_real_ + } else { + mean(z, na.rm = TRUE) + } + }, + + mean_events = { + z <- mean_events[!error] + + if (!length(z) || all(is.na(z))) { + NA_real_ + } else { + mean(z, na.rm = TRUE) + } + }, + + mean_zero_fraction = { + z <- zero_fraction[!error] + + if (!length(z) || all(is.na(z))) { + NA_real_ + } else { + mean(z, na.rm = TRUE) + } + } + ), + + by = .( + species, + n_cameras, + prop_focus + ) + ] + } + + # ------------------------------------------------------------ + # Fehlertabelle + # ------------------------------------------------------------ + + errors <- raw[ + error == TRUE, + .( + N = .N + ), + by = .( + species, + grid_spacing_m, + error_message + ) + ][order(-N)] + + # ------------------------------------------------------------ + # Rückgabe + # ------------------------------------------------------------ + + list( + raw = raw, + summary = summary, + errors = errors + ) +} + + +# ---- 8. Beispiel / Hauptlauf ----------------------------------------------- +# Zuerst einen kleinen Testlauf starten. Danach n_replicates in CFG erhoehen. +RUN_FULL_ANALYSIS <- FALSE + +if (RUN_FULL_ANALYSIS) { + ans <- run_power_analysis() + fwrite(ans$raw, "power_raw.csv") + fwrite(ans$summary, "power_summary.csv") + + # Auch im Grid-Modus wird gegen die tatsaechlich resultierende Kamerazahl geplottet. + p <- ggplot(ans$summary, + aes(x = n_cameras, y = power, + group = if (identical(CFG$camera_design_mode, "grid")) + factor(grid_spacing_m) else factor(prop_focus), + linetype = if (identical(CFG$camera_design_mode, "grid")) + factor(grid_spacing_m) else factor(prop_focus))) + + geom_line() + geom_point() + + geom_hline(yintercept = CFG$target_power, linetype = 2) + + facet_wrap(~ species) + + scale_y_continuous(limits = c(0,1)) + + labs(x = "Gesamtzahl Kameras", y = "Power", + linetype = if (identical(CFG$camera_design_mode, "grid")) + "Grid-Abstand (m)" else "Anteil Fokus", + title = "Power zur Erkennung einer Abnahme der Fokusflaechennutzung") + + theme_bw() + ggsave("power_sampling_design.png", p, width = 10, height = 6, dpi = 300) + + # Kleinstes Design je Art mit Ziel-Power: + recommendation <- ans$summary[reaches_target == TRUE][ + order(n_cameras, -power), .SD[1], by = species] + print(recommendation) +} + +# ---- 9. Schneller Funktionscheck ------------------------------------------- +# Dieser Block ist absichtlich klein und kann direkt ausgefuehrt werden. +RUN_SMOKE_TEST <- FALSE +if (RUN_SMOKE_TEST) { + cfg_test <- CFG + cfg_test$years <- 1:3 + cfg_test$survey_days <- 5 + cfg_test$fixes_per_day <- 24 + cfg_test$n_replicates <- 2 + cfg_test$camera_design_mode <- "grid" + cfg_test$grid_spacings_m <- 700 + + smoke <- run_one_replicate( + species = "Rehwild", pars = SPECIES$Rehwild, + grid_spacing_m = 700, replicate_id = 1, cfg = cfg_test + ) + print(smoke) +} + +# ---- 10. Empfohlene Kalibrierung mit realen Daten -------------------------- +# A) Streifgebietsgroessen: +# SPECIES[[Art]]$home_range_ha aus GPS-Daten (z.B. AKDE/MCP) setzen. +# B) Bewegung: +# step_scale_m und resting_probability anhand Schrittlaengen/Aktivitaet. +# C) Gamswild: +# habitat_weight_function durch Vorhersagen eines RSF/SSF-Modells mit +# Hoehe, Hangneigung, Exposition, Fels/Wald und Schneelage ersetzen. +# D) Kameras: +# camera_design_mode = "grid" und grid_spacings_m anpassen; jeder Lauf +# verwendet einen zufaelligen Rasterversatz und optional eine Drehung. +# Fuer feste reale Standorte vorhandene/erlaubte Punkte als sf einlesen. +# E) Effektszenarien: +# focus_use_multiplier_end = 0.9, 0.8, 0.7, ... fuer minimale erkennbare +# Abnahme testen; annual_population_change separat variieren. +# F) Interpretation: +# Eine sinkende Detektionsrate kann durch geringere Dichte, geringere +# Nutzung, veraenderte Aktivitaet oder Detektierbarkeit entstehen. Das +# Fokus-vs-Buffer-BACI-aehnliche Design hilft, trennt diese Prozesse aber +# nicht ohne Zusatzdaten vollstaendig. diff --git a/fotofallen_shiny_gui_app.R b/fotofallen_shiny_gui_app.R new file mode 100644 index 0000000..79a0a3f --- /dev/null +++ b/fotofallen_shiny_gui_app.R @@ -0,0 +1,1316 @@ +# ============================================================================= +# Shiny GUI – Konfiguration einer Fotofallen-Simulationsstudie +# Rehwild, Rotwild und Gamswild +# +# Start: +# install.packages(c("shiny","sf","data.table","ggplot2","DT")) +# shiny::runApp("app.R") +# +# Output: +# Download einer .RData-Datei mit den Objekten: +# CFG, AREA, SPECIES, HABITAT +# +# Diese Datei kann später im Poweranalyse-Skript geladen werden: +# load("simulations_setup.RData") +# ============================================================================= + +required <- c("shiny", "sf", "data.table", "ggplot2", "DT") +missing <- required[!vapply(required, requireNamespace, logical(1), quietly = TRUE)] +if (length(missing)) { + stop( + "Bitte zuerst installieren: install.packages(c(", + paste(sprintf('"%s"', missing), collapse = ", "), + "))" + ) +} + +library(shiny) +library(sf) +library(data.table) +library(ggplot2) +library(DT) + +# --------------------------------------------------------------------------- +# Standardwerte +# --------------------------------------------------------------------------- + +default_CFG <- list( + crs = 32632, + years = 1:5, + survey_days = 30, + fixes_per_day = 288, + n_replicates = 500, + alpha = 0.05, + target_power = 0.80, + + camera_design_mode = "grid", + camera_numbers = c(12, 20, 30, 40, 60), + allocations_focus = c(0.35, 0.50, 0.65, 0.80), + min_camera_spacing_m = 250, + + grid_spacings_m = c(250, 350, 500, 700), + grid_random_rotation = TRUE, + grid_clip_to = "outer", + + focus_radius_m = 1000, + buffer_width_m = 1500, + landscape_margin_m = 1800, + + detection_radius_m = 20, + p_detect_5m = 0.95, + p_detect_18m = 0.05, + independence_minutes = 30, + + focus_use_multiplier_end = 0.60, + annual_population_change = 0.00, + permanent_cameras = TRUE +) + +default_SPECIES <- list( + Rehwild = list( + n_animals = 80, + home_range_ha = 70, + step_scale_m = 38, + n_attraction_points = 7, + attraction_strength = 0.10, + resting_probability = 0.22, + speed_km_day = 3.5, + group_size_mean = 1.3 + ), + Rotwild = list( + n_animals = 45, + home_range_ha = 900, + step_scale_m = 105, + n_attraction_points = 10, + attraction_strength = 0.055, + resting_probability = 0.16, + speed_km_day = 7.0, + group_size_mean = 3.5 + ), + Gamswild = list( + n_animals = 55, + home_range_ha = 260, + step_scale_m = 70, + n_attraction_points = 8, + attraction_strength = 0.075, + resting_probability = 0.18, + speed_km_day = 5.0, + group_size_mean = 2.2 + ) +) + +# Parameter der synthetischen Habitatgewichtung. +# Diese Parameter werden ebenfalls gespeichert und können später durch +# Raster-/RSF-/SSF-basierte Habitatmodelle ersetzt werden. +default_HABITAT <- list( + enabled = TRUE, + apply_to = "Gamswild", + ridge_intercept_m = 500, + ridge_slope = 0.35, + ridge_sd_m = 850, + rugged_x_scale_m = 230, + rugged_y_scale_m = 270, + rugged_min = 0.55, + minimum_weight = 0.05 +) + +# --------------------------------------------------------------------------- +# Hilfsfunktionen +# --------------------------------------------------------------------------- + +parse_num_vector <- function(x, integer = FALSE, min_value = -Inf, max_value = Inf) { + x <- trimws(x) + if (!nzchar(x)) return(numeric(0)) + z <- suppressWarnings(as.numeric(unlist(strsplit(gsub(";", ",", x), ",")))) + z <- z[is.finite(z)] + z <- z[z >= min_value & z <= max_value] + if (integer) z <- as.integer(round(z)) + unique(z) +} + +make_area_from_cfg <- function(cfg) { + center <- st_sfc(st_point(c(0, 0)), crs = cfg$crs) + focus <- st_buffer(center, cfg$focus_radius_m) + outer <- st_buffer(focus, cfg$buffer_width_m) + buffer <- st_difference(outer, focus) + landscape <- st_buffer(outer, cfg$landscape_margin_m) + + zones <- st_sf( + zone = c("Fokus", "Buffer"), + geometry = st_sfc(st_geometry(focus)[[1]], st_geometry(buffer)[[1]]), + crs = cfg$crs + ) + + list( + source = "generated", + center = center, + focus = focus, + buffer = buffer, + outer = outer, + landscape = landscape, + zones = zones + ) +} + +read_uploaded_shape <- function(fileinfo, target_crs, layer_mode = "first") { + if (is.null(fileinfo) || nrow(fileinfo) == 0) { + stop("Keine Geodatei ausgewählt.") + } + + tmpdir <- tempfile("shape_upload_") + dir.create(tmpdir, recursive = TRUE) + + for (i in seq_len(nrow(fileinfo))) { + file.copy(fileinfo$datapath[i], + file.path(tmpdir, fileinfo$name[i]), + overwrite = TRUE) + } + + files <- list.files(tmpdir, full.names = TRUE) + shp <- files[grepl("\\.shp$", files, ignore.case = TRUE)] + gpkg <- files[grepl("\\.gpkg$", files, ignore.case = TRUE)] + geojson <- files[grepl("\\.(geojson|json)$", files, ignore.case = TRUE)] + + if (length(gpkg)) { + layers <- st_layers(gpkg[1])$name + layer <- if (layer_mode == "first") layers[1] else layer_mode + x <- st_read(gpkg[1], layer = layer, quiet = TRUE) + } else if (length(shp)) { + x <- st_read(shp[1], quiet = TRUE) + } else if (length(geojson)) { + x <- st_read(geojson[1], quiet = TRUE) + } else { + stop( + "Keine unterstützte Vektordatei gefunden. ", + "Für Shapefiles bitte .shp, .shx, .dbf und ggf. .prj gemeinsam hochladen; ", + "alternativ GeoPackage (.gpkg) oder GeoJSON." + ) + } + + if (nrow(x) < 1) stop("Die Geodatei enthält keine Features.") + x <- st_make_valid(x) + x <- x[!st_is_empty(x), , drop = FALSE] + if (is.na(st_crs(x))) { + stop("Die hochgeladene Geodatei besitzt kein definiertes CRS.") + } + + x <- st_transform(x, target_crs) + geom <- st_union(st_geometry(x)) + focus <- st_sf(geometry = geom) + focus <- st_make_valid(focus) + + focus +} + +make_area_from_focus <- function(focus, cfg) { + focus <- st_transform(focus, cfg$crs) + focus <- st_sf(geometry = st_union(st_geometry(st_make_valid(focus)))) + + outer <- st_buffer(focus, cfg$buffer_width_m) + buffer <- st_difference(outer, focus) + landscape <- st_buffer(outer, cfg$landscape_margin_m) + center <- st_centroid(focus) + + zones <- rbind( + st_sf(zone = "Fokus", geometry = st_geometry(focus)), + st_sf(zone = "Buffer", geometry = st_geometry(buffer)) + ) + + list( + source = "uploaded", + center = center, + focus = focus, + buffer = buffer, + outer = outer, + landscape = landscape, + zones = zones + ) +} + +home_range_sd <- function(home_range_ha) { + radius <- sqrt(home_range_ha * 10000 / pi) + radius / 2.45 +} + +habitat_weight <- function(x, y, species, habitat) { + if (!isTRUE(habitat$enabled) || species != habitat$apply_to) { + return(rep(1, length(x))) + } + + ridge_center <- habitat$ridge_slope * x + habitat$ridge_intercept_m + ridge <- exp(-((y - ridge_center)^2) / (2 * habitat$ridge_sd_m^2)) + + rugged <- habitat$rugged_min + + (1 - habitat$rugged_min) * + (sin(x / habitat$rugged_x_scale_m) * + cos(y / habitat$rugged_y_scale_m) + 1) / 2 + + pmin(1, pmax(habitat$minimum_weight, ridge * rugged)) +} + +sample_point_in_polygon <- function(poly) { + p <- st_sample(poly, 1, type = "random") + if (!length(p)) stop("Kein Punkt in der Fläche erzeugt.") + st_coordinates(p)[1, ] +} + +sample_centers_gui <- function(n, species, year, area, cfg, habitat) { + pts <- vector("list", n) + + n_years <- length(cfg$years) + denom <- max(1, n_years - 1) + focus_mult <- cfg$focus_use_multiplier_end ^ + ((year - min(cfg$years)) / denom) + + i <- 1L + tries <- 0L + + while (i <= n && tries < 100000L) { + tries <- tries + 1L + cand <- st_sample(area$outer, 1) + xy <- st_coordinates(cand)[1, ] + + inside_focus <- lengths(st_intersects(cand, area$focus)) > 0 + w_zone <- if (inside_focus) focus_mult else 1 + w_hab <- habitat_weight(xy[1], xy[2], species, habitat) + + if (runif(1) < w_zone * w_hab) { + pts[[i]] <- cand[[1]] + i <- i + 1L + } + } + + if (i <= n) stop("Zu wenige Streifgebietszentren akzeptiert.") + + st_sf( + animal_id = sprintf("A%04d", seq_len(n)), + geometry = st_sfc(pts, crs = cfg$crs) + ) +} + +simulate_one_track <- function(species, pars, area, cfg, habitat, + days = 3, fixes_per_day = NULL) { + if (is.null(fixes_per_day)) { + fixes_per_day <- min(cfg$fixes_per_day, 288) + } + + center <- sample_centers_gui( + n = 1, + species = species, + year = min(cfg$years), + area = area, + cfg = cfg, + habitat = habitat + ) + + center_xy <- st_coordinates(center)[1, ] + hr_sd <- home_range_sd(pars$home_range_ha) + + att <- cbind( + rnorm(pars$n_attraction_points, center_xy[1], hr_sd), + rnorm(pars$n_attraction_points, center_xy[2], hr_sd) + ) + + n_steps <- max(2L, as.integer(days * fixes_per_day)) + dt_hours <- 24 / fixes_per_day + + pos <- matrix(NA_real_, n_steps, 2) + pos[1, ] <- center_xy + target <- sample.int(nrow(att), 1) + active <- rep(TRUE, n_steps) + + for (t in 2:n_steps) { + if (runif(1) < 0.025) target <- sample.int(nrow(att), 1) + + active[t] <- runif(1) > pars$resting_probability + + if (!active[t]) { + pos[t, ] <- pos[t - 1, ] + } else { + pull_att <- pars$attraction_strength * (att[target, ] - pos[t - 1, ]) + pull_ctr <- 0.012 * (center_xy - pos[t - 1, ]) + eps <- rnorm(2, 0, pars$step_scale_m) + + proposed <- pos[t - 1, ] + pull_att + pull_ctr + eps + hw <- habitat_weight(proposed[1], proposed[2], species, habitat) + + if (runif(1) > hw) { + proposed <- pos[t - 1, ] + 0.35 * eps + pull_ctr + } + + pos[t, ] <- proposed + } + } + + data.table( + species = species, + animal_id = paste0(species, "_sample"), + step = seq_len(n_steps), + time_hours = (seq_len(n_steps) - 1) * dt_hours, + x = pos[, 1], + y = pos[, 2], + active = active + ) +} + +make_randomized_grid <- function(area, spacing_m, cfg) { + target <- switch( + cfg$grid_clip_to, + outer = area$outer, + focus = area$focus, + buffer = area$buffer, + stop("grid_clip_to muss 'outer', 'focus' oder 'buffer' sein.") + ) + + bb <- st_bbox(target) + cx <- mean(c(bb["xmin"], bb["xmax"])) + cy <- mean(c(bb["ymin"], bb["ymax"])) + diagonal <- sqrt( + (bb["xmax"] - bb["xmin"])^2 + + (bb["ymax"] - bb["ymin"])^2 + ) + + off_x <- runif(1, 0, spacing_m) + off_y <- runif(1, 0, spacing_m) + lim <- as.numeric(diagonal / 2 + 2 * spacing_m) + + xs <- seq(cx - lim + off_x, cx + lim, by = spacing_m) + ys <- seq(cy - lim + off_y, cy + lim, by = spacing_m) + xy <- as.matrix(expand.grid(x = xs, y = ys)) + + angle <- if (isTRUE(cfg$grid_random_rotation)) { + runif(1, 0, pi / 2) + } else { + 0 + } + + if (angle != 0) { + centered <- sweep(xy, 2, c(cx, cy), "-") + rot <- matrix( + c(cos(angle), -sin(angle), + sin(angle), cos(angle)), + nrow = 2, + byrow = TRUE + ) + xy <- centered %*% t(rot) + xy <- sweep(xy, 2, c(cx, cy), "+") + } + + pts <- st_as_sf( + data.frame(x = xy[, 1], y = xy[, 2]), + coords = c("x", "y"), + crs = cfg$crs + ) + + pts <- pts[lengths(st_within(pts, target)) > 0, , drop = FALSE] + if (!nrow(pts)) stop("Das Raster erzeugt keine Kamerastandorte.") + + pts$zone <- ifelse( + lengths(st_within(pts, area$focus)) > 0, + "Fokus", + "Buffer" + ) + pts$camera_id <- sprintf("K%03d", seq_len(nrow(pts))) + pts$grid_spacing_m <- spacing_m + pts$grid_angle_deg <- angle * 180 / pi + pts$grid_offset_x_m <- off_x + pts$grid_offset_y_m <- off_y + pts +} + +random_points_min_distance <- function(polygon, n, min_dist, max_tries = 10000) { + if (n <= 0) { + return(st_sf(geometry = st_sfc(crs = st_crs(polygon)))) + } + + accepted <- NULL + tries <- 0L + + while ((is.null(accepted) || nrow(accepted) < n) && tries < max_tries) { + tries <- tries + 1L + cand <- st_sf(geometry = st_sample(polygon, size = max(10, n))) + + if (!nrow(cand)) next + + for (i in seq_len(nrow(cand))) { + p <- cand[i, ] + + if (is.null(accepted)) { + accepted <- p + } else { + d <- as.numeric(st_distance(p, accepted)) + if (all(d >= min_dist)) accepted <- rbind(accepted, p) + } + + if (nrow(accepted) >= n) break + } + } + + if (is.null(accepted) || nrow(accepted) < n) { + stop( + "Kamerazahl und Mindestabstand sind für die Fläche nicht realisierbar." + ) + } + + accepted[seq_len(n), ] +} + +make_camera_design_gui <- function(area, cfg) { + if (cfg$camera_design_mode == "grid") { + spacing <- cfg$grid_spacings_m[1] + return(make_randomized_grid(area, spacing, cfg)) + } + + n_cameras <- cfg$camera_numbers[1] + prop_focus <- cfg$allocations_focus[1] + n_focus <- round(n_cameras * prop_focus) + n_buffer <- n_cameras - n_focus + + cf <- random_points_min_distance( + area$focus, + n_focus, + cfg$min_camera_spacing_m + ) + cb <- random_points_min_distance( + area$buffer, + n_buffer, + cfg$min_camera_spacing_m + ) + + cf$zone <- "Fokus" + cb$zone <- "Buffer" + + cams <- rbind(cf, cb) + cams$camera_id <- sprintf("K%03d", seq_len(nrow(cams))) + cams +} + +area_summary_table <- function(area) { + data.frame( + zone = c("Fokus", "Buffer", "Fokus + Buffer", "Landschaft"), + area_ha = round( + c( + as.numeric(st_area(area$focus)), + as.numeric(st_area(area$buffer)), + as.numeric(st_area(area$outer)), + as.numeric(st_area(area$landscape)) + ) / 10000, + 2 + ) + ) +} + +species_to_df <- function(species) { + rbindlist( + lapply(names(species), function(s) { + as.data.table(c(list(species = s), species[[s]])) + }), + fill = TRUE + ) +} + +# --------------------------------------------------------------------------- +# Benutzeroberfläche +# --------------------------------------------------------------------------- + +ui <- navbarPage( + title = "Fotofallen-Simulationsstudie", + id = "main_tabs", + + tabPanel( + "CFG", + sidebarLayout( + sidebarPanel( + width = 4, + + h4("Zeit und Wiederholungen"), + numericInput("crs", "Projektions-CRS (EPSG)", default_CFG$crs, + min = 1, step = 1), + textInput("years", "Jahre (z.B. 1,2,3,4,5)", "1,2,3,4,5"), + numericInput("survey_days", "Erhebungsdauer je Jahr [Tage]", + default_CFG$survey_days, min = 1, step = 1), + numericInput("fixes_per_day", "Simulierte Positionen pro Tag", + default_CFG$fixes_per_day, min = 1, step = 1), + numericInput("n_replicates", "Monte-Carlo-Wiederholungen", + default_CFG$n_replicates, min = 1, step = 50), + numericInput("alpha", "Signifikanzniveau α", + default_CFG$alpha, min = 0.001, max = 0.5, step = 0.005), + numericInput("target_power", "Ziel-Power", + default_CFG$target_power, min = 0.1, max = 0.999, step = 0.01), + + hr(), + + h4("Kameradesign"), + radioButtons( + "camera_design_mode", + "Design", + choices = c("Zufälliges Grid" = "grid", + "Zufällige Punkte" = "random"), + selected = default_CFG$camera_design_mode + ), + + conditionalPanel( + "input.camera_design_mode == 'grid'", + textInput("grid_spacings_m", + "Grid-Abstände [m], kommasepariert", + paste(default_CFG$grid_spacings_m, collapse = ",")), + checkboxInput("grid_random_rotation", + "Grid zufällig drehen", + default_CFG$grid_random_rotation), + selectInput( + "grid_clip_to", + "Grid begrenzen auf", + choices = c( + "Fokus + Buffer" = "outer", + "nur Fokus" = "focus", + "nur Buffer" = "buffer" + ), + selected = default_CFG$grid_clip_to + ) + ), + + conditionalPanel( + "input.camera_design_mode == 'random'", + textInput("camera_numbers", + "Kamerazahlen, kommasepariert", + paste(default_CFG$camera_numbers, collapse = ",")), + textInput("allocations_focus", + "Anteile Fokus (0–1), kommasepariert", + paste(default_CFG$allocations_focus, collapse = ",")), + numericInput("min_camera_spacing_m", + "Mindestabstand Kameras [m]", + default_CFG$min_camera_spacing_m, + min = 0, step = 10) + ) + ), + + mainPanel( + width = 8, + + fluidRow( + column( + 6, + h4("Detektion"), + numericInput("detection_radius_m", "Detektionsradius [m]", + default_CFG$detection_radius_m, min = 0.1, step = 1), + numericInput("p_detect_5m", "P(Detektion) bei 5 m", + default_CFG$p_detect_5m, min = 0.001, max = 0.999, + step = 0.01), + numericInput("p_detect_18m", "P(Detektion) bei 18 m", + default_CFG$p_detect_18m, min = 0.001, max = 0.999, + step = 0.01), + numericInput("independence_minutes", + "Unabhängigkeitsintervall [min]", + default_CFG$independence_minutes, min = 0, step = 5) + ), + column( + 6, + h4("Trend / Szenario"), + numericInput( + "focus_use_multiplier_end", + "Nutzung Fokus im letzten Jahr (relativ zu Jahr 1)", + default_CFG$focus_use_multiplier_end, + min = 0.01, max = 2, step = 0.05 + ), + numericInput( + "annual_population_change", + "Jährliche Populationsänderung", + default_CFG$annual_population_change, + min = -0.99, max = 1, step = 0.01 + ), + checkboxInput( + "permanent_cameras", + "Kamerastandorte über Jahre konstant", + default_CFG$permanent_cameras + ) + ) + ), + + hr(), + h4("Aktuelle CFG-Vorschau"), + verbatimTextOutput("cfg_preview") + ) + ) + ), + + tabPanel( + "Artprofile", + fluidRow( + column( + 4, + selectInput( + "species_edit", + "Wildart", + choices = names(default_SPECIES), + selected = "Rehwild" + ), + numericInput("sp_n_animals", "Anzahl Tiere", 80, min = 1, step = 1), + numericInput("sp_home_range_ha", "Streifgebiet [ha]", 70, + min = 0.1, step = 10), + numericInput("sp_step_scale_m", "Schritt-Skala [m]", 38, + min = 0.1, step = 1), + numericInput("sp_n_attraction_points", "Attraktionspunkte", 7, + min = 1, step = 1) + ), + column( + 4, + numericInput("sp_attraction_strength", "Attraktionsstärke", 0.10, + min = 0, max = 1, step = 0.005), + numericInput("sp_resting_probability", "Ruhewahrscheinlichkeit", 0.22, + min = 0, max = 0.99, step = 0.01), + numericInput("sp_speed_km_day", "Bewegungsstrecke [km/Tag]", 3.5, + min = 0.01, step = 0.1), + numericInput("sp_group_size_mean", "Mittlere Gruppengröße", 1.3, + min = 1, step = 0.1), + actionButton("save_species", "Artprofil übernehmen", + class = "btn-primary") + ), + column( + 4, + h4("Gespeicherte Artprofile"), + DTOutput("species_table") + ) + ) + ), + + tabPanel( + "Study Area", + sidebarLayout( + sidebarPanel( + width = 4, + + radioButtons( + "area_mode", + "Fokusfläche", + choices = c( + "Künstliche Kreisfläche" = "generated", + "Eigene Vektordatei" = "uploaded" + ), + selected = "generated" + ), + + conditionalPanel( + "input.area_mode == 'generated'", + numericInput("focus_radius_m", "Radius Fokusfläche [m]", + default_CFG$focus_radius_m, min = 10, step = 100) + ), + + conditionalPanel( + "input.area_mode == 'uploaded'", + fileInput( + "focus_shape", + "Fokusfläche hochladen", + multiple = TRUE, + accept = c(".shp", ".shx", ".dbf", ".prj", + ".gpkg", ".geojson", ".json") + ), + helpText( + "Shapefile: .shp, .shx, .dbf und .prj gemeinsam auswählen. ", + "GeoPackage oder GeoJSON kann einzeln geladen werden." + ) + ), + + numericInput("buffer_width_m", "Bufferbreite [m]", + default_CFG$buffer_width_m, min = 0, step = 100), + numericInput("landscape_margin_m", "Zusätzlicher Landschaftspuffer [m]", + default_CFG$landscape_margin_m, min = 0, step = 100), + + actionButton("build_area", "Fläche erstellen / aktualisieren", + class = "btn-primary") + ), + + mainPanel( + width = 8, + plotOutput("area_plot", height = 550), + DTOutput("area_table") + ) + ) + ), + + tabPanel( + "Habitat", + sidebarLayout( + sidebarPanel( + width = 4, + checkboxInput("habitat_enabled", + "Habitatgewichtung aktivieren", + default_HABITAT$enabled), + selectInput( + "habitat_apply_to", + "Habitatgewichtung anwenden auf", + choices = names(default_SPECIES), + selected = default_HABITAT$apply_to + ), + numericInput("ridge_intercept_m", "Ridge: Achsenabschnitt [m]", + default_HABITAT$ridge_intercept_m, step = 50), + numericInput("ridge_slope", "Ridge: Steigung", + default_HABITAT$ridge_slope, step = 0.05), + numericInput("ridge_sd_m", "Ridge: Breite / SD [m]", + default_HABITAT$ridge_sd_m, min = 1, step = 50), + numericInput("rugged_x_scale_m", "Ruggedness: X-Skala [m]", + default_HABITAT$rugged_x_scale_m, min = 1, step = 10), + numericInput("rugged_y_scale_m", "Ruggedness: Y-Skala [m]", + default_HABITAT$rugged_y_scale_m, min = 1, step = 10), + numericInput("rugged_min", "Ruggedness: Mindestfaktor", + default_HABITAT$rugged_min, min = 0, max = 1, step = 0.05), + numericInput("minimum_weight", "Minimales Habitatgewicht", + default_HABITAT$minimum_weight, min = 0.001, max = 1, + step = 0.01) + ), + + mainPanel( + width = 8, + h4("Synthetische Habitatgewichtung"), + p( + "Diese Ansicht dient zur Parametrisierung des Habitatanteils der ", + "Bewegungssimulation. Für reale Anwendungen kann die Funktion später ", + "durch Rasterwerte oder ein RSF/SSF-Modell ersetzt werden." + ), + plotOutput("habitat_plot", height = 550) + ) + ) + ), + + tabPanel( + "Sample Tracks", + fluidRow( + column( + 3, + numericInput("track_days", "Simulierte Tage", 3, min = 1, max = 30), + numericInput("track_fixes_day", "Positionen pro Tag", 96, + min = 4, max = 1440, step = 4), + actionButton("simulate_tracks_btn", + "Sample Tracks für alle Arten simulieren", + class = "btn-primary") + ), + column( + 9, + plotOutput("tracks_plot", height = 650) + ) + ) + ), + + tabPanel( + "Study Design", + sidebarLayout( + sidebarPanel( + width = 3, + p( + "Für die Beispielkarte wird im Grid-Modus der erste angegebene ", + "Rasterabstand verwendet. Im Random-Modus werden die erste ", + "Kamerazahl und der erste Fokusanteil verwendet." + ), + actionButton("design_btn", "Beispiel-Design neu ziehen", + class = "btn-primary") + ), + mainPanel( + width = 9, + plotOutput("design_plot", height = 650), + verbatimTextOutput("design_summary") + ) + ) + ), + + tabPanel( + "Speichern", + fluidRow( + column( + 7, + h3("Setup für die Poweranalyse speichern"), + p( + "Die RData-Datei enthält die vier Objekte ", + code("CFG"), ", ", code("AREA"), ", ", code("SPECIES"), + " und ", code("HABITAT"), "." + ), + downloadButton("download_rdata", "simulations_setup.RData speichern", + class = "btn-primary"), + br(), br(), + h4("Später im Poweranalyse-Skript"), + tags$pre( + 'load("simulations_setup.RData")\n\n', + '# Danach stehen zur Verfügung:\n', + 'str(CFG)\n', + 'names(AREA)\n', + 'SPECIES$Rehwild\n', + 'HABITAT\n\n', + '# Beispiel:\n', + 'ans <- run_power_analysis(species_names = names(SPECIES), cfg = CFG)' + ) + ), + column( + 5, + h4("Validierung"), + verbatimTextOutput("validation") + ) + ) + ) +) + +# --------------------------------------------------------------------------- +# Server +# --------------------------------------------------------------------------- + +server <- function(input, output, session) { + + species_rv <- reactiveVal(default_SPECIES) + area_rv <- reactiveVal(make_area_from_cfg(default_CFG)) + tracks_rv <- reactiveVal(NULL) + design_rv <- reactiveVal(NULL) + + cfg_current <- reactive({ + years <- parse_num_vector(input$years, integer = TRUE) + if (!length(years)) years <- 1:5 + + camera_numbers <- parse_num_vector( + input$camera_numbers, integer = TRUE, min_value = 1 + ) + if (!length(camera_numbers)) camera_numbers <- default_CFG$camera_numbers + + allocations_focus <- parse_num_vector( + input$allocations_focus, min_value = 0, max_value = 1 + ) + if (!length(allocations_focus)) { + allocations_focus <- default_CFG$allocations_focus + } + + grid_spacings <- parse_num_vector( + input$grid_spacings_m, min_value = 0.1 + ) + if (!length(grid_spacings)) grid_spacings <- default_CFG$grid_spacings_m + + list( + crs = as.integer(input$crs), + years = sort(unique(years)), + survey_days = as.integer(input$survey_days), + fixes_per_day = as.integer(input$fixes_per_day), + n_replicates = as.integer(input$n_replicates), + alpha = input$alpha, + target_power = input$target_power, + + camera_design_mode = input$camera_design_mode, + camera_numbers = camera_numbers, + allocations_focus = allocations_focus, + min_camera_spacing_m = input$min_camera_spacing_m, + + grid_spacings_m = grid_spacings, + grid_random_rotation = isTRUE(input$grid_random_rotation), + grid_clip_to = input$grid_clip_to, + + focus_radius_m = input$focus_radius_m, + buffer_width_m = input$buffer_width_m, + landscape_margin_m = input$landscape_margin_m, + + detection_radius_m = input$detection_radius_m, + p_detect_5m = input$p_detect_5m, + p_detect_18m = input$p_detect_18m, + independence_minutes = input$independence_minutes, + + focus_use_multiplier_end = input$focus_use_multiplier_end, + annual_population_change = input$annual_population_change, + permanent_cameras = isTRUE(input$permanent_cameras) + ) + }) + + habitat_current <- reactive({ + list( + enabled = isTRUE(input$habitat_enabled), + apply_to = input$habitat_apply_to, + ridge_intercept_m = input$ridge_intercept_m, + ridge_slope = input$ridge_slope, + ridge_sd_m = input$ridge_sd_m, + rugged_x_scale_m = input$rugged_x_scale_m, + rugged_y_scale_m = input$rugged_y_scale_m, + rugged_min = input$rugged_min, + minimum_weight = input$minimum_weight + ) + }) + + # Artprofil-Felder beim Wechsel aktualisieren + observeEvent(input$species_edit, { + sp <- species_rv()[[input$species_edit]] + + updateNumericInput(session, "sp_n_animals", value = sp$n_animals) + updateNumericInput(session, "sp_home_range_ha", value = sp$home_range_ha) + updateNumericInput(session, "sp_step_scale_m", value = sp$step_scale_m) + updateNumericInput(session, "sp_n_attraction_points", + value = sp$n_attraction_points) + updateNumericInput(session, "sp_attraction_strength", + value = sp$attraction_strength) + updateNumericInput(session, "sp_resting_probability", + value = sp$resting_probability) + updateNumericInput(session, "sp_speed_km_day", value = sp$speed_km_day) + updateNumericInput(session, "sp_group_size_mean", + value = sp$group_size_mean) + }, ignoreInit = FALSE) + + observeEvent(input$save_species, { + req(input$species_edit) + + sp <- species_rv() + + sp[[input$species_edit]] <- list( + n_animals = as.integer(input$sp_n_animals), + home_range_ha = input$sp_home_range_ha, + step_scale_m = input$sp_step_scale_m, + n_attraction_points = as.integer(input$sp_n_attraction_points), + attraction_strength = input$sp_attraction_strength, + resting_probability = input$sp_resting_probability, + speed_km_day = input$sp_speed_km_day, + group_size_mean = input$sp_group_size_mean + ) + + species_rv(sp) + + showNotification( + paste("Artprofil", input$species_edit, "übernommen."), + type = "message" + ) + }) + + output$species_table <- renderDT({ + datatable( + species_to_df(species_rv()), + rownames = FALSE, + options = list(scrollX = TRUE, pageLength = 3, dom = "t") + ) + }) + + # Study Area explizit neu aufbauen + observeEvent(input$build_area, { + cfg <- cfg_current() + + tryCatch({ + if (input$area_mode == "uploaded") { + req(input$focus_shape) + focus <- read_uploaded_shape(input$focus_shape, cfg$crs) + area <- make_area_from_focus(focus, cfg) + } else { + area <- make_area_from_cfg(cfg) + } + + area_rv(area) + design_rv(NULL) + tracks_rv(NULL) + + showNotification( + "Study Area wurde aktualisiert.", + type = "message" + ) + }, error = function(e) { + showNotification(e$message, type = "error", duration = NULL) + }) + }) + + output$area_plot <- renderPlot({ + area <- area_rv() + + ggplot() + + geom_sf( + data = area$landscape, + fill = "grey96", + colour = "grey70", + linewidth = 0.4 + ) + + geom_sf( + data = area$buffer, + fill = "#9ecae1", + alpha = 0.45, + colour = "#3182bd" + ) + + geom_sf( + data = area$focus, + fill = "#fdae6b", + alpha = 0.65, + colour = "#e6550d" + ) + + coord_sf() + + labs( + title = "Aktuelle Study Area", + subtitle = paste( + "Quelle:", + ifelse(area$source == "uploaded", + "hochgeladene Fokusfläche", + "generierte Kreisfläche") + ), + x = NULL, + y = NULL + ) + + theme_bw() + }) + + output$area_table <- renderDT({ + datatable( + area_summary_table(area_rv()), + rownames = FALSE, + options = list(dom = "t") + ) + }) + + # Habitatkarte: rasterisiert nur für die Vorschau + output$habitat_plot <- renderPlot({ + area <- area_rv() + hab <- habitat_current() + + bb <- st_bbox(area$landscape) + nx <- 100 + ny <- 100 + + grid <- expand.grid( + x = seq(bb["xmin"], bb["xmax"], length.out = nx), + y = seq(bb["ymin"], bb["ymax"], length.out = ny) + ) + + pts <- st_as_sf(grid, coords = c("x", "y"), crs = st_crs(area$landscape)) + inside <- lengths(st_within(pts, area$landscape)) > 0 + grid <- grid[inside, , drop = FALSE] + + grid$weight <- habitat_weight( + grid$x, + grid$y, + hab$apply_to, + hab + ) + + ggplot(grid, aes(x = x, y = y, fill = weight)) + + geom_raster() + + geom_sf( + data = area$focus, + inherit.aes = FALSE, + fill = NA, + colour = "white", + linewidth = 0.8 + ) + + geom_sf( + data = area$outer, + inherit.aes = FALSE, + fill = NA, + colour = "black", + linewidth = 0.5 + ) + + coord_sf(crs = st_crs(area$landscape)) + + scale_fill_viridis_c(limits = c(0, 1)) + + labs( + title = paste("Habitatgewichtung:", hab$apply_to), + fill = "Gewicht", + x = NULL, + y = NULL + ) + + theme_bw() + }) + + # Sample Tracks + observeEvent(input$simulate_tracks_btn, { + cfg <- cfg_current() + area <- area_rv() + spp <- species_rv() + hab <- habitat_current() + + withProgress(message = "Sample Tracks werden simuliert ...", value = 0, { + out <- lapply(seq_along(spp), function(i) { + incProgress(1 / length(spp), detail = names(spp)[i]) + + simulate_one_track( + species = names(spp)[i], + pars = spp[[i]], + area = area, + cfg = cfg, + habitat = hab, + days = input$track_days, + fixes_per_day = input$track_fixes_day + ) + }) + + tracks_rv(rbindlist(out)) + }) + }) + + output$tracks_plot <- renderPlot({ + tr <- tracks_rv() + area <- area_rv() + + validate( + need(!is.null(tr), + "Auf „Sample Tracks für alle Arten simulieren“ klicken.") + ) + + ggplot() + + geom_sf( + data = area$outer, + fill = "grey96", + colour = "grey70" + ) + + geom_sf( + data = area$focus, + fill = "#fdae6b", + alpha = 0.30, + colour = "#e6550d" + ) + + geom_path( + data = tr, + aes(x = x, y = y, colour = species), + linewidth = 0.45, + alpha = 0.85 + ) + + geom_point( + data = tr[, .SD[1], by = species], + aes(x = x, y = y, colour = species), + size = 2.5 + ) + + coord_sf(crs = st_crs(area$outer)) + + facet_wrap(~species) + + labs( + title = "Exemplarischer Sample Track je Wildart", + subtitle = "Ein simuliertes Individuum je Art", + colour = "Wildart", + x = NULL, + y = NULL + ) + + theme_bw() + }) + + # Beispiel-Study-Design + make_design <- function() { + cfg <- cfg_current() + area <- area_rv() + + tryCatch( + make_camera_design_gui(area, cfg), + error = function(e) { + showNotification(e$message, type = "error", duration = NULL) + NULL + } + ) + } + + observeEvent(input$design_btn, { + design_rv(make_design()) + }) + + output$design_plot <- renderPlot({ + cams <- design_rv() + area <- area_rv() + + if (is.null(cams)) { + cams <- make_design() + validate(need(!is.null(cams), "Kein Design erzeugt.")) + } + + ggplot() + + geom_sf( + data = area$buffer, + fill = "#9ecae1", + alpha = 0.35, + colour = "#3182bd" + ) + + geom_sf( + data = area$focus, + fill = "#fdae6b", + alpha = 0.50, + colour = "#e6550d" + ) + + geom_sf( + data = cams, + aes(colour = zone), + size = 2.1 + ) + + coord_sf() + + labs( + title = "Exemplarisches Kameradesign", + subtitle = paste(nrow(cams), "Kamerastandorte"), + colour = "Zone", + x = NULL, + y = NULL + ) + + theme_bw() + }) + + output$design_summary <- renderPrint({ + cams <- design_rv() + if (is.null(cams)) { + cat("Noch kein explizit neu gezogenes Design.\n") + return() + } + + cat("Anzahl Kameras:", nrow(cams), "\n") + cat("Fokus:", sum(cams$zone == "Fokus"), "\n") + cat("Buffer:", sum(cams$zone == "Buffer"), "\n") + + if ("grid_spacing_m" %in% names(cams)) { + cat("Grid-Abstand:", unique(cams$grid_spacing_m), "m\n") + cat("Grid-Winkel:", round(unique(cams$grid_angle_deg), 1), "Grad\n") + } + }) + + output$cfg_preview <- renderPrint({ + str(cfg_current(), max.level = 1) + }) + + output$validation <- renderPrint({ + cfg <- cfg_current() + area <- area_rv() + spp <- species_rv() + hab <- habitat_current() + + issues <- character() + + if (cfg$p_detect_18m >= cfg$p_detect_5m) { + issues <- c( + issues, + "WARNUNG: P(Detektion bei 18 m) ist nicht kleiner als bei 5 m." + ) + } + + if (cfg$detection_radius_m < 18) { + issues <- c( + issues, + "Hinweis: Detektionsradius ist kleiner als der Kalibrierpunkt 18 m." + ) + } + + if (cfg$fixes_per_day < 96) { + issues <- c( + issues, + "Hinweis: Wenige Positionen/Tag können kurze Kamerapassagen verpassen." + ) + } + + if (!length(cfg$grid_spacings_m)) { + issues <- c(issues, "FEHLER: Kein Grid-Abstand angegeben.") + } + + if (any(vapply(spp, function(x) x$home_range_ha <= 0, logical(1)))) { + issues <- c(issues, "FEHLER: Streifgebietsgrößen müssen > 0 sein.") + } + + if (isTRUE(hab$enabled) && hab$ridge_sd_m <= 0) { + issues <- c(issues, "FEHLER: Habitat ridge_sd_m muss > 0 sein.") + } + + cat("CRS:", cfg$crs, "\n") + cat("Study-Area-Quelle:", area$source, "\n") + cat("Wildarten:", paste(names(spp), collapse = ", "), "\n") + cat("Design:", cfg$camera_design_mode, "\n") + + if (!length(issues)) { + cat("\nOK: Keine offensichtlichen Parameterkonflikte erkannt.\n") + } else { + cat("\n", paste(issues, collapse = "\n"), "\n", sep = "") + } + }) + + output$download_rdata <- downloadHandler( + filename = function() { + paste0("simulations_setup_", format(Sys.Date(), "%Y%m%d"), ".RData") + }, + content = function(file) { + CFG <- cfg_current() + AREA <- area_rv() + SPECIES <- species_rv() + HABITAT <- habitat_current() + + save(CFG, AREA, SPECIES, HABITAT, file = file, compress = "xz") + } + ) +} + +shinyApp(ui, server) diff --git a/simulationsstudie_fotofallen_schalenwild.Rmd b/simulationsstudie_fotofallen_schalenwild.Rmd new file mode 100644 index 0000000..e828bbd --- /dev/null +++ b/simulationsstudie_fotofallen_schalenwild.Rmd @@ -0,0 +1,692 @@ +--- +title: "Simulationsstudie für ein Fotofallen-Monitoring von Reh-, Rot- und Gamswild" +subtitle: "Planung eines Fokus–Buffer-Designs zur Erkennung zeitlicher Veränderungen der Raumnutzung" +author: "Projektvorlage" +date: "`r format(Sys.Date(), '%d.%m.%Y')`" +output: + html_document: + toc: true + toc_float: true + number_sections: true + theme: readable + code_folding: show +params: + hauptskript: "fotofallen_power_simulation_schalenwild_grid.R" + art: "Rehwild" + grid_abstand_m: 500 + vollstaendig_ausfuehren: false +--- + +```{r setup, include=FALSE} +knitr::opts_chunk$set( + echo = TRUE, + message = FALSE, + warning = FALSE, + fig.width = 8, + fig.height = 5, + dpi = 120 +) +options(stringsAsFactors = FALSE) +``` + +# Ziel der Simulationsstudie + +Die Simulationsstudie untersucht, mit welchem Fotofallen-Design eine zeitliche Abnahme der Nutzung einer **Fokusfläche** zuverlässig erkannt werden kann. Die Fokusfläche wird von einem **Buffer** umgeben. In beiden Zonen werden Fotofallen installiert. + +Die zentrale Frage lautet: + +> Wie viele Fotofallen werden benötigt und wie sollten sie räumlich verteilt sein, damit eine Abnahme der Raumnutzungsintensität in der Fokusfläche gegenüber dem Buffer mit ausreichender statistischer Sicherheit erkannt wird? + +Dabei werden drei Schalenwildarten berücksichtigt: + +- Rehwild, +- Rotwild, +- Gamswild. + +Die Arten unterscheiden sich in der Simulation unter anderem hinsichtlich Streifgebietsgröße, Bewegungsweite, Bindung an Attraktionspunkte, Aktivität und Gruppengröße. + +Die Studie folgt einer prozessbasierten Struktur: + +1. Untersuchungsraum definieren. +2. artspezifische Bewegungen simulieren. +3. Kamerastandorte erzeugen. +4. Tierbewegungen und Kamerastandorte räumlich überlagern. +5. Detektionen simulieren. +6. Detektionsraten je Kamera, Jahr und Zone berechnen. +7. die zeitliche Veränderung in Fokusfläche und Buffer vergleichen. +8. den gesamten Ablauf oft wiederholen und daraus die statistische Power bestimmen. + +# Benötigte Dateien und Pakete + +Das Dokument ist als verständliche Begleitdokumentation zum Hauptskript gedacht. Für eine vollständige Ausführung sollte sich das folgende Skript im selben Arbeitsordner befinden: + +```{r dateipfad} +params$hauptskript +``` + +Benötigte R-Pakete: + +```{r pakete, eval=FALSE} +install.packages(c( + "sf", + "data.table", + "ggplot2", + "MASS", + "knitr", + "rmarkdown" +)) + +# Optional für Negativ-Binomial-Mischmodelle: +install.packages("glmmTMB") +``` + +Das Hauptskript kann mit folgendem Befehl eingelesen werden: + +```{r hauptskript-einlesen, eval=FALSE} +source(params$hauptskript) +``` + +**Hinweis:** Im Hauptskript ist ein kurzer Funktionstest aktiviert. Für die Dokumentation oder einen kontrollierten Lauf kann `RUN_SMOKE_TEST <- FALSE` gesetzt werden. + +# Aufbau des Untersuchungsraums + +## Fokusfläche, Buffer und Landschaft + +Im Beispiel wird die Fokusfläche als Kreis erzeugt. Darum liegt ein ringförmiger Buffer. Eine zusätzliche Landschaftsfläche sorgt dafür, dass auch Streifgebietszentren und Bewegungen außerhalb der beiden eigentlichen Auswertungszonen simuliert werden können. + +Wichtige Parameter: + +```{r raumparameter, eval=FALSE} +CFG$focus_radius_m <- 1000 +CFG$buffer_width_m <- 1500 +CFG$landscape_margin_m <- 1800 +CFG$crs <- 32632 +``` + +Die Bedeutung der Flächen ist: + +| Fläche | Funktion | +|---|---| +| Fokusfläche | Bereich, für den eine abnehmende Nutzung geprüft wird | +| Buffer | räumliche Vergleichszone um die Fokusfläche | +| Landschaft | größerer Simulationsraum für Streifgebiete und Bewegungen | + +Bei realen Projekten sollte die Fokusfläche nicht künstlich als Kreis erzeugt, sondern als vorhandenes Polygon aus einem GeoPackage, Shapefile oder GeoJSON eingelesen werden. + +Beispiel: + +```{r reale-fokusflaeche, eval=FALSE} +library(sf) + +focus <- st_read("input/fokusflaeche.gpkg") +focus <- st_make_valid(focus) +focus <- st_transform(focus, 32632) + +outer <- st_buffer(focus, dist = 1500) +buffer <- st_difference(outer, focus) +landscape <- st_buffer(outer, dist = 1800) +``` + +# Artspezifische Bewegungsökologie + +Die drei Arten werden über getrennte Parameterprofile beschrieben. + +```{r artprofile, eval=FALSE} +SPECIES +``` + +Die wichtigsten Parameter sind: + +| Parameter | Bedeutung | +|---|---| +| `n_animals` | simulierte Zahl der Tiere | +| `home_range_ha` | typische Streifgebietsgröße | +| `step_scale_m` | Größenordnung kurzfristiger Bewegungsschritte | +| `n_attraction_points` | Anzahl bevorzugter Aufenthaltsbereiche | +| `attraction_strength` | Stärke der Rückkehr zu bevorzugten Bereichen | +| `resting_probability` | Wahrscheinlichkeit eines inaktiven Zeitschritts | +| `speed_km_day` | angenommene tägliche Bewegungsstrecke | +| `group_size_mean` | mittlere Gruppengröße | + +Die voreingestellten Werte sind **Startwerte für die Planung**. Sie sollten mit lokalen GPS-Daten, Literaturwerten oder Expertenwissen kalibriert werden. + +## Beispielhafte Unterschiede + +- **Rehwild:** kleinere Streifgebiete und stärkere lokale Bindung. +- **Rotwild:** deutlich größere Streifgebiete und weitere Bewegungen. +- **Gamswild:** mittlere bis große Streifgebiete; zusätzlich kann eine topografische Habitatselektion eingebaut werden. + +Für Gamswild ist im Hauptskript die Funktion `habitat_weight_function()` vorgesehen. Sie kann später beispielsweise mit Höhe, Hangneigung, Exposition, Felsanteil, Walddeckung oder Schneelage erweitert werden. + +```{r gams-habitat, eval=FALSE} +habitat_weight_function <- function(x, y, species) { + if (species != "Gamswild") return(rep(1, length(x))) + + # Platzhalter: + # Später z.B. Vorhersagen eines RSF-/SSF-Modells einsetzen. + rep(1, length(x)) +} +``` + +# Simulation der zeitlichen Veränderung + +Die Studie trennt zwei mögliche Prozesse: + +1. eine Veränderung der gesamten Population, +2. eine zusätzliche Veränderung der Nutzung der Fokusfläche. + +## Veränderung der Fokusflächennutzung + +```{r fokus-veraenderung, eval=FALSE} +CFG$focus_use_multiplier_end <- 0.60 +``` + +Ein Wert von `0.60` bedeutet, dass die relative Nutzung der Fokusfläche im letzten Jahr nur noch 60 % des Ausgangsniveaus beträgt. + +Bei fünf Jahren wird dieser Rückgang schrittweise zwischen Jahr 1 und Jahr 5 umgesetzt. + +## Veränderung der Gesamtpopulation + +```{r populationsveraenderung, eval=FALSE} +CFG$annual_population_change <- 0.00 +``` + +- `0.00`: Gesamtpopulation bleibt konstant. +- `-0.05`: jährliche Abnahme um etwa 5 %. +- `0.03`: jährliche Zunahme um etwa 3 %. + +Die getrennte Parametrisierung ist wichtig: Eine sinkende Detektionsrate in der Fokusfläche kann entweder aus einer lokalen Verlagerung oder aus einer allgemeinen Bestandsabnahme resultieren. + +# Erzeugung der Kamerastandorte + +Das Hauptskript bietet zwei Designs. + +## Zufällige Standorte mit Mindestabstand + +```{r random-design, eval=FALSE} +CFG$camera_design_mode <- "random" +CFG$camera_numbers <- c(12, 20, 30, 40, 60) +CFG$allocations_focus <- c(0.35, 0.50, 0.65, 0.80) +CFG$min_camera_spacing_m <- 250 +``` + +Dabei werden eine feste Kamerazahl und ein gewünschter Anteil in der Fokusfläche vorgegeben. + +## Zufällig verschobenes Raster + +Für die aktuelle Fragestellung ist besonders das Grid-Design relevant: + +```{r grid-design, eval=FALSE} +CFG$camera_design_mode <- "grid" +CFG$grid_spacings_m <- c(250, 350, 500, 700) +CFG$grid_random_rotation <- TRUE +CFG$grid_clip_to <- "outer" +``` + +Der Rasterabstand bestimmt indirekt die Kamerazahl: + +- kleiner Abstand: mehr Kameras, +- großer Abstand: weniger Kameras. + +Das Raster wird in jeder Simulationswiederholung zufällig verschoben. Optional wird es auch zufällig gedreht. Dadurch wird geprüft, ob ein Design robust gegenüber einer zufälligen Lage des Rasters ist. + +Mögliche Begrenzungen: + +```{r grid-clip, eval=FALSE} +CFG$grid_clip_to <- "outer" # Fokusfläche und Buffer +CFG$grid_clip_to <- "focus" # nur Fokusfläche +CFG$grid_clip_to <- "buffer" # nur Buffer +``` + +## Beispielkarte eines Grid-Designs + +Der folgende Block kann ausgeführt werden, nachdem das Hauptskript mit `source()` geladen wurde. + +```{r grid-karte, eval=params$vollstaendig_ausfuehren} +cfg_demo <- CFG +cfg_demo$camera_design_mode <- "grid" +cfg_demo$grid_random_rotation <- TRUE + +cams_demo <- make_camera_design( + area = AREA, + cfg = cfg_demo, + grid_spacing_m = params$grid_abstand_m +) + +ggplot() + + geom_sf(data = AREA$zones, aes(fill = zone), alpha = 0.25) + + geom_sf(data = cams_demo, shape = 21, size = 2.5) + + coord_sf() + + labs( + title = paste("Zufällig verschobenes Kameraraster:", + params$grid_abstand_m, "m"), + subtitle = paste(nrow(cams_demo), "potenzielle Kamerastandorte"), + fill = "Zone" + ) + + theme_bw() +``` + +# Simulation der Tierbewegungen + +Für jedes Jahr werden zunächst Streifgebietszentren erzeugt. Anschließend werden Bewegungsbahnen für alle Tiere simuliert. + +Das Bewegungsmodell enthält: + +- eine Bindung an das Streifgebiet, +- mehrere Attraktionspunkte, +- zufällige Bewegungsschritte, +- Ruhephasen, +- artspezifische Bewegungsskalen, +- eine zeitlich veränderliche Präferenz für die Fokusfläche. + +Vereinfacht kann der Ablauf so dargestellt werden: + +```{r bewegungsablauf, eval=FALSE} +tracks <- simulate_tracks( + species = "Rehwild", + year = 1, + pars = SPECIES$Rehwild, + area = AREA, + cfg = CFG +) +``` + +Ein Bewegungsdatensatz enthält mindestens: + +| Variable | Bedeutung | +|---|---| +| `animal_id` | Kennung des Tieres | +| `species` | Art | +| `year` | Simulationsjahr | +| `time_step` | laufender Zeitschritt | +| `x`, `y` | Position | +| Aktivitätsinformation | aktiv oder ruhend | + +## Beispiel eines Individuums + +```{r individuum-plot, eval=params$vollstaendig_ausfuehren} +tracks_demo <- simulate_tracks( + species = params$art, + year = 1, + pars = SPECIES[[params$art]], + area = AREA, + cfg = CFG +) + +id_demo <- unique(tracks_demo$animal_id)[1] +one_animal <- tracks_demo[animal_id == id_demo] + +one_sf <- st_as_sf( + one_animal, + coords = c("x", "y"), + crs = CFG$crs, + remove = FALSE +) + +ggplot() + + geom_sf(data = AREA$zones, aes(fill = zone), alpha = 0.20) + + geom_path( + data = one_animal, + aes(x = x, y = y), + linewidth = 0.35 + ) + + geom_sf(data = one_sf[1, ], size = 2.5) + + coord_sf() + + labs( + title = paste("Beispielbewegung eines Individuums:", params$art), + subtitle = id_demo, + fill = "Zone" + ) + + theme_bw() +``` + +# Simulation der Fotofallendetektion + +Eine Fotofalle registriert nicht automatisch jedes Tier in ihrer Umgebung. Im Modell hängt die Detektionswahrscheinlichkeit von der Entfernung zwischen Tier und Kamera ab. + +Wichtige Einstellungen: + +```{r detektionsparameter, eval=FALSE} +CFG$detection_radius_m <- 20 +CFG$p_detect_5m <- 0.95 +CFG$p_detect_18m <- 0.05 +CFG$independence_minutes <- 30 +``` + +Das bedeutet im Beispiel: + +- in 5 m Entfernung ist die Detektionswahrscheinlichkeit hoch, +- in 18 m Entfernung ist sie gering, +- außerhalb des Detektionsradius erfolgt keine Detektion, +- Beobachtungen werden zu unabhängigen Ereignissen zusammengefasst. + +Die Detektionen werden mit folgendem Funktionsaufruf simuliert: + +```{r detektionsaufruf, eval=FALSE} +detections <- simulate_detections( + tracks = tracks_demo, + cameras = cams_demo, + cfg = CFG +) +``` + +# Kennwerte je Kamera, Jahr und Zone + +Nach der Detektionssimulation werden die Ereignisse je Kamera zusammengefasst. + +Ein zentraler Kennwert ist die relative Detektionsrate: + +\[ +RAI = \frac{\text{Zahl unabhängiger Ereignisse}} +{\text{Kameratage}} \times 100 +\] + +Sie beschreibt die Zahl unabhängiger Detektionen pro 100 Kameratage. + +```{r zusammenfassung, eval=FALSE} +camera_counts <- summarise_camera_counts( + det = detections, + cameras = cams_demo, + year = 1, + species = params$art, + cfg = CFG +) +``` + +Die relative Detektionsrate ist kein direkter Beweis für absolute Dichte. Sie kann sich verändern durch: + +- lokale Dichte, +- Raumnutzung, +- Aktivitätszeit, +- Bewegungsgeschwindigkeit, +- Gruppengröße, +- Sichtfeld und Ausrichtung der Kamera, +- Vegetation und Hindernisse, +- technische Ausfallzeiten. + +# Statistischer Test + +Die Hauptauswertung prüft, ob sich der zeitliche Trend in der Fokusfläche vom Trend im Buffer unterscheidet. + +Das statistische Modell enthält insbesondere: + +\[ +\text{Detektionen} \sim \text{Jahr} + \text{Zone} ++ \text{Jahr} \times \text{Zone} +\] + +Der Interaktionsterm `Jahr × Zone` ist entscheidend: + +- negativer Interaktionseffekt: stärkere Abnahme in der Fokusfläche, +- Effekt nahe null: ähnliche Entwicklung in beiden Zonen, +- positiver Effekt: relative Zunahme der Fokusflächennutzung. + +```{r modelltest, eval=FALSE} +test_result <- fit_change_test(camera_counts) +test_result +``` + +Das Hauptskript verwendet, soweit verfügbar, ein Negativ-Binomial-Modell. Dieses ist für überdisperse Zähldaten meist geeigneter als ein einfaches Poisson-Modell. + +# Eine vollständige Simulationswiederholung + +Eine einzelne Wiederholung umfasst alle Prozessschritte: + +```{r eine-wiederholung, eval=FALSE} +one_run <- run_one_replicate( + species = "Rehwild", + pars = SPECIES$Rehwild, + grid_spacing_m = 500, + replicate_id = 1, + cfg = CFG +) + +one_run +``` + +Das Ergebnis enthält unter anderem: + +- Art, +- Rasterabstand, +- tatsächliche Kamerazahl, +- Anteil der Kameras in der Fokusfläche, +- geschätzten Interaktionseffekt, +- p-Wert, +- Entscheidung, ob die Abnahme erkannt wurde, +- mittlere Ereigniszahl, +- Anteil der Kamera-Jahre ohne Ereignis. + +# Poweranalyse + +Ein einzelner Simulationslauf kann zufällig zu einem signifikanten oder nicht signifikanten Ergebnis führen. Deshalb wird jedes Design vielfach wiederholt. + +Die statistische Power wird geschätzt als: + +\[ +Power = +\frac{\text{Wiederholungen mit korrekt erkannter Abnahme}} +{\text{Zahl gültiger Wiederholungen}} +\] + +Typisches Ziel: + +```{r powerziel, eval=FALSE} +CFG$target_power <- 0.80 +CFG$alpha <- 0.05 +CFG$n_replicates <- 500 +``` + +Für Vorprüfungen reichen oft 50 bis 100 Wiederholungen. Für eine belastbare Designentscheidung sind eher 500 bis 1000 Wiederholungen sinnvoll. + +```{r poweranalyse, eval=FALSE} +CFG$camera_design_mode <- "grid" +CFG$grid_spacings_m <- c(250, 350, 500, 700) +CFG$n_replicates <- 500 + +ans <- run_power_analysis( + species_names = c("Rehwild", "Rotwild", "Gamswild"), + cfg = CFG +) + +ans$summary +``` + +# Darstellung der Ergebnisse + +```{r powerplot, eval=FALSE} +library(ggplot2) + +ggplot( + ans$summary, + aes( + x = n_cameras, + y = power, + group = factor(grid_spacing_m), + linetype = factor(grid_spacing_m) + ) +) + + geom_line() + + geom_point() + + geom_hline( + yintercept = CFG$target_power, + linetype = 2 + ) + + facet_wrap(~ species) + + scale_y_continuous(limits = c(0, 1)) + + labs( + x = "Mittlere tatsächliche Kamerazahl", + y = "Statistische Power", + linetype = "Rasterabstand (m)", + title = "Power zur Erkennung einer Abnahme der Fokusflächennutzung" + ) + + theme_bw() +``` + +Bei der Interpretation sollten neben der Power auch folgende Größen geprüft werden: + +- minimale und maximale Kamerazahl bei zufälliger Rasterlage, +- Anteil der Kameras in der Fokusfläche, +- Anteil der Kamera-Jahre ohne Detektion, +- mittlere Ereigniszahl, +- Konvergenz und Zahl gültiger Modellläufe, +- Stärke des geschätzten Interaktionseffekts. + +# Empfohlene Szenarien + +Die Power sollte nicht nur für einen angenommenen Rückgang berechnet werden. Sinnvoll ist eine Szenarienmatrix. + +```{r szenarien, eval=FALSE} +focus_effects <- c(0.90, 0.80, 0.70, 0.60) +grid_spacings <- c(250, 350, 500, 700) +species_names <- c("Rehwild", "Rotwild", "Gamswild") +``` + +Beispiele: + +| Szenario | Interpretation | +|---|---| +| `0.90` | 10 % geringere Nutzung im letzten Jahr | +| `0.80` | 20 % geringere Nutzung | +| `0.70` | 30 % geringere Nutzung | +| `0.60` | 40 % geringere Nutzung | + +Zusätzlich sollten Varianten der Gesamtpopulation geprüft werden: + +```{r populationsszenarien, eval=FALSE} +population_changes <- c(0.00, -0.03, -0.05) +``` + +So kann geprüft werden, ob das Design eine lokale Verlagerung auch dann erkennt, wenn gleichzeitig der Gesamtbestand abnimmt. + +# Kalibrierung mit realen Daten + +Vor einer endgültigen Designentscheidung sollten folgende Komponenten kalibriert werden. + +## Bewegungsdaten + +Aus GPS-Daten können abgeleitet werden: + +- Streifgebietsgrößen, +- Schrittweitenverteilung, +- Aktivitätsrhythmus, +- saisonale Unterschiede, +- Habitatselektion, +- individuelle Variation, +- Geschlechts- oder Altersunterschiede. + +## Kameradaten + +Aus Pilotdaten können geschätzt werden: + +- mittlere Ereigniszahl je Kameratag, +- Anteil von Nullbeobachtungen, +- Unterschiede zwischen Habitaten, +- Ausfallzeiten, +- effektive Detektionsdistanz, +- Einfluss von Wegen oder Wechseln, +- benötigter Unabhängigkeitszeitraum. + +## Fokusfläche und Buffer + +Zu prüfen sind: + +- ausreichende Größe beider Zonen, +- Repräsentativität der Habitate, +- Lage relativ zu Streifgebietsgrößen, +- räumliche Abhängigkeit benachbarter Kameras, +- praktische Erreichbarkeit, +- unveränderte Standorte über die Jahre. + +# Interpretation von relativer Abundanz und Dichte + +Eine signifikante Abnahme der Detektionsrate in der Fokusfläche zeigt zunächst, dass dort weniger unabhängige Fotofallenereignisse registriert werden. + +Dies ist vereinbar mit: + +- geringerer lokaler Tierdichte, +- geringerer Aufenthaltsdauer, +- einer Verlagerung der Streifgebiete, +- veränderten Bewegungswegen, +- geringerer Aktivität, +- veränderter Detektierbarkeit. + +Eine absolute Dichteaussage erfordert zusätzliche Annahmen oder Daten. Denkbare Erweiterungen sind: + +- Random Encounter Model, +- Time-to-Event-Modelle, +- Space-to-Event-Modelle, +- räumliche Capture-Recapture-Modelle bei individuell erkennbaren Tieren, +- Kalibrierung mit GPS-markierten Tieren, +- gemeinsame Modelle für Aktivität, Nutzung und Detektion. + +Die im Hauptskript enthaltene REM-artige Dichtekennzahl sollte daher als ergänzende Modellgröße und nicht automatisch als belastbare absolute Dichte interpretiert werden. + +# Praktischer Arbeitsablauf + +1. Fokusfläche als reale Geometrie einlesen. +2. Bufferbreite fachlich festlegen. +3. artspezifische Parameter mit lokalen Daten kalibrieren. +4. plausible Rückgangsszenarien definieren. +5. mehrere Rasterabstände vergleichen. +6. zunächst einen kleinen Funktionstest durchführen. +7. anschließend mindestens 500 Wiederholungen je Design rechnen. +8. Power, Nullanteil und tatsächliche Kamerazahl gemeinsam bewerten. +9. ein praktisch umsetzbares Design auswählen. +10. die gleichen Kamerastandorte über die Monitoringjahre beibehalten. + +# Beispiel für einen vollständigen Hauptlauf + +```{r kompletter-lauf, eval=FALSE} +source("fotofallen_power_simulation_schalenwild_grid.R") + +CFG$camera_design_mode <- "grid" +CFG$grid_spacings_m <- c(250, 350, 500, 700) +CFG$grid_random_rotation <- TRUE +CFG$grid_clip_to <- "outer" + +CFG$years <- 1:5 +CFG$survey_days <- 30 +CFG$n_replicates <- 500 +CFG$focus_use_multiplier_end <- 0.60 +CFG$annual_population_change <- 0.00 + +ans <- run_power_analysis( + species_names = c("Rehwild", "Rotwild", "Gamswild"), + cfg = CFG +) + +data.table::fwrite(ans$raw, "power_raw.csv") +data.table::fwrite(ans$summary, "power_summary.csv") +``` + +# Reproduzierbarkeit + +Für reproduzierbare Ergebnisse sollte der Zufallsstartwert dokumentiert werden: + +```{r seed, eval=FALSE} +set.seed(20260730) +``` + +Zusätzlich sollten gespeichert werden: + +- verwendete R-Version, +- Paketversionen, +- vollständige Parameterliste, +- Eingabekarten, +- Kamerastandorte, +- Simulationscode, +- Rohresultate aller Wiederholungen. + +```{r session-info, eval=FALSE} +sessionInfo() +``` + +# Zusammenfassung + +Die Simulationsstudie verbindet drei Ebenen: + +1. **ökologischer Prozess:** artspezifische Bewegung und Raumnutzung, +2. **Beobachtungsprozess:** unvollständige Detektion durch Fotofallen, +3. **Stichprobendesign:** Kamerazahl und räumliche Verteilung. + +Die Entscheidung für einen Rasterabstand sollte nicht allein anhand der mittleren Kamerazahl getroffen werden. Entscheidend ist, ob das Design für alle relevanten Arten und realistischen Rückgangsszenarien eine ausreichende Power erreicht und zugleich praktisch umsetzbar bleibt. diff --git a/simulationsstudie_fotofallen_schalenwild.html b/simulationsstudie_fotofallen_schalenwild.html new file mode 100644 index 0000000..19da79c --- /dev/null +++ b/simulationsstudie_fotofallen_schalenwild.html @@ -0,0 +1,2435 @@ + + + + + + + + + + + + + + +Simulationsstudie für ein Fotofallen-Monitoring von Reh-, Rot- und Gamswild + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + +
+
+
+
+
+ +
+ + + + + + + +
+

1 Ziel der +Simulationsstudie

+

Die Simulationsstudie untersucht, mit welchem Fotofallen-Design eine +zeitliche Abnahme der Nutzung einer Fokusfläche +zuverlässig erkannt werden kann. Die Fokusfläche wird von einem +Buffer umgeben. In beiden Zonen werden Fotofallen +installiert.

+

Die zentrale Frage lautet:

+
+

Wie viele Fotofallen werden benötigt und wie sollten sie räumlich +verteilt sein, damit eine Abnahme der Raumnutzungsintensität in der +Fokusfläche gegenüber dem Buffer mit ausreichender statistischer +Sicherheit erkannt wird?

+
+

Dabei werden drei Schalenwildarten berücksichtigt:

+
    +
  • Rehwild,
  • +
  • Rotwild,
  • +
  • Gamswild.
  • +
+

Die Arten unterscheiden sich in der Simulation unter anderem +hinsichtlich Streifgebietsgröße, Bewegungsweite, Bindung an +Attraktionspunkte, Aktivität und Gruppengröße.

+

Die Studie folgt einer prozessbasierten Struktur:

+
    +
  1. Untersuchungsraum definieren.
  2. +
  3. artspezifische Bewegungen simulieren.
  4. +
  5. Kamerastandorte erzeugen.
  6. +
  7. Tierbewegungen und Kamerastandorte räumlich überlagern.
  8. +
  9. Detektionen simulieren.
  10. +
  11. Detektionsraten je Kamera, Jahr und Zone berechnen.
  12. +
  13. die zeitliche Veränderung in Fokusfläche und Buffer +vergleichen.
  14. +
  15. den gesamten Ablauf oft wiederholen und daraus die statistische +Power bestimmen.
  16. +
+
+
+

2 Benötigte Dateien und +Pakete

+

Das Dokument ist als verständliche Begleitdokumentation zum +Hauptskript gedacht. Für eine vollständige Ausführung sollte sich das +folgende Skript im selben Arbeitsordner befinden:

+
params$hauptskript
+
## [1] "fotofallen_power_simulation_schalenwild_grid.R"
+

Benötigte R-Pakete:

+
install.packages(c(
+  "sf",
+  "data.table",
+  "ggplot2",
+  "MASS",
+  "knitr",
+  "rmarkdown"
+))
+
+# Optional für Negativ-Binomial-Mischmodelle:
+install.packages("glmmTMB")
+

Das Hauptskript kann mit folgendem Befehl eingelesen werden:

+
source(params$hauptskript)
+

Hinweis: Im Hauptskript ist ein kurzer Funktionstest +aktiviert. Für die Dokumentation oder einen kontrollierten Lauf kann +RUN_SMOKE_TEST <- FALSE gesetzt werden.

+
+
+

3 Aufbau des +Untersuchungsraums

+
+

3.1 Fokusfläche, Buffer +und Landschaft

+

Im Beispiel wird die Fokusfläche als Kreis erzeugt. Darum liegt ein +ringförmiger Buffer. Eine zusätzliche Landschaftsfläche sorgt dafür, +dass auch Streifgebietszentren und Bewegungen außerhalb der beiden +eigentlichen Auswertungszonen simuliert werden können.

+

Wichtige Parameter:

+
CFG$focus_radius_m       <- 1000
+CFG$buffer_width_m       <- 1500
+CFG$landscape_margin_m   <- 1800
+CFG$crs                  <- 32632
+

Die Bedeutung der Flächen ist:

+ ++++ + + + + + + + + + + + + + + + + + + + + +
FlächeFunktion
FokusflächeBereich, für den eine abnehmende Nutzung geprüft wird
Bufferräumliche Vergleichszone um die Fokusfläche
Landschaftgrößerer Simulationsraum für Streifgebiete und Bewegungen
+

Bei realen Projekten sollte die Fokusfläche nicht künstlich als Kreis +erzeugt, sondern als vorhandenes Polygon aus einem GeoPackage, Shapefile +oder GeoJSON eingelesen werden.

+

Beispiel:

+
library(sf)
+
+focus <- st_read("input/fokusflaeche.gpkg")
+focus <- st_make_valid(focus)
+focus <- st_transform(focus, 32632)
+
+outer <- st_buffer(focus, dist = 1500)
+buffer <- st_difference(outer, focus)
+landscape <- st_buffer(outer, dist = 1800)
+
+
+
+

4 Artspezifische +Bewegungsökologie

+

Die drei Arten werden über getrennte Parameterprofile +beschrieben.

+
SPECIES
+

Die wichtigsten Parameter sind:

+ ++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ParameterBedeutung
n_animalssimulierte Zahl der Tiere
home_range_hatypische Streifgebietsgröße
step_scale_mGrößenordnung kurzfristiger Bewegungsschritte
n_attraction_pointsAnzahl bevorzugter Aufenthaltsbereiche
attraction_strengthStärke der Rückkehr zu bevorzugten Bereichen
resting_probabilityWahrscheinlichkeit eines inaktiven Zeitschritts
speed_km_dayangenommene tägliche Bewegungsstrecke
group_size_meanmittlere Gruppengröße
+

Die voreingestellten Werte sind Startwerte für die +Planung. Sie sollten mit lokalen GPS-Daten, Literaturwerten +oder Expertenwissen kalibriert werden.

+
+

4.1 Beispielhafte +Unterschiede

+
    +
  • Rehwild: kleinere Streifgebiete und stärkere lokale +Bindung.
  • +
  • Rotwild: deutlich größere Streifgebiete und weitere +Bewegungen.
  • +
  • Gamswild: mittlere bis große Streifgebiete; +zusätzlich kann eine topografische Habitatselektion eingebaut +werden.
  • +
+

Für Gamswild ist im Hauptskript die Funktion +habitat_weight_function() vorgesehen. Sie kann später +beispielsweise mit Höhe, Hangneigung, Exposition, Felsanteil, +Walddeckung oder Schneelage erweitert werden.

+
habitat_weight_function <- function(x, y, species) {
+  if (species != "Gamswild") return(rep(1, length(x)))
+
+  # Platzhalter:
+  # Später z.B. Vorhersagen eines RSF-/SSF-Modells einsetzen.
+  rep(1, length(x))
+}
+
+
+
+

5 Simulation der +zeitlichen Veränderung

+

Die Studie trennt zwei mögliche Prozesse:

+
    +
  1. eine Veränderung der gesamten Population,
  2. +
  3. eine zusätzliche Veränderung der Nutzung der Fokusfläche.
  4. +
+
+

5.1 Veränderung der +Fokusflächennutzung

+
CFG$focus_use_multiplier_end <- 0.60
+

Ein Wert von 0.60 bedeutet, dass die relative Nutzung +der Fokusfläche im letzten Jahr nur noch 60 % des Ausgangsniveaus +beträgt.

+

Bei fünf Jahren wird dieser Rückgang schrittweise zwischen Jahr 1 und +Jahr 5 umgesetzt.

+
+
+

5.2 Veränderung der +Gesamtpopulation

+
CFG$annual_population_change <- 0.00
+
    +
  • 0.00: Gesamtpopulation bleibt konstant.
  • +
  • -0.05: jährliche Abnahme um etwa 5 %.
  • +
  • 0.03: jährliche Zunahme um etwa 3 %.
  • +
+

Die getrennte Parametrisierung ist wichtig: Eine sinkende +Detektionsrate in der Fokusfläche kann entweder aus einer lokalen +Verlagerung oder aus einer allgemeinen Bestandsabnahme resultieren.

+
+
+
+

6 Erzeugung der +Kamerastandorte

+

Das Hauptskript bietet zwei Designs.

+
+

6.1 Zufällige Standorte +mit Mindestabstand

+
CFG$camera_design_mode <- "random"
+CFG$camera_numbers <- c(12, 20, 30, 40, 60)
+CFG$allocations_focus <- c(0.35, 0.50, 0.65, 0.80)
+CFG$min_camera_spacing_m <- 250
+

Dabei werden eine feste Kamerazahl und ein gewünschter Anteil in der +Fokusfläche vorgegeben.

+
+
+

6.2 Zufällig verschobenes +Raster

+

Für die aktuelle Fragestellung ist besonders das Grid-Design +relevant:

+
CFG$camera_design_mode <- "grid"
+CFG$grid_spacings_m <- c(250, 350, 500, 700)
+CFG$grid_random_rotation <- TRUE
+CFG$grid_clip_to <- "outer"
+

Der Rasterabstand bestimmt indirekt die Kamerazahl:

+
    +
  • kleiner Abstand: mehr Kameras,
  • +
  • großer Abstand: weniger Kameras.
  • +
+

Das Raster wird in jeder Simulationswiederholung zufällig verschoben. +Optional wird es auch zufällig gedreht. Dadurch wird geprüft, ob ein +Design robust gegenüber einer zufälligen Lage des Rasters ist.

+

Mögliche Begrenzungen:

+
CFG$grid_clip_to <- "outer"   # Fokusfläche und Buffer
+CFG$grid_clip_to <- "focus"   # nur Fokusfläche
+CFG$grid_clip_to <- "buffer"  # nur Buffer
+
+
+

6.3 Beispielkarte eines +Grid-Designs

+

Der folgende Block kann ausgeführt werden, nachdem das Hauptskript +mit source() geladen wurde.

+
cfg_demo <- CFG
+cfg_demo$camera_design_mode <- "grid"
+cfg_demo$grid_random_rotation <- TRUE
+
+cams_demo <- make_camera_design(
+  area = AREA,
+  cfg = cfg_demo,
+  grid_spacing_m = params$grid_abstand_m
+)
+
+ggplot() +
+  geom_sf(data = AREA$zones, aes(fill = zone), alpha = 0.25) +
+  geom_sf(data = cams_demo, shape = 21, size = 2.5) +
+  coord_sf() +
+  labs(
+    title = paste("Zufällig verschobenes Kameraraster:",
+                  params$grid_abstand_m, "m"),
+    subtitle = paste(nrow(cams_demo), "potenzielle Kamerastandorte"),
+    fill = "Zone"
+  ) +
+  theme_bw()
+
+
+
+

7 Simulation der +Tierbewegungen

+

Für jedes Jahr werden zunächst Streifgebietszentren erzeugt. +Anschließend werden Bewegungsbahnen für alle Tiere simuliert.

+

Das Bewegungsmodell enthält:

+
    +
  • eine Bindung an das Streifgebiet,
  • +
  • mehrere Attraktionspunkte,
  • +
  • zufällige Bewegungsschritte,
  • +
  • Ruhephasen,
  • +
  • artspezifische Bewegungsskalen,
  • +
  • eine zeitlich veränderliche Präferenz für die Fokusfläche.
  • +
+

Vereinfacht kann der Ablauf so dargestellt werden:

+
tracks <- simulate_tracks(
+  species = "Rehwild",
+  year = 1,
+  pars = SPECIES$Rehwild,
+  area = AREA,
+  cfg = CFG
+)
+

Ein Bewegungsdatensatz enthält mindestens:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
VariableBedeutung
animal_idKennung des Tieres
speciesArt
yearSimulationsjahr
time_steplaufender Zeitschritt
x, yPosition
Aktivitätsinformationaktiv oder ruhend
+
+

7.1 Beispiel eines +Individuums

+
tracks_demo <- simulate_tracks(
+  species = params$art,
+  year = 1,
+  pars = SPECIES[[params$art]],
+  area = AREA,
+  cfg = CFG
+)
+
+id_demo <- unique(tracks_demo$animal_id)[1]
+one_animal <- tracks_demo[animal_id == id_demo]
+
+one_sf <- st_as_sf(
+  one_animal,
+  coords = c("x", "y"),
+  crs = CFG$crs,
+  remove = FALSE
+)
+
+ggplot() +
+  geom_sf(data = AREA$zones, aes(fill = zone), alpha = 0.20) +
+  geom_path(
+    data = one_animal,
+    aes(x = x, y = y),
+    linewidth = 0.35
+  ) +
+  geom_sf(data = one_sf[1, ], size = 2.5) +
+  coord_sf() +
+  labs(
+    title = paste("Beispielbewegung eines Individuums:", params$art),
+    subtitle = id_demo,
+    fill = "Zone"
+  ) +
+  theme_bw()
+
+
+
+

8 Simulation der +Fotofallendetektion

+

Eine Fotofalle registriert nicht automatisch jedes Tier in ihrer +Umgebung. Im Modell hängt die Detektionswahrscheinlichkeit von der +Entfernung zwischen Tier und Kamera ab.

+

Wichtige Einstellungen:

+
CFG$detection_radius_m <- 20
+CFG$p_detect_5m <- 0.95
+CFG$p_detect_18m <- 0.05
+CFG$independence_minutes <- 30
+

Das bedeutet im Beispiel:

+
    +
  • in 5 m Entfernung ist die Detektionswahrscheinlichkeit hoch,
  • +
  • in 18 m Entfernung ist sie gering,
  • +
  • außerhalb des Detektionsradius erfolgt keine Detektion,
  • +
  • Beobachtungen werden zu unabhängigen Ereignissen +zusammengefasst.
  • +
+

Die Detektionen werden mit folgendem Funktionsaufruf simuliert:

+
detections <- simulate_detections(
+  tracks = tracks_demo,
+  cameras = cams_demo,
+  cfg = CFG
+)
+
+
+

9 Kennwerte je Kamera, +Jahr und Zone

+

Nach der Detektionssimulation werden die Ereignisse je Kamera +zusammengefasst.

+

Ein zentraler Kennwert ist die relative Detektionsrate:

+

\[ +RAI = \frac{\text{Zahl unabhängiger Ereignisse}} +{\text{Kameratage}} \times 100 +\]

+

Sie beschreibt die Zahl unabhängiger Detektionen pro 100 +Kameratage.

+
camera_counts <- summarise_camera_counts(
+  det = detections,
+  cameras = cams_demo,
+  year = 1,
+  species = params$art,
+  cfg = CFG
+)
+

Die relative Detektionsrate ist kein direkter Beweis für absolute +Dichte. Sie kann sich verändern durch:

+
    +
  • lokale Dichte,
  • +
  • Raumnutzung,
  • +
  • Aktivitätszeit,
  • +
  • Bewegungsgeschwindigkeit,
  • +
  • Gruppengröße,
  • +
  • Sichtfeld und Ausrichtung der Kamera,
  • +
  • Vegetation und Hindernisse,
  • +
  • technische Ausfallzeiten.
  • +
+
+
+

10 Statistischer +Test

+

Die Hauptauswertung prüft, ob sich der zeitliche Trend in der +Fokusfläche vom Trend im Buffer unterscheidet.

+

Das statistische Modell enthält insbesondere:

+

\[ +\text{Detektionen} \sim \text{Jahr} + \text{Zone} ++ \text{Jahr} \times \text{Zone} +\]

+

Der Interaktionsterm Jahr × Zone ist entscheidend:

+
    +
  • negativer Interaktionseffekt: stärkere Abnahme in der +Fokusfläche,
  • +
  • Effekt nahe null: ähnliche Entwicklung in beiden Zonen,
  • +
  • positiver Effekt: relative Zunahme der Fokusflächennutzung.
  • +
+
test_result <- fit_change_test(camera_counts)
+test_result
+

Das Hauptskript verwendet, soweit verfügbar, ein +Negativ-Binomial-Modell. Dieses ist für überdisperse Zähldaten meist +geeigneter als ein einfaches Poisson-Modell.

+
+
+

11 Eine vollständige +Simulationswiederholung

+

Eine einzelne Wiederholung umfasst alle Prozessschritte:

+
one_run <- run_one_replicate(
+  species = "Rehwild",
+  pars = SPECIES$Rehwild,
+  grid_spacing_m = 500,
+  replicate_id = 1,
+  cfg = CFG
+)
+
+one_run
+

Das Ergebnis enthält unter anderem:

+
    +
  • Art,
  • +
  • Rasterabstand,
  • +
  • tatsächliche Kamerazahl,
  • +
  • Anteil der Kameras in der Fokusfläche,
  • +
  • geschätzten Interaktionseffekt,
  • +
  • p-Wert,
  • +
  • Entscheidung, ob die Abnahme erkannt wurde,
  • +
  • mittlere Ereigniszahl,
  • +
  • Anteil der Kamera-Jahre ohne Ereignis.
  • +
+
+
+

12 Poweranalyse

+

Ein einzelner Simulationslauf kann zufällig zu einem signifikanten +oder nicht signifikanten Ergebnis führen. Deshalb wird jedes Design +vielfach wiederholt.

+

Die statistische Power wird geschätzt als:

+

\[ +Power = +\frac{\text{Wiederholungen mit korrekt erkannter Abnahme}} +{\text{Zahl gültiger Wiederholungen}} +\]

+

Typisches Ziel:

+
CFG$target_power <- 0.80
+CFG$alpha <- 0.05
+CFG$n_replicates <- 500
+

Für Vorprüfungen reichen oft 50 bis 100 Wiederholungen. Für eine +belastbare Designentscheidung sind eher 500 bis 1000 Wiederholungen +sinnvoll.

+
CFG$camera_design_mode <- "grid"
+CFG$grid_spacings_m <- c(250, 350, 500, 700)
+CFG$n_replicates <- 500
+
+ans <- run_power_analysis(
+  species_names = c("Rehwild", "Rotwild", "Gamswild"),
+  cfg = CFG
+)
+
+ans$summary
+
+
+

13 Darstellung der +Ergebnisse

+
library(ggplot2)
+
+ggplot(
+  ans$summary,
+  aes(
+    x = n_cameras,
+    y = power,
+    group = factor(grid_spacing_m),
+    linetype = factor(grid_spacing_m)
+  )
+) +
+  geom_line() +
+  geom_point() +
+  geom_hline(
+    yintercept = CFG$target_power,
+    linetype = 2
+  ) +
+  facet_wrap(~ species) +
+  scale_y_continuous(limits = c(0, 1)) +
+  labs(
+    x = "Mittlere tatsächliche Kamerazahl",
+    y = "Statistische Power",
+    linetype = "Rasterabstand (m)",
+    title = "Power zur Erkennung einer Abnahme der Fokusflächennutzung"
+  ) +
+  theme_bw()
+

Bei der Interpretation sollten neben der Power auch folgende Größen +geprüft werden:

+
    +
  • minimale und maximale Kamerazahl bei zufälliger Rasterlage,
  • +
  • Anteil der Kameras in der Fokusfläche,
  • +
  • Anteil der Kamera-Jahre ohne Detektion,
  • +
  • mittlere Ereigniszahl,
  • +
  • Konvergenz und Zahl gültiger Modellläufe,
  • +
  • Stärke des geschätzten Interaktionseffekts.
  • +
+
+
+

14 Empfohlene +Szenarien

+

Die Power sollte nicht nur für einen angenommenen Rückgang berechnet +werden. Sinnvoll ist eine Szenarienmatrix.

+
focus_effects <- c(0.90, 0.80, 0.70, 0.60)
+grid_spacings <- c(250, 350, 500, 700)
+species_names <- c("Rehwild", "Rotwild", "Gamswild")
+

Beispiele:

+ + + + + + + + + + + + + + + + + + + + + + + + + +
SzenarioInterpretation
0.9010 % geringere Nutzung im letzten Jahr
0.8020 % geringere Nutzung
0.7030 % geringere Nutzung
0.6040 % geringere Nutzung
+

Zusätzlich sollten Varianten der Gesamtpopulation geprüft werden:

+
population_changes <- c(0.00, -0.03, -0.05)
+

So kann geprüft werden, ob das Design eine lokale Verlagerung auch +dann erkennt, wenn gleichzeitig der Gesamtbestand abnimmt.

+
+
+

15 Kalibrierung mit +realen Daten

+

Vor einer endgültigen Designentscheidung sollten folgende Komponenten +kalibriert werden.

+
+

15.1 Bewegungsdaten

+

Aus GPS-Daten können abgeleitet werden:

+
    +
  • Streifgebietsgrößen,
  • +
  • Schrittweitenverteilung,
  • +
  • Aktivitätsrhythmus,
  • +
  • saisonale Unterschiede,
  • +
  • Habitatselektion,
  • +
  • individuelle Variation,
  • +
  • Geschlechts- oder Altersunterschiede.
  • +
+
+
+

15.2 Kameradaten

+

Aus Pilotdaten können geschätzt werden:

+
    +
  • mittlere Ereigniszahl je Kameratag,
  • +
  • Anteil von Nullbeobachtungen,
  • +
  • Unterschiede zwischen Habitaten,
  • +
  • Ausfallzeiten,
  • +
  • effektive Detektionsdistanz,
  • +
  • Einfluss von Wegen oder Wechseln,
  • +
  • benötigter Unabhängigkeitszeitraum.
  • +
+
+
+

15.3 Fokusfläche und +Buffer

+

Zu prüfen sind:

+
    +
  • ausreichende Größe beider Zonen,
  • +
  • Repräsentativität der Habitate,
  • +
  • Lage relativ zu Streifgebietsgrößen,
  • +
  • räumliche Abhängigkeit benachbarter Kameras,
  • +
  • praktische Erreichbarkeit,
  • +
  • unveränderte Standorte über die Jahre.
  • +
+
+
+
+

16 Interpretation von +relativer Abundanz und Dichte

+

Eine signifikante Abnahme der Detektionsrate in der Fokusfläche zeigt +zunächst, dass dort weniger unabhängige Fotofallenereignisse registriert +werden.

+

Dies ist vereinbar mit:

+
    +
  • geringerer lokaler Tierdichte,
  • +
  • geringerer Aufenthaltsdauer,
  • +
  • einer Verlagerung der Streifgebiete,
  • +
  • veränderten Bewegungswegen,
  • +
  • geringerer Aktivität,
  • +
  • veränderter Detektierbarkeit.
  • +
+

Eine absolute Dichteaussage erfordert zusätzliche Annahmen oder +Daten. Denkbare Erweiterungen sind:

+
    +
  • Random Encounter Model,
  • +
  • Time-to-Event-Modelle,
  • +
  • Space-to-Event-Modelle,
  • +
  • räumliche Capture-Recapture-Modelle bei individuell erkennbaren +Tieren,
  • +
  • Kalibrierung mit GPS-markierten Tieren,
  • +
  • gemeinsame Modelle für Aktivität, Nutzung und Detektion.
  • +
+

Die im Hauptskript enthaltene REM-artige Dichtekennzahl sollte daher +als ergänzende Modellgröße und nicht automatisch als belastbare absolute +Dichte interpretiert werden.

+
+
+

17 Praktischer +Arbeitsablauf

+
    +
  1. Fokusfläche als reale Geometrie einlesen.
  2. +
  3. Bufferbreite fachlich festlegen.
  4. +
  5. artspezifische Parameter mit lokalen Daten kalibrieren.
  6. +
  7. plausible Rückgangsszenarien definieren.
  8. +
  9. mehrere Rasterabstände vergleichen.
  10. +
  11. zunächst einen kleinen Funktionstest durchführen.
  12. +
  13. anschließend mindestens 500 Wiederholungen je Design rechnen.
  14. +
  15. Power, Nullanteil und tatsächliche Kamerazahl gemeinsam +bewerten.
  16. +
  17. ein praktisch umsetzbares Design auswählen.
  18. +
  19. die gleichen Kamerastandorte über die Monitoringjahre +beibehalten.
  20. +
+
+
+

18 Beispiel für einen +vollständigen Hauptlauf

+
source("fotofallen_power_simulation_schalenwild_grid.R")
+
+CFG$camera_design_mode <- "grid"
+CFG$grid_spacings_m <- c(250, 350, 500, 700)
+CFG$grid_random_rotation <- TRUE
+CFG$grid_clip_to <- "outer"
+
+CFG$years <- 1:5
+CFG$survey_days <- 30
+CFG$n_replicates <- 500
+CFG$focus_use_multiplier_end <- 0.60
+CFG$annual_population_change <- 0.00
+
+ans <- run_power_analysis(
+  species_names = c("Rehwild", "Rotwild", "Gamswild"),
+  cfg = CFG
+)
+
+data.table::fwrite(ans$raw, "power_raw.csv")
+data.table::fwrite(ans$summary, "power_summary.csv")
+
+
+

19 +Reproduzierbarkeit

+

Für reproduzierbare Ergebnisse sollte der Zufallsstartwert +dokumentiert werden:

+
set.seed(20260730)
+

Zusätzlich sollten gespeichert werden:

+
    +
  • verwendete R-Version,
  • +
  • Paketversionen,
  • +
  • vollständige Parameterliste,
  • +
  • Eingabekarten,
  • +
  • Kamerastandorte,
  • +
  • Simulationscode,
  • +
  • Rohresultate aller Wiederholungen.
  • +
+
sessionInfo()
+
+
+

20 Zusammenfassung

+

Die Simulationsstudie verbindet drei Ebenen:

+
    +
  1. ökologischer Prozess: artspezifische Bewegung und +Raumnutzung,
  2. +
  3. Beobachtungsprozess: unvollständige Detektion durch +Fotofallen,
  4. +
  5. Stichprobendesign: Kamerazahl und räumliche +Verteilung.
  6. +
+

Die Entscheidung für einen Rasterabstand sollte nicht allein anhand +der mittleren Kamerazahl getroffen werden. Entscheidend ist, ob das +Design für alle relevanten Arten und realistischen Rückgangsszenarien +eine ausreichende Power erreicht und zugleich praktisch umsetzbar +bleibt.

+
+ + + +
+
+ +
+ + + + + + + + + + + + + + + + +