Package 'toro'

Description

Adds play/pause/stop buttons to control route animations on the map. Optionally includes a speed control slider for adjusting animation speed.

Usage

add_animation_controls(
  map,
  route_id = NULL,
  position = "top-right",
  panel_id = NULL,
  buttons = c("play", "pause"),
  include_speed_control = FALSE,
  speed_values = c(0.5, 1, 2),
  speed_labels = c("Slow", "Normal", "Fast"),
  settings = list()
)

Arguments

Value

The map or map proxy object for chaining.

Examples

library(sf)

line_data <- sf::st_sf(
  id = 1,
  geometry = sf::st_sfc(
    sf::st_linestring(
      cbind(c(172.2041, 163.9383), c(-32.56960, -46.43999))
    ),
    crs = 4326
  )
)

map() |>
  add_route(route_id = "route_line", points = line_data) |>
  add_animation_controls(route_id = "route_line", include_speed_control = TRUE)

Description

Add a circle layer to a map or map proxy

Usage

add_circle_layer(
  map,
  id,
  source,
  paint = NULL,
  layout = NULL,
  popup_column = NULL,
  hover_column = NULL,
  can_cluster = FALSE,
  under_id = NULL,
  filter = NULL,
  ...
)

Arguments

Value

The updated map object with the circle layer added.

Examples

# Load libraries
library(spData)
library(sf)

nz_data <- spData::nz_height |>
  sf::st_transform(4326)

map() |>
 set_bounds(bounds = nz_data) |>
 add_circle_layer(
   id = "nz_elevation",
   source = nz_data,
   hover_column = "elevation"
 )

map() |>
 set_bounds(bounds = nz_data) |>
 add_circle_layer(
   id = "nz_elevation",
   source = nz_data,
   hover_column = "elevation",
   paint = get_paint_options(
     "circle",
     options = list(
       colour = get_column_steps(
         "elevation",
         c(3000),
         c("grey", "black")
       )
     )
   )
 )

Description

Creates a toggle button that can enable/disable clustering for a specific layer.

Usage

add_cluster_toggle(
  map,
  layer_id,
  control_id = NULL,
  left_label = "Toggle Clustering",
  right_label = NULL,
  initial_state = FALSE,
  position = "top-right",
  panel_id = NULL,
  section_title = NULL,
  group_id = NULL
)

Arguments

Value

The map or map proxy object for chaining.

Examples

# Load libraries
library(sf)

# Prepare data
data(quakes)
quakes_data <- quakes |>
 sf::st_as_sf(coords = c("long", "lat"), crs = 4326)

map() |>
 add_symbol_layer(
   id = "quakes",
   source = quakes_data,
   can_cluster = TRUE
 ) |>
 add_cluster_toggle(layer_id = "quakes")

Description

Creates a collapsible group within a control panel that can contain multiple controls.

Usage

add_control_group(
  map,
  panel_id,
  group_id,
  group_title = NULL,
  collapsible = FALSE,
  collapsed = FALSE
)

Arguments

Value

The map or map proxy object for chaining.

Examples

map() |>
  add_control_panel(panel_id = "my_panel", direction = "row") |>
  add_control_group(
    panel_id = "my_panel",
    group_id = "group_1",
    group_title = "Group 1"
  ) |>
  add_control_group(
    panel_id = "my_panel",
    group_id = "group_2",
    group_title = "Group 2"
  ) |>
  add_cursor_coords_control(panel_id = "my_panel", group_id = "group_1") |>
  add_zoom_control(panel_id = "my_panel", group_id = "group_2")

map() |>
  add_control_panel(
    panel_id = "my_panel",
    title = "Map Settings",
    position = "top-right",
    collapsible = TRUE,
    collapsed = TRUE,
    direction = "row"
  ) |>
  add_cursor_coords_control(
    panel_id = "my_panel",
    section_title = "Cursor Coordinates"
  )

Description

Creates a flexible control panel that can contain multiple controls.

Usage

add_control_panel(
  map,
  panel_id,
  title = NULL,
  position = "bottom-left",
  collapsible = FALSE,
  collapsed = FALSE,
  direction = "column",
  custom_controls = NULL
)

Arguments

Value

The map or map proxy object for chaining.

Examples

map() |>
  add_control_panel(panel_id = "my_panel", title = "Map Settings") |>
  add_cursor_coords_control(panel_id = "my_panel") |>
  add_zoom_control(panel_id = "my_panel")

map() |>
  add_control_panel(
    panel_id = "my_panel",
    title = "Map Settings",
    position = "top-right",
    collapsible = TRUE,
    collapsed = TRUE,
    direction = "row"
  ) |>
  add_cursor_coords_control(
    panel_id = "my_panel",
    section_title = "Cursor Coordinates"
  )

Description

Add a cursor coordinates control to the map

Usage

add_cursor_coords_control(
  map,
  position = "bottom-left",
  long_label = "Lng",
  lat_label = "Lat",
  panel_id = NULL,
  section_title = NULL,
  group_id = NULL
)

Arguments

Value

The map or map proxy object for chaining.

Examples

# Add to a map
map() |>
 add_cursor_coords_control()

# Change default options
map() |>
 add_cursor_coords_control(
   position = "top-right",
   long_label = "Longitude",
   lat_label = "Latitude"
 )

# Add to a control panel
map() |>
 add_control_panel(panel_id = "my_panel", title = "Map Settings") |>
 add_cursor_coords_control(panel_id = "my_panel", section_title = "Cursor Coordinates")

# Add to a control panel inside a control group
map() |>
 add_control_panel(panel_id = "my_panel", title = "Map Settings") |>
 add_control_group(
   panel_id = "my_panel",
   group_id = "map_state",
   group_title = "Map State"
   ) |>
 add_cursor_coords_control(panel_id = "my_panel", group_id = "map_state")

Description

Add a custom HTML control to the map

Usage

add_custom_control(
  map,
  id,
  html,
  position = "top-right",
  panel_id = NULL,
  section_title = NULL,
  group_id = NULL
)

Arguments

Value

The map or map proxy object for chaining.

Examples

# Add to a map
map() |>
 add_custom_control(
   id = "custom_control",
   html = "<p>I am a custom control</p>"
)

# Add to a control panel
map() |>
 add_control_panel(panel_id = "my_panel", title = "Map Settings") |>
 add_custom_control(
   id = "custom_control_panel",
   html = "<p>I am a custom control in a panel</p>",
   panel_id = "my_panel",
   section_title = "Custom Control Section"
 )

# Add to a control panel inside a control group
map() |>
 add_control_panel(panel_id = "my_panel", title = "Map Settings") |>
 add_control_group(
   panel_id = "my_panel",
   group_id = "custom_controls",
   group_title = "Custom Controls"
   ) |>
 add_custom_control(
   id = "custom_control_panel",
   html = "<p>I am a custom control in a panel</p>",
   panel_id = "my_panel",
   group_id = "custom_controls"
 )

Description

The draw control allows users to draw shapes (polygons, lines, points) on the map. The drawn shapes can be styled and managed through the control options. Information about the drawn shapes can be retrieved in Shiny using the input$map_shape_created (where map is the ID of the map) reactive value.

Usage

add_draw_control(
  map,
  id = "draw_control",
  position = "top-right",
  modes = c("polygon"),
  active_colour = "#04AAC1",
  inactive_colour = "#04AAC1",
  mode_labels = list(),
  panel_id = NULL,
  section_title = NULL,
  group_id = NULL
)

Arguments

Details

For a more in-depth example see the Draw control article.

Value

The map or map proxy object for chaining.

See Also

get_drawn_shape() to retrieve the drawn shape as an sf object in Shiny.

Examples

map() |>
 add_draw_control()

Description

Add a FeatureService source to the map

Usage

add_feature_server_source(
  map,
  source_url,
  source_id,
  append_query_url = "/0/query?where=1=1&outFields=*&f=geojson"
)

Arguments

Value

The map or map proxy object for chaining.

Note

By default the function appends a query URL to the provided source_url to retrieve all features in GeoJSON format. If you need more control over the query parameters, you can provide the full query URL directly in the source_url argument and set append_query_url to an empty string to prevent appending the default query parameters.

Examples

service_url <- paste0(
 "https://services1.arcgis.com/VwarAUbcaX64Jhub/arcgis/rest/services/",
 "World_Exclusive_Economic_Zones_Boundaries/FeatureServer"
)

 map() |>
   add_feature_server_source(service_url, "eez") |>
   add_line_layer(id = "eez_lines", source = "eez")

Description

Add a fill layer to a map or map proxy

Usage

add_fill_layer(
  map,
  id,
  source,
  paint = NULL,
  layout = NULL,
  popup_column = NULL,
  hover_column = NULL,
  can_cluster = FALSE,
  under_id = NULL,
  filter = NULL,
  ...
)

Arguments

Value

The updated map object with the fill layer added.

Examples

# Load libraries
library(dplyr)
library(spData)
library(sf)

nz_data <- spData::nz |>
  dplyr::rename(geometry = geom) |>
  sf::st_transform(4326)

map() |>
 add_fill_layer(
   id = "nz_regions",
   source = nz_data,
   hover_column = "Name"
 )

map() |>
 add_fill_layer(
   id = "nz_regions",
   source = nz_data,
   hover_column = "Name",
   paint = get_paint_options(
     "fill",
     options = list(
       colour = "#a3b18a",
       opacity = 0.3,
       outline_colour = "#588157"
     )
   )
 )

Description

Add an image source to the map

Usage

add_image(map, image_id, image_url)

Arguments

Value

The map or map proxy object for chaining.

Examples

# Load libraries
library(sf)

# Prepare data
data(quakes)
quakes_data <- sf::st_as_sf(quakes, coords = c("long", "lat"), crs = 4326)

image_url <- paste0(
 "https://upload.wikimedia.org/wikipedia/en/thumb/0/02/",
 "Leaf_icon.png/600px-Leaf_icon.png"
)

 map() |>
   add_image(
     image_id = "leaf-icon",
     image_url = image_url
   ) |>
   add_symbol_layer(
     id = "leaf_symbols",
     source = sf::st_as_sf(quakes_data, coords = c("long", "lat"), crs = 4326),
     layout = get_layout_options(
       "symbol",
       options = list(
         icon_image = "leaf-icon",
         icon_size = 0.1
       )
     )
   )

Description

Add a grid of latitude and longitude lines to the map

Usage

add_lat_lng_grid(map, grid_colour = "#000000")

Arguments

Value

The map or map proxy object for chaining.

Examples

map() |>
 add_lat_lng_grid()

Description

Add a layer to a map or map proxy

Usage

add_layer(
  map,
  id,
  type = "fill",
  source,
  paint = NULL,
  layout = NULL,
  popup_column = NULL,
  hover_column = NULL,
  can_cluster = FALSE,
  under_id = NULL,
  filter = NULL,
  ...
)

Arguments

Value

The updated map object with the new layer added.

Note

If source is not a string referring to an existing source, it will be converted to a GeoJSON source and added to the map automatically. The Id for the source is generated by appending the layer Id to ⁠source-⁠. For example, if you add a layer with id = "my_layer" and source is a sf object, the source is added to the map with the ID "source-my_layer".

See Also

get_paint_options() for paint customisation, get_layout_options() for layout customisation, and get_layer_filter() for applying filters to layers.

Examples

# Load libraries
library(spData)
library(dplyr)
library(sf)

nz_data <- spData::nz |>
  dplyr::rename(geometry = geom) |>
  sf::st_transform(4326)

map() |>
 add_layer(
   id = "nz_regions",
   type = "fill",
   source = nz_data,
   hover_column = "Name"
 )

Description

Creates a drop-down selector that allows switching between layers, showing only the selected layer while hiding all others. This is useful for comparing different data layers or allowing users to choose between mutually exclusive visualizations.

Usage

add_layer_selector_control(
  map,
  layer_ids,
  labels = NULL,
  default_layer = NULL,
  none_option = FALSE,
  none_label = "None",
  position = "top-right",
  panel_id = NULL,
  section_title = NULL,
  group_id = NULL
)

Arguments

Value

The map or map proxy object for chaining.

Examples

# Load libraries
library(spData)
library(sf)

# Prepare data
data(quakes)
quakes_data <- quakes |>
 sf::st_as_sf(coords = c("long", "lat"), crs = 4326)

nz_data <- spData::nz_height |>
  sf::st_transform(4326)

map() |>
 add_circle_layer(
   id = "quakes",
   source = quakes_data
 ) |>
 add_circle_layer(
   id = "nz_elevation",
   source = nz_data
 ) |>
 add_layer_selector_control(
   layer_ids = c("quakes", "nz_elevation"),
   labels = c("quakes" = "Earthquakes", "nz_elevation" = "NZ Elevation")
 )

Description

Add a line layer to a map or map proxy

Usage

add_line_layer(
  map,
  id,
  source,
  paint = NULL,
  layout = NULL,
  popup_column = NULL,
  hover_column = NULL,
  can_cluster = FALSE,
  under_id = NULL,
  filter = NULL,
  ...
)

Arguments

Value

The updated map object with the line layer added.

Examples

# Load libraries
library(spData)
library(sf)

seine_data <- spData::seine |>
  sf::st_transform(4326)

map() |>
 set_bounds(bounds = seine_data, padding = 100) |>
 add_line_layer(
   id = "seine_lines",
   source = seine_data,
   hover_column = "name"
 )

map() |>
 set_bounds(bounds = seine_data, padding = 100) |>
 add_line_layer(
   id = "seine_lines",
   source = seine_data,
   hover_column = "name",
   paint = get_paint_options(
     "line",
     options = list(
       colour = get_column_group(
         "name",
         c("Marne" = "#014f86", "Seine" = "#61a5c2"),
         "#a9d6e5"
       ),
       line_width = get_column_group("name", c("Seine" = 3), 1)
     )
   )
 )

Description

A route is a line that can be animated along a set of points. This function adds a route to the map with a unique identifier and settings for the route's appearance and animation.

Usage

add_route(map, route_id, points, settings = list())

Arguments

Value

The map or map proxy object for chaining.

Examples

if(interactive()){
library(shiny)
library(toro)
library(sf)

line_data <- sf::st_sf(
  id = 1,
  geometry = sf::st_sfc(
    sf::st_linestring(
      cbind(c(172.2041, 163.9383), c(-32.56960, -46.43999))
    ),
    crs = 4326
  )
)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   actionButton("play_route", "Play Route Animation"),
   actionButton("pause_route", "Pause Route Animation"),
   actionButton("remove_route", "Remove Route")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
     add_route(route_id = "route_line", points = line_data)
 })

 observe({
   req(input$map_loaded)
   mapProxy("map") |>
     play_route(route_id = "route_line")
 }) |>
   bindEvent(input$play_route)

  observe({
   req(input$map_loaded)
   mapProxy("map") |>
     pause_route(route_id = "route_line")
 }) |>
   bindEvent(input$pause_route)

  observe({
   req(input$map_loaded)
   mapProxy("map") |>
     remove_route(route_id = "route_line")
 }) |>
   bindEvent(input$remove_route)
}
}

Description

Add a source to the map

Usage

add_source(map, source_id, data, type = "geojson", cluster = FALSE, ...)

Arguments

Value

The map or map proxy object for chaining.

Note

If you add a source directly in an add layer function, the source ID will be automatically generated as source-{layer-id}.

Examples

# Load libraries
library(sf)

# Prepare data
data(quakes)
quakes_data <- sf::st_as_sf(quakes, coords = c("long", "lat"), crs = 4326)

# Display the source on map
map() |>
  add_source(
    source_id = "my_source",
    data = sf::st_as_sf(quakes_data, coords = c("long", "lat"), crs = 4326)
  ) |>
  add_circle_layer(id = "quakes", source = "my_source")

Description

The speed control allows users to adjust the speed of an animation on the map, such as a time-based animation controlled by the timeline control. It can be added as a standalone control on the map or within a control panel for better organization of multiple controls.

Usage

add_speed_control(
  map,
  values = c(0.5, 1, 2),
  labels = c("Slow", "Normal", "Fast"),
  default_index = 2,
  position = "top-right",
  panel_id = NULL,
  section_title = NULL,
  group_id = NULL
)

Arguments

Value

The map or map proxy object for chaining.

Examples

# Add to a map (no dates specified)
map() |>
 add_speed_control()

# Change default options
map() |>
 add_speed_control(
   values = c(0.5, 1, 2, 5),
   labels = c("Slow", "Normal", "Fast", "Super fast"),
   default_index = 4 # Start on Super fast
 )

# Add to a control panel
map() |>
 add_control_panel(panel_id = "my_panel", title = "Map Settings") |>
 add_speed_control(panel_id = "my_panel")

# Add to a control panel inside a control group
map() |>
 add_control_panel(panel_id = "my_panel", title = "Map Settings") |>
 add_control_group(
   panel_id = "my_panel",
   group_id = "animation_controls",
   group_title = "Animation Controls"
 ) |>
 add_speed_control(
   panel_id = "my_panel",
   group_id = "animation_controls"
 )

Description

This layer is typically used for icons or pins.

Usage

add_symbol_layer(
  map,
  id,
  source,
  paint = NULL,
  layout = NULL,
  popup_column = NULL,
  hover_column = NULL,
  can_cluster = FALSE,
  under_id = NULL,
  filter = NULL,
  ...
)

Arguments

Value

The updated map object with the symbol layer added.

Examples

# Load libraries
library(sf)

# Prepare data
data(quakes)
quakes_data <- quakes |>
 sf::st_as_sf(coords = c("long", "lat"), crs = 4326)

# Create map and add fill layer
map() |>
 add_symbol_layer(
   id = "test_layer",
   source = quakes_data
 )

Description

This layer is typically used for text labels.

Usage

add_text_layer(
  map,
  id,
  source,
  paint = NULL,
  layout = NULL,
  popup_column = NULL,
  hover_column = NULL,
  can_cluster = FALSE,
  under_id = NULL,
  filter = NULL,
  ...
)

Arguments

Value

The updated map object with the text layer added.

Examples

# Load libraries
library(sf)

# Prepare data
data(quakes)
quakes_data <- quakes |>
 sf::st_as_sf(coords = c("long", "lat"), crs = 4326)

# Create map and add fill layer
map() |>
 add_text_layer(
   id = "test_layer",
   source = quakes_data
 )

Description

Add a tile selector control to the map or control panel

Usage

add_tile_selector_control(
  map,
  available_tiles = NULL,
  labels = NULL,
  default_tile = NULL,
  position = "top-right",
  panel_id = NULL,
  section_title = NULL,
  group_id = NULL
)

Arguments

Value

The map or map proxy object for chaining.

Examples

# Add a tile selector that gives the ability to switch between all available tilesets
all_tiles <- get_tile_options()

map(loadedTiles = all_tiles) |>
 add_tile_selector_control(available_tiles = all_tiles)

Description

The timeline control allows for users to interact with a date-based timeline, and can be used to control an animation of map data over time.

Usage

add_timeline_control(
  map,
  start_date = NULL,
  end_date = NULL,
  position = "bottom-left",
  max_ticks = 3,
  panel_id = NULL,
  section_title = NULL,
  group_id = NULL
)

Arguments

Value

The map or map proxy object for chaining.

Examples

# Add to a map (no dates specified)
map() |>
 add_timeline_control()

# Add to map with dates
map() |>
 add_timeline_control(
   start_date = Sys.Date(),
   end_date = Sys.Date() + 30
 )

# Add to a control panel
map() |>
 add_control_panel(panel_id = "my_panel", title = "Map Settings") |>
 add_timeline_control(
   start_date = Sys.Date(),
   end_date = Sys.Date() + 30,
   panel_id = "my_panel"
 )

# Add to a control panel inside a control group
map() |>
 add_control_panel(panel_id = "my_panel", title = "Map Settings") |>
 add_control_group(
   panel_id = "my_panel",
   group_id = "animation_controls",
   group_title = "Animation Controls"
 ) |>
 add_timeline_control(
   start_date = Sys.Date(),
   end_date = Sys.Date() + 30,
   panel_id = "my_panel",
   group_id = "animation_controls"
 )

Description

Creates a toggle button that can show/hide a specific layer.

Usage

add_visibility_toggle(
  map,
  layer_id,
  control_id = NULL,
  left_label = "Toggle Layer",
  right_label = NULL,
  initial_state = TRUE,
  position = "top-right",
  panel_id = NULL,
  section_title = NULL,
  group_id = NULL
)

Arguments

Value

The map or map proxy object for chaining.

Examples

# Load libraries
library(sf)

# Prepare data
data(quakes)
quakes_data <- quakes |>
 sf::st_as_sf(coords = c("long", "lat"), crs = 4326)

map() |>
 add_circle_layer(
   id = "quakes",
   source = quakes_data
 ) |>
 add_visibility_toggle(layer_id = "quakes")

Description

Add a zoom control to the map

Usage

add_zoom_control(
  map,
  position = "top-right",
  control_options = list(),
  panel_id = NULL,
  section_title = NULL,
  group_id = NULL
)

Arguments

Value

The map proxy object for chaining.

Note

See MapLibre NavigationControl docs for more information on available options.

Examples

add_zoom_control(map())

# Inside a control panel
map() |>
 add_control_panel(panel_id = "my_panel", title = "View Controls") |>
 add_zoom_control(panel_id = "my_panel")

Description

The ID of the shape is provided by the draw control when a shape is created.

Usage

delete_drawn_shape(proxy, shape_id)

Arguments

Value

The map proxy object for chaining.

Examples

if(interactive()){
library(shiny)
library(toro)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   selectInput("shape_ids", "Drawn shape IDs", choices = NULL),
   actionButton("remove_drawn_shape", "Remove drawn shape")
 )
)
server <- function(input, output, session) {
 drawn_shape_ids <- reactiveVal(character())

 output$map <- renderMap({
   map() |>
    add_draw_control()
 })

 # Update the select input options with current shape IDs
 observe({
   req(input$map_loaded)
   updateSelectInput(inputId = "shape_ids", choices = drawn_shape_ids())
 })

 # Update the list of drawn shape IDs when a new shape is created
 observe({
   req(input$map_loaded, input$map_shape_created)
   new_shape <- get_drawn_shape(input$map_shape_created)
   drawn_shape_ids(c(drawn_shape_ids(), new_shape$id))
 }) |>
   bindEvent(input$map_shape_created)

 # Delete the selected drawn shape when the button is clicked
 observe({
   req(input$map_loaded, input$shape_ids)
   mapProxy("map") |>
     delete_drawn_shape(input$shape_ids)
   # Remove the deleted shape ID from the list of drawn shape IDs
   drawn_shape_ids(setdiff(drawn_shape_ids(), input$shape_ids))
 }) |>
   bindEvent(input$remove_drawn_shape)
}
}

Description

This function exports a map widget as an image file using webshot2 or mapview. Works in non-Shiny contexts like RMarkdown, scripts, or interactive sessions.

Usage

export_map_image(
  map,
  filepath,
  width = 800,
  height = 600,
  delay = 2,
  zoom = 1,
  ...
)

Arguments

Value

The file path of the saved image (invisibly).

Examples

# Load library
library(sf)

data <- data.frame(lon = 174.8210, lat = -41.3096) |>
  sf::st_as_sf(coords = c("lon", "lat"), crs = 4326)
# Create and export a map
my_map <- map() |>
  add_circle_layer("epi_circle", source = data)

export_map_image(my_map, file.path(tempdir(), "my_map.png"), width = 1200, height = 800)

Description

The click input is a list containing the layerId, properties, geometry, and time. Turn this into an sf object.

Usage

get_clicked_feature(clicked_feature_input)

Arguments

Details

To get the clicked feature, use input$map_feature_click in a Shiny app, where map is the ID of your map output. This input will contain a list representing the clicked feature whenever a feature is clicked on the map. Pass this input to get_clicked_feature() to convert it into an sf object for easier manipulation in R.

Value

A sf object representing the clicked feature, or NULL.

Note

time is not used in this function, but it is included in the input so that the same feature can be clicked multiple times and the changed time means that the input will be updated.

Examples

if(interactive()){
library(shiny)
library(spData)
library(sf)
library(toro)

nz_data <- spData::nz_height |>
  sf::st_transform(4326)

ui <- fluidPage(
 tagList(
   mapOutput("map")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
     set_bounds(bounds = nz_data) |>
     add_circle_layer(
       id = "nz_elevation",
       source = nz_data
     )
 })

 # Print the clicked feature as an sf object
 observe({
   req(input$map_loaded, input$map_feature_click)
   print(get_clicked_feature(input$map_feature_click))
 }) |>
   bindEvent(input$map_feature_click)
}
}

Description

Allows the column value to be used for styling features in a map layer.

Usage

get_column(column_name)

Arguments

Value

List containing the paint or layout option to be set.

Examples

get_column("opacity")
get_column("icon")
# Use in a paint property: list("circle-color" = get_column("color"))

Description

Allows the data to be styled by the group option in the column.

Usage

get_column_boolean(column_name, true_value, false_value)

Arguments

Value

List containing the paint or layout option to be set.

Examples

get_column_boolean("group", "red", "grey")

Description

Allows the data to be styled by the group option in the column.

Usage

get_column_group(column_name, named_group_values, default_value = "#cccccc")

Arguments

Value

List containing the paint or layout option to be set.

Note

If using numbers as the group values, then you need to use stats::setNames rather than a named vector, as the names of the vector will be coerced to strings.

Examples

get_column_group("group", c("A" = "red", "B" = "blue"), "grey")
get_column_group("opacity", stats::setNames(c(0.3, 0.5), c("A", "B")), 0.6)

Description

Allows the data to be styled by the step breaks in the column.

Usage

get_column_steps(column_name, breaks, values)

Arguments

Value

List containing the paint or layout option to be set.

Examples

get_column_steps("value", c(10, 20, 30), c("red", "orange", "yellow", "green"))

Description

Parses the JSON string returned by the map widget when a shape is drawn. Ensures that the ID of the shape is included in the resulting sf object.

Usage

get_drawn_shape(create_input_string)

Arguments

Details

To get the drawn shape, use input$map_shape_created in a Shiny app, where map is the ID of your map output. This input will contain a JSON string representing the drawn shape whenever a new shape is created using the draw control on the map. Pass this input to get_drawn_shape() to convert it into an sf object for easier manipulation in R.

Value

A sf object representing the drawn shape, or NULL.

Examples

if(interactive()){
library(shiny)
library(toro)

ui <- fluidPage(
 tagList(
   mapOutput("map")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
    add_draw_control()
 })

 # Update the list of drawn shape IDs when a new shape is created
 observe({
   req(input$map_loaded, input$map_shape_created)
   new_shape <- get_drawn_shape(input$map_shape_created)
   print(new_shape)
 }) |>
   bindEvent(input$map_shape_created)
}
}

Description

Parse a filter string into a list of filters that the map can use.

Usage

get_layer_filter(filter_str)

Arguments

Value

A list where the first element is "all" if multiple filters are provided, or a single filter condition.

Examples

# Filter to only show rows where the "layer_id" column is equal to "forests"
get_layer_filter("layer_id == forests")

# Filter to show rows where the "layer_id" column is equal to "sites" and the "project_status"
# column is equal to "Confirmed"
get_layer_filter(c("layer_id == sites", "project_status == Confirmed"))

Description

This function returns a list of layout options based on the layer type and any additional options provided.

Usage

get_layout_options(layer_type, options = list())

Arguments

Value

A list of layout options suitable for the specified layer type.

Note

You can provide any layout options found in the MapLibre Layers docs in the options argument, and they will be included in the returned list. The default options are just a starting point and can be overridden by providing them in the options argument.

See Also

get_column() for getting options from column values directly, get_column_group() for getting options by spiliting column values into groups, and get_column_steps() for getting options by spiliting column values into groups based on steps.

Examples

get_layout_options("line", list(line_cap = "butt", line_join = "bevel"))

get_layout_options("symbol", list(icon_image = "yellow_pin", icon_size = 1.5))

# For horizontal flipping, provide left/right versions of your icon or use rotation fallback
get_layout_options("symbol", list(icon_image = "arrow", icon_flip_horizontal = TRUE))

# Provide options outside of the defaults
get_layout_options(
 "circle",
 list(
   "circle-sort-key" = get_column_steps(
     "elevation",
     c(3000),
     c(100, 200)
   )
 )
)

Description

This function returns a list of paint options based on the layer type and any additional options provided.

Usage

get_paint_options(layer_type, options = list())

Arguments

Value

A list of paint options suitable for the specified layer type.

Note

You can provide any paint options found in the MapLibre Layers docs in the options argument, and they will be included in the returned list. The default options are just a starting point and can be overridden by providing them in the options argument.

See Also

get_column() for getting options from column values directly, get_column_group() for getting options by spiliting column values into groups, and get_column_steps() for getting options by spiliting column values into groups based on steps.

Examples

get_paint_options("line", list(colour = "blue", opacity = 0.8, line_width = 2))

get_paint_options("circle", list(colour = "red", circle_radius = 10, outline_colour = "black"))

# Use with get_column for data-driven styling:
get_paint_options("fill", list(colour = get_column("color"), opacity = get_column("opacity")))

get_paint_options("fill", list(
   colour = get_column_group("group", c("A" = "green", "B" = "blue"))
))

get_paint_options("fill", list(
   opacity = get_column_steps("percent", c(25, 75), c("red", "orange", "yellow"))
))

# Provide options outside of the defaults
get_paint_options("circle", list("circle-blur" = 0.5))

Description

Get available tile layer options

Usage

get_tile_options()

Value

A character vector of available tile layer options.

Examples

all_tiles <- get_tile_options()

Description

Hide a layer from the map

Usage

hide_layer(proxy, layer_id)

Arguments

Value

The map proxy object for chaining.

Note

This does not remove the layer, it only hides it from view.

Examples

if(interactive()){
library(shiny)
library(sf)
library(toro)

data(quakes)
quakes_data <- sf::st_as_sf(quakes, coords = c("long", "lat"), crs = 4326)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   actionButton("show_layer", "Show Layer"),
   actionButton("hide_layer", "Hide Layer")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
     add_circle_layer(
       id = "quakes",
       source = quakes_data
     )
 })

 observe({
   mapProxy("map") |>
     show_layer(layer_id = "quakes")
 }) |>
   bindEvent(input$show_layer)

 observe({
   mapProxy("map") |>
     hide_layer(layer_id = "quakes")
 }) |>
   bindEvent(input$hide_layer)
}
}

Description

This function creates a map htmlwidget for use in R and Shiny applications.

Usage

map(
  style = "lightgrey",
  center = c(174, -41),
  zoom = 2,
  width = "100%",
  height = NULL,
  session = shiny::getDefaultReactiveDomain(),
  ...
)

Arguments

Value

An object of class htmlwidget representing the map.

Examples

map()

# Load two tilesets for the map to use
map(loadedTiles = c("natgeo", "streets"))

# Load two tilesets for the map to use and add maxzoom to satellite layer
map(loadedTiles = list(natgeo = list(), satellite = list(maxZoom = 2)))

Description

Create a MapLibre GL output for use in Shiny

Usage

mapOutput(outputId, width = "100%", height = "600px")

Arguments

Value

A MapLibre GL map for use in a Shiny UI.

Examples

if(interactive()){
library(shiny)
library(toro)

ui <- fluidPage(
 tagList(
   mapOutput("map")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map()
 })
}
}

Description

Create a proxy object for updating the map

Usage

mapProxy(outputId, session = shiny::getDefaultReactiveDomain())

Arguments

Value

A proxy object for the map.

Examples

if(interactive()){
library(shiny)
library(toro)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   checkboxInput("has_zoom_controls", "Remove Zoom Controls", value = TRUE)
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
     add_zoom_control()
 })

 observe({
   req(input$map_loaded)
   if (input$has_zoom_controls == TRUE) {
     mapProxy("map") |>
       add_zoom_control()
   } else {
     mapProxy("map") |>
       remove_zoom_control()
   }
 }) |>
   bindEvent(input$has_zoom_controls)
}
}

Description

Pause a route animation on a toro map

Usage

pause_route(map, route_id, settings = list())

Arguments

Value

The updated map proxy object.

Examples

if(interactive()){
library(shiny)
library(toro)
library(sf)

line_data <- sf::st_sf(
  id = 1,
  geometry = sf::st_sfc(
    sf::st_linestring(
      cbind(c(172.2041, 163.9383), c(-32.56960, -46.43999))
    ),
    crs = 4326
  )
)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   actionButton("play_route", "Play Route Animation"),
   actionButton("pause_route", "Pause Route Animation"),
   actionButton("remove_route", "Remove Route")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
     add_route(route_id = "route_line", points = line_data)
 })

 observe({
   req(input$map_loaded)
   mapProxy("map") |>
     play_route(route_id = "route_line")
 }) |>
   bindEvent(input$play_route)

  observe({
   req(input$map_loaded)
   mapProxy("map") |>
     pause_route(route_id = "route_line")
 }) |>
   bindEvent(input$pause_route)

  observe({
   req(input$map_loaded)
   mapProxy("map") |>
     remove_route(route_id = "route_line")
 }) |>
   bindEvent(input$remove_route)
}
}

Description

Play a route animation on a toro map

Usage

play_route(map, route_id, settings = list())

Arguments

Value

The updated map proxy object.

Examples

if(interactive()){
library(shiny)
library(toro)
library(sf)

line_data <- sf::st_sf(
  id = 1,
  geometry = sf::st_sfc(
    sf::st_linestring(
      cbind(c(172.2041, 163.9383), c(-32.56960, -46.43999))
    ),
    crs = 4326
  )
)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   actionButton("play_route", "Play Route Animation"),
   actionButton("pause_route", "Pause Route Animation"),
   actionButton("remove_route", "Remove Route")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
     add_route(route_id = "route_line", points = line_data)
 })

 observe({
   req(input$map_loaded)
   mapProxy("map") |>
     play_route(route_id = "route_line")
 }) |>
   bindEvent(input$play_route)

  observe({
   req(input$map_loaded)
   mapProxy("map") |>
     pause_route(route_id = "route_line")
 }) |>
   bindEvent(input$pause_route)

  observe({
   req(input$map_loaded)
   mapProxy("map") |>
     remove_route(route_id = "route_line")
 }) |>
   bindEvent(input$remove_route)
}
}

Description

Remove a cluster toggle control from the map

Usage

remove_cluster_toggle(proxy, layer_id, panel_id = NULL)

Arguments

Value

The map proxy object for chaining.

Examples

if(interactive()){
# Load libraries
library(shiny)
library(toro)
library(sf)

# Prepare data
data(quakes)
quakes_data <- quakes |>
 sf::st_as_sf(coords = c("long", "lat"), crs = 4326)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   actionButton("remove_control", "Remove cluster control")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   add_symbol_layer(
     id = "quakes",
     source = quakes_data,
     can_cluster = TRUE
   ) |>
   add_cluster_toggle(layer_id = "quakes")
 })

 observe({
   req(input$map_loaded)
   mapProxy("map") |>
     remove_cluster_toggle("quakes")
 }) |>
   bindEvent(input$remove_control)
}
}

Description

Remove a control from the map

Usage

remove_control(proxy, control_id)

Arguments

Value

The map proxy object for chaining.

Examples

if(interactive()){
library(shiny)
library(toro)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   actionButton("remove_controls", "Remove controls")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
     add_zoom_control() |>
     add_custom_control(
       id = "custom_control",
       html = "<p>I am a custom control</p>"
     )
 })

 observe({
   req(input$map_loaded)
   mapProxy("map") |>
     remove_control("zoom_control") |>
     remove_control("custom_control")
 }) |>
   bindEvent(input$remove_controls)
}
}

Description

Remove a control group from a control panel

Usage

remove_control_group(proxy, panel_id, group_id)

Arguments

Value

The map proxy object for chaining.

Examples

if(interactive()){
library(shiny)
library(toro)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   actionButton("remove_group1", "Remove control group 1")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
     add_control_panel(panel_id = "my_panel", title = "Map Settings") |>
     add_control_group(
       panel_id = "my_panel",
       group_id = "control_group1",
       group_title = "Control Group 1"
     ) |>
    add_control_group(
       panel_id = "my_panel",
       group_id = "control_group2",
       group_title = "Control Group 2"
     )
 })

 observe({
   req(input$map_loaded)
   mapProxy("map") |>
     remove_control_group(panel_id = "my_panel", group_id = "control_group1")
 }) |>
   bindEvent(input$remove_group1)
}
}

Description

Remove the cursor coordinates control from the map

Usage

remove_cursor_coords_control(proxy, panel_id = NULL)

Arguments

Value

The map proxy object for chaining.

Examples

if(interactive()){
library(shiny)
library(toro)

ui <- fluidPage(
 tagList(
   fluidRow(
     column(6, mapOutput("map_one")),
     column(6, mapOutput("map_two"))
   ),
   actionButton("remove_control", "Remove control")
 )
)
server <- function(input, output, session) {
 output$map_one <- renderMap({
   map() |>
     add_cursor_coords_control()
 })

 output$map_two <- renderMap({
   map() |>
     add_control_panel(panel_id = "my_panel", title = "Map Settings") |>
     add_cursor_coords_control(panel_id = "my_panel")
 })

 observe({
   req(input$map_one_loaded, input$map_two_loaded)
   mapProxy("map_one") |>
     remove_cursor_coords_control()
   mapProxy("map_two") |>
     remove_cursor_coords_control(panel_id = "my_panel")
 }) |>
   bindEvent(input$remove_control)
}
}

Description

Remove a custom control from the map

Usage

remove_custom_control(proxy, control_id, panel_id = NULL)

Arguments

Value

The map proxy object for chaining.

Examples

if(interactive()){
library(shiny)
library(toro)

ui <- fluidPage(
 tagList(
   fluidRow(
     column(6, mapOutput("map_one")),
     column(6, mapOutput("map_two"))
   ),
   actionButton("remove_control", "Remove control")
 )
)
server <- function(input, output, session) {
 output$map_one <- renderMap({
   map() |>
     add_custom_control(
       id = "custom_control",
       html = "<p>I am a custom control</p>"
     )
 })

 output$map_two <- renderMap({
   map() |>
     add_control_panel(panel_id = "my_panel", title = "Map Settings") |>
     add_custom_control(
       id = "custom_control",
       html = "<p>I am a custom control</p>",
       panel_id = "my_panel"
     )
 })

 observe({
   req(input$map_one_loaded, input$map_two_loaded)
   mapProxy("map_one") |>
     remove_custom_control("custom_control")
   mapProxy("map_two") |>
     remove_custom_control("custom_control", panel_id = "my_panel")
 }) |>
   bindEvent(input$remove_control)
}
}

Description

Remove the draw control from the map

Usage

remove_draw_control(proxy, panel_id = NULL)

Arguments

Value

The map proxy object for chaining.

Examples

if(interactive()){
library(shiny)
library(toro)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   actionButton("remove_draw_control", "Remove draw control")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
    add_draw_control()
 })

 observe({
   req(input$map_loaded)
   mapProxy("map") |>
     remove_draw_control()
 }) |>
   bindEvent(input$remove_draw_control)
}
}

Description

Remove the layer selector control from the map

Usage

remove_layer_selector_control(proxy, panel_id = NULL)

Arguments

Value

The map proxy object for chaining.

Examples

if(interactive()){
# Load libraries
library(shiny)
library(toro)
library(spData)
library(sf)

# Prepare data
data(quakes)
quakes_data <- quakes |>
 sf::st_as_sf(coords = c("long", "lat"), crs = 4326)

nz_data <- spData::nz_height |>
  sf::st_transform(4326)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   actionButton("remove_control", "Remove layer selector control")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
     add_circle_layer(
       id = "quakes",
       source = quakes_data
     ) |>
     add_circle_layer(
       id = "nz_elevation",
       source = nz_data
     ) |>
     add_layer_selector_control(
       layer_ids = c("quakes", "nz_elevation"),
       labels = c("quakes" = "Earthquakes", "nz_elevation" = "NZ Elevation")
     )
 })

 observe({
   req(input$map_loaded)
   mapProxy("map") |>
     remove_layer_selector_control()
 }) |>
   bindEvent(input$remove_control)
}
}

Description

Remove an animation route from a toro map

Usage

remove_route(map, route_id, settings = list())

Arguments

Value

The updated map proxy object.

Examples

if(interactive()){
library(shiny)
library(toro)
library(sf)

line_data <- sf::st_sf(
  id = 1,
  geometry = sf::st_sfc(
    sf::st_linestring(
      cbind(c(172.2041, 163.9383), c(-32.56960, -46.43999))
    ),
    crs = 4326
  )
)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   actionButton("play_route", "Play Route Animation"),
   actionButton("pause_route", "Pause Route Animation"),
   actionButton("remove_route", "Remove Route")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
     add_route(route_id = "route_line", points = line_data)
 })

 observe({
   req(input$map_loaded)
   mapProxy("map") |>
     play_route(route_id = "route_line")
 }) |>
   bindEvent(input$play_route)

  observe({
   req(input$map_loaded)
   mapProxy("map") |>
     pause_route(route_id = "route_line")
 }) |>
   bindEvent(input$pause_route)

  observe({
   req(input$map_loaded)
   mapProxy("map") |>
     remove_route(route_id = "route_line")
 }) |>
   bindEvent(input$remove_route)
}
}

Description

Remove the speed control from the map

Usage

remove_speed_control(proxy, panel_id = NULL)

Arguments

Value

The map proxy object for chaining.

Examples

# Add to a map
map() |>
 add_speed_control()

# Add to a control panel
map() |>
 add_control_panel(panel_id = "my_panel", title = "Map Settings") |>
 add_speed_control(panel_id = "my_panel")

Description

Remove the tile selector control from the map

Usage

remove_tile_selector_control(proxy, panel_id = NULL)

Arguments

Value

The map proxy object for chaining.

Examples

if(interactive()){
# Load libraries
library(shiny)
library(toro)

all_tiles <- get_tile_options()

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   actionButton("remove_control", "Remove tile selector control")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map(loadedTiles = all_tiles) |>
     add_tile_selector_control(available_tiles = all_tiles)
 })

 observe({
   req(input$map_loaded)
   mapProxy("map") |>
     remove_tile_selector_control()
 }) |>
   bindEvent(input$remove_control)
}
}

Description

Remove the timeline control from the map

Usage

remove_timeline_control(proxy, panel_id = NULL)

Arguments

Value

The map proxy object for chaining.

Examples

# Add to a map
map() |>
 add_timeline_control()

# Add to a control panel
map() |>
 add_control_panel(panel_id = "my_panel", title = "Map Settings") |>
 add_timeline_control(panel_id = "my_panel")

Description

Remove a visibility toggle control from the map

Usage

remove_visibility_toggle(proxy, layer_id, panel_id = NULL)

Arguments

Value

The map proxy object for chaining.

Examples

if(interactive()){
# Load libraries
library(shiny)
library(toro)
library(sf)

# Prepare data
data(quakes)
quakes_data <- quakes |>
 sf::st_as_sf(coords = c("long", "lat"), crs = 4326)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   actionButton("remove_control", "Remove visibility control")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   add_circle_layer(
     id = "quakes",
     source = quakes_data
   ) |>
   add_visibility_toggle(layer_id = "quakes")
 })

 observe({
   req(input$map_loaded)
   mapProxy("map") |>
     remove_visibility_toggle("quakes")
 }) |>
   bindEvent(input$remove_control)
}
}

Description

Remove the zoom control from the map

Usage

remove_zoom_control(proxy, panel_id = NULL)

Arguments

Value

The map proxy object for chaining.

Examples

if(interactive()){
library(shiny)
library(toro)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   checkboxInput("has_zoom_controls", "Remove Zoom Controls", value = TRUE)
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
     add_zoom_control()
 })

 observe({
   req(input$map_loaded)
   if (input$has_zoom_controls == TRUE) {
     mapProxy("map") |>
       add_zoom_control()
   } else {
     mapProxy("map") |>
       remove_zoom_control()
   }
 }) |>
   bindEvent(input$has_zoom_controls)
}
}

Description

Render a MapLibre GL map in Shiny

Usage

renderMap(expr, env = parent.frame(), quoted = FALSE)

Arguments

Value

A rendered MapLibre GL map for use in a Shiny server.

Examples

if(interactive()){
library(shiny)
library(toro)

ui <- fluidPage(
 tagList(
   mapOutput("map")
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map()
 })
}
}

Description

This function saves a map widget as a self-contained HTML file that can be opened in any web browser.

Usage

save_map_html(map, filepath, title = "Toro Map", selfcontained = TRUE, ...)

Arguments

Value

The file path of the saved HTML file (invisibly).

Examples

# Load library
library(sf)

data <- data.frame(lon = 174.8210, lat = -41.3096) |>
  sf::st_as_sf(coords = c("lon", "lat"), crs = 4326)
# Create and export a map
my_map <- map() |>
  add_circle_layer("epi_circle", source = data)

save_map_html(my_map, file.path(tempdir(), "my_map.html"))

Description

Set the map bounds

Usage

set_bounds(map, bounds, padding = 50, max_zoom = map$maxZoom)

Arguments

Value

The map or map proxy object for chaining.

Examples

# Load libraries
library(toro)
library(spData)
library(sf)

nz_data <- spData::nz_height |>
  sf::st_transform(4326)

map() |>
  set_bounds(list(list(-79, 43), list(-73, 45)))

map() |>
 set_bounds(bounds = nz_data)

Description

Set a layout property for a layer on the map

Usage

set_layout_property(proxy, layer_id, property_name, value)

Arguments

Value

The map proxy object for chaining.

Examples

if(interactive()){
library(shiny)
library(sf)
library(toro)

data(quakes)
quakes_data <- sf::st_as_sf(quakes, coords = c("long", "lat"), crs = 4326)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   selectInput(
     "text_column",
     "Select Text Column",
     choices = c("depth", "mag", "stations")
   )
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
     add_text_layer(
       id = "quakes",
       source = quakes_data,
       layout = get_layout_options(
         "text",
         options = list(
           text_field = get_column("depth")
         )
       )
     )
 })

 observe({
   req(input$map_loaded)
   mapProxy("map") |>
     set_layout_property(
       layer_id = "quakes",
       property_name = "text-field",
       value = get_column(input$text_column)
     )
 }) |>
   bindEvent(input$text_column)
}
}

Description

Set a paint property for a layer on the map

Usage

set_paint_property(proxy, layer_id, property_name, value)

Arguments

Value

The map proxy object for chaining.

Examples

if(interactive()){
library(shiny)
library(sf)
library(toro)

data(quakes)
quakes_data <- sf::st_as_sf(quakes, coords = c("long", "lat"), crs = 4326)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   selectInput(
     "colour",
     "Select Tile Layer",
     choices = c(
       "red",
       "orange",
       "yellow",
       "green",
       "blue",
       "indigo",
       "violet"
     )
   )
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
     add_circle_layer(id = "quakes", source = quakes_data)
 })

 observe({
   req(input$map_loaded)
   mapProxy("map") |>
     set_paint_property(
       layer_id = "quakes",
       property_name = "circle-color",
       value = input$colour
     )
 }) |>
   bindEvent(input$colour)
}
}

Description

Set data for a source on the map

Usage

set_source_data(proxy, source_id, data, type = "geojson")

Arguments

Value

The map proxy object for chaining.

Examples

if(interactive()){
library(shiny)
library(sf)
library(toro)

data(quakes)
quakes_data <- sf::st_as_sf(quakes, coords = c("long", "lat"), crs = 4326)

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   actionButton("btn", "Update Source Data")
 )
)
server <- function(input, output, session) {
 get_random_points <- function(data, n = 10) {
   random_rows <- runif(n, min = 1, max = nrow(data))
   return(data[random_rows, ])
 }

 output$map <- renderMap({
   map() |>
     add_symbol_layer(
       id = "quakes",
       source = get_random_points(quakes_data)
     )
   })
 observe({
   mapProxy("map") |>
     set_source_data(
       source_id = "source-quakes",
       data = get_random_points(quakes_data)
     )
 }) |>
 bindEvent(input$btn)
}
}