CacheGeo {reproducible} | R Documentation |
Cache-like function for spatial domains
Description
Usage
CacheGeo(
targetFile = NULL,
url = NULL,
domain,
FUN,
destinationPath = getOption("reproducible.destinationPath", "."),
useCloud = getOption("reproducible.useCloud", FALSE),
cloudFolderID = NULL,
purge = FALSE,
useCache = getOption("reproducible.useCache"),
overwrite = getOption("reproducible.overwrite"),
action = c("nothing", "update", "replace", "append"),
...
)
Arguments
targetFile |
The (optional) local file (or path to file) |
url |
The (optional) url of the object on Google Drive (the only option currently). This is only for downloading and uploading to. |
domain |
An sf polygon object that is the spatial area of interest. If |
FUN |
A function call that will be called if there is the |
destinationPath |
Character string of a directory in which to download
and save the file that comes from |
useCloud |
A logical. |
cloudFolderID |
If this is specified, then it must be either 1) a googledrive
url to a folder where the |
purge |
Logical or Integer. |
useCache |
Passed to |
overwrite |
Logical. Should downloading and all the other actions occur even if they pass the checksums or the files are all there. |
action |
A character string, with one of c("nothing", "update",
"replace", "append"). Partial matching is used ("n" is sufficient).
|
... |
Any named objects that are needed for FUN |
Details
This function is a combination of Cache
and prepInputs
but for spatial
domains. This differs from Cache
in that the current function call doesn't
have to have an identical function call previously run. Instead, it needs
to have had a previous function call where the domain
being passes is
within the geographic limits of the targetFile
or file located at the url
.
This is similar to a geospatial operation on a remote GIS server, with 2 differences:
This downloads the object first before doing the GIS locally, and 2. it will optionally upload an updated object if the geographic area did not yet exist.
This has a very specific use case: assess whether an existing sf
polygon
or multipolygon object (local or remote) covers the spatial
area of a domain
of interest. If it does, then return only that
part of the sf
object that completely covers the domain
.
If it does not, then run FUN
. It is expected that FUN
will produce an sf
polygon or multipolygon class object. The result of FUN
will then be
appended to the sf
object as a new entry (feature) or it will replace
the existing "same extent" entry in the sf
object.
Value
Returns an object that results from FUN
, which will possibly be a subset
of a larger spatial object that is specified with targetFile
or url
.
Examples
if (requireNamespace("sf", quietly = TRUE) &&
requireNamespace("terra", quietly = TRUE)) {
dPath <- checkPath(file.path(tempdir2()), create = TRUE)
localFileLux <- system.file("ex/lux.shp", package = "terra")
# 1 step for each layer
# 1st step -- get study area
full <- prepInputs(localFileLux, destinationPath = dPath) # default is sf::st_read
zoneA <- full[3:6, ]
zoneB <- full[8, ] # not in A
zoneC <- full[3, ] # yes in A
zoneD <- full[7:8, ] # not in A, B or C
zoneE <- full[3:5, ] # yes in A
# 2nd step: re-write to disk as read/write is lossy; want all "from disk" for this ex.
writeTo(zoneA, writeTo = "zoneA.shp", destinationPath = dPath)
writeTo(zoneB, writeTo = "zoneB.shp", destinationPath = dPath)
writeTo(zoneC, writeTo = "zoneC.shp", destinationPath = dPath)
writeTo(zoneD, writeTo = "zoneD.shp", destinationPath = dPath)
writeTo(zoneE, writeTo = "zoneE.shp", destinationPath = dPath)
# Must re-read to get identical columns
zoneA <- sf::st_read(file.path(dPath, "zoneA.shp"))
zoneB <- sf::st_read(file.path(dPath, "zoneB.shp"))
zoneC <- sf::st_read(file.path(dPath, "zoneC.shp"))
zoneD <- sf::st_read(file.path(dPath, "zoneD.shp"))
zoneE <- sf::st_read(file.path(dPath, "zoneE.shp"))
# The function that is to be run. This example returns a data.frame because
# saving `sf` class objects with list-like columns does not work with
# many st_driver()
fun <- function(domain, newField) {
domain |>
as.data.frame() |>
cbind(params = I(lapply(seq_len(NROW(domain)), function(x) newField)))
}
# Run sequence -- A, B will add new entries in targetFile, C will not,
# D will, E will not
for (z in list(zoneA, zoneB, zoneC, zoneD, zoneE)) {
out <- CacheGeo(
targetFile = "fireSenseParams.rds",
domain = z,
FUN = fun(domain, newField = I(list(list(a = 1, b = 1:2, c = "D")))),
fun = fun, # pass whatever is needed into the function
destinationPath = dPath,
action = "update"
# , cloudFolderID = "cachedObjects" # to upload/download from cloud
)
}
}