Package {toro}

Add animation controls to a toro map

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"),
  button_icons = list(),
  button_text = list(play = "Play", pause = "Pause", stop = "Stop"),
  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)
library(toro)

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,
    button_icons = list(play = "\u25b6", pause = "\u23f8", stop = "\u23f9"),
    button_text = list() # Remove labels, show only icons
  )

Add a circle layer to a map or map proxy

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")
       )
     )
   )
 )

Add a cluster toggle control to the map or control panel

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")

Add a control group to a control panel

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,
  collapse_config = list()
)

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,
    collapse_config = list(collapsed = TRUE),
    direction = "row"
  ) |>
  add_cursor_coords_control(
    panel_id = "my_panel",
    section_title = "Cursor Coordinates"
  )

Add a control panel to the map

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,
  collapse_config = list(),
  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,
    collapse_config = list(collapsed = TRUE),
    direction = "row"
  ) |>
  add_cursor_coords_control(
    panel_id = "my_panel",
    section_title = "Cursor Coordinates"
  )

Add a control to an existing control panel

Description

Used by other toro control functions to add controls to a panel.

Usage

add_control_to_panel(
  map,
  panel_id,
  control_type,
  control_options = list(),
  section_title = NULL,
  group_id = NULL
)

Arguments

Value

The map or map proxy object for chaining.

Add a cursor coordinates control to the map

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")

Add a custom HTML control to the map

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"
 )

Add a draw control to the map

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(),
  features = NULL,
  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()

Add a shape to the map as a drawn shape object

Description

Add a shape to the map as a drawn shape object

Usage

add_drawn_shape(proxy, new_geometry)

Arguments

Value

The map proxy object for chaining.

Examples

library(shiny)
library(dplyr)
library(sf)
library(toro)

get_polygon <- function() {
  random_offset <- runif(1, -10, 10)
  sf::st_sf(
    geometry = sf::st_sfc(
      sf::st_polygon(list(matrix(
        c(
          174.7,
          -36.8,
          174.8,
          -36.8,
          174.8,
          -36.9,
          174.7,
          -36.9,
          174.7,
          -36.8
        ) +
          random_offset,
        ncol = 2,
        byrow = TRUE
      ))),
      crs = 4326
    )
  )
}

ui <- bootstrapPage(
  tagList(
    mapOutput("map"),
    actionButton("add", "Add shape"),
    actionButton("update", "Update shape"),
    actionButton("delete", "Delete shape"),
    h2("Selected shape ID"),
    textOutput("selected_shape")
  )
)

server <- function(
  input,
  output,
  session
) {
  selected_shape_id <- reactiveVal(NULL)

  output$map <- renderMap({
    map() |>
      add_draw_control(
        modes = c("polygon", "line", "delete"),
        features = get_polygon()
      )
  })

  output$selected_shape <- renderText({
    selected_shape_id()
  })

  observe({
    print(input$map_feature_click)
    selected_shape_id(input$map_feature_click$properties$id)
  }) |>
    bindEvent(input$map_feature_click)

  observe({
    add_drawn_shape(mapProxy("map"), get_polygon())
    selected_shape_id(NULL)
  }) |>
    bindEvent(input$add)

  observe({
    req(selected_shape_id())
    update_drawn_shape(mapProxy("map"), selected_shape_id(), get_polygon())
  }) |>
    bindEvent(input$update)

  observe({
    req(selected_shape_id())
    delete_drawn_shape(mapProxy("map"), selected_shape_id())
    selected_shape_id(NULL)
  }) |>
    bindEvent(input$delete)
}

if (interactive()) {
  shinyApp(ui, server)
}

Add a FeatureService source to the map

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")

Add a fill layer to a map or map proxy

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"
     )
   )
 )

Add an image source to the map

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
       )
     )
   )

Add a grid of latitude and longitude lines to the map

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()

Add a layer to a map or map proxy

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"
 )

Add a layer selector control to the map or control panel

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(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)

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")
 )

Add a legend to a map for a specific layer

Description

Add a legend to a map for a specific layer

Usage

add_legend(
  map,
  layer_id,
  title = NULL,
  values = NULL,
  colours = NULL,
  options = list()
)

Arguments

Value

The modified map object with the added legend.

Examples

library(shiny)
library(dplyr)
library(sf)
library(toro)

data(quakes)
quakes_data <- quakes |>
  dplyr::mutate(
    description = paste(
      "<div class='map-popup'>Location:",
      lat,
      ",",
      long,
      "<br>",
      "Magnitude:",
      mag,
      "</div>"
    )
  ) |>
  sf::st_as_sf(coords = c("long", "lat"), crs = 4326, remove = FALSE)


ui <- fluidPage(
  toro::mapOutput("map"),
  div(
    class = "row",
    checkboxInput(
      "include_quakes_legend",
      "Include earthquakes magnitude legend",
      value = TRUE
    ),
    checkboxInput(
      "include_quakes_lat_legend",
      "Include earthquakes latitude legend",
      value = TRUE
    )
  )
)

colours <- c(
  "#440154FF",
  "#414487FF",
  "#2A788EFF",
  "#22A884FF",
  "#7AD151FF",
  "#FDE725FF"
)

server <- function(input, output, session) {
  # Render UI -------------------------------------------------------

  output$map <- toro::renderMap({
    toro::map() |>
      set_zoom(3) |>
      add_circle_layer(
        id = "quakes",
        source = quakes_data,
        hover_column = "description",
        paint = get_paint_options(
          "circle",
          options = list(
            color = get_column_steps(
              "mag",
              breaks = quantile(quakes_data$mag),
              values = colours
            )
          )
        )
      ) |>
      add_circle_layer(
        id = "quakes_lat",
        source = quakes_data,
        hover_column = "description",
        paint = get_paint_options(
          "circle",
          options = list(
            color = get_column_steps(
              "lat",
              breaks = quantile(quakes_data$lat),
              values = colours
            )
          )
        )
      ) |>
      add_legend(
        title = "Earthquake magnitude",
        layer_id = "quakes"
      ) |>
      add_legend(
        title = "Earthquake latitude",
        layer_id = "quakes_lat"
      ) |>
      add_layer_selector_control(
        layer_ids = c("quakes", "quakes_lat"),
        position = "top-left"
      )
  })

  # Observers -------------------------------------------------------------

  observe({
    req(input$map_loaded)
    if (input$include_quakes_legend == TRUE) {
      toro::mapProxy("map") |>
        add_legend(
          title = "Earthquake magnitude",
          layer_id = "quakes"
        )
    } else {
      toro::mapProxy("map") |>
        remove_legend(layer_id = "quakes")
    }
  }) |>
    bindEvent(input$include_quakes_legend)

  observe({
    req(input$map_loaded)
    if (input$include_quakes_lat_legend == TRUE) {
      toro::mapProxy("map") |>
        add_legend(
          title = "Earthquake latitude",
          layer_id = "quakes_lat"
        )
    } else {
      toro::mapProxy("map") |>
        remove_legend(layer_id = "quakes_lat")
    }
  }) |>
    bindEvent(input$include_quakes_lat_legend)
}

if (interactive()) {
  shinyApp(ui, server)
}

Add a line layer to a map or map proxy

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)
     )
   )
 )

Add a paint control to the map

Description

Allow for a layer to change paint properties based on user input.

Usage

add_paint_control(
  map,
  id,
  layer_id,
  options_list,
  label = NULL,
  default = NULL,
  position = "top-right",
  input_type = "select"
)

Arguments

Value

The modified map object.

Examples

library(shiny)
library(dplyr)
library(sf)
library(toro)


ui <- fluidPage(
  mapOutput("map"),
  actionButton("remove_control", "Remove paint control"),
  actionButton("add_control", "Add paint control")
)

nz_long <- c(
  172.2041,
  182.2494,
  168.1286,
  163.9383,
  171.7449
)
nz_lat <- c(
  -32.56960,
  -38.85522,
  -48.49620,
  -46.43999,
  -34.62533
)

nz_line <- sf::st_sf(
  id = 1,
  geometry = sf::st_sfc(sf::st_linestring(cbind(nz_long, nz_lat)), crs = 4326)
)

nz_points <- sf::st_cast(nz_line, "POINT") |>
  mutate(id = row_number())

nz_points$date <- seq.Date(
  from = as.Date("2026-01-01"),
  to = as.Date("2026-01-05"),
  by = "day"
)
nz_points$lat <- nz_lat
nz_points$long <- nz_long
nz_points$tici <- seq_len(nrow(nz_points))
nz_points$group <- c("A", "B", "A", "C", "D")
nz_points$colour <- c("red", "pink", "green", "orange", "blue")
nz_points$bool <- c(FALSE, FALSE, FALSE, TRUE, TRUE)

options_list <- list(
  list(
    id = "default",
    label = "Default",
    paint = get_paint_options(
      "circle",
      list(
        colour = "#FFCD00",
        circle_radius = 5,
        outline_colour = "black"
      )
    )
  ),
  list(
    id = "colour",
    label = "Colour",
    paint = get_paint_options(
      "circle",
      list(
        colour = get_column("colour"),
        circle_radius = 6,
        outline_colour = "white"
      )
    )
  ),
  list(
    id = "bool",
    label = "Bool",
    paint = get_paint_options(
      "circle",
      list(
        colour = get_column_boolean("bool", "white", "red"),
        circle_radius = 6,
        outline_colour = "white"
      )
    )
  ),
  list(
    id = "steps",
    label = "Steps",
    paint = get_paint_options(
      "circle",
      list(
        colour = get_column_steps(
          "long",
          c(171, 172, 178),
          c("red", "orange", "yellow", "green")
        ),
        circle_radius = 6,
        outline_colour = "white"
      )
    )
  ),
  list(
    id = "group",
    label = "Group",
    paint = get_paint_options(
      "circle",
      list(
        colour = get_column_group(
          "group",
          c("A" = "red", "B" = "yellow"),
          "white"
        ),
        circle_radius = 6,
        outline_colour = "white",
        opacity = get_column_group(
          "group",
          stats::setNames(c(0.9, 0.7), c("A", "B")),
          0.3
        )
      )
    )
  )
)

server <- function(input, output, session) {
  # Render UI -------------------------------------------------------

  output$map <- toro::renderMap({
    toro::map() |>
      set_zoom(3) |>
      add_source("my_source", nz_points) |>
      add_circle_layer("circle_layer", "my_source") |>
      add_paint_control(
        "my_paint_control",
        "circle_layer",
        options_list,
        label = "Index",
        default = "steps"
      )
  })

  # Observers -------------------------------------------------------------

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

  observe({
    req(input$map_loaded)
    add_paint_control(
      mapProxy("map"),
      "my_paint_control",
      "circle_layer",
      options_list,
      default = "bool"
    )
  }) |>
    bindEvent(input$add_control)
}

if (interactive()) {
  shinyApp(ui, server)
}

Add a route to a toro map which can be animated

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)
}
}

Add a scale control to the map

Description

Adds a distance scale bar to the map, wrapping MapLibre's native ScaleControl.

Usage

add_scale_control(
  map,
  id = "scale_control",
  max_width = 100,
  unit = c("metric", "imperial", "nautical"),
  position = "bottom-left"
)

Arguments

Value

The map or map proxy object for chaining.

Examples

map() |>
  add_scale_control()

map() |>
  add_scale_control(unit = "imperial", max_width = 100)

Add a source to the map

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")

Add a speed control to the map or control panel

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"
 )

Add a symbol layer to a map or map proxy

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
 )

Add a text layer to a map or map proxy

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
 )

Add a tile selector control to the map or control panel

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)

Add an Image Server source to a toro map

Description

WIP.

Usage

add_tiles_from_map_server(map, url, tile_id, as_image_layer = FALSE, ...)

Arguments

Value

The updated map object.

Add an Image Server source to a toro map

Description

WIP.

Usage

add_tiles_from_wms(map, url, tile_id, as_image_layer = FALSE, ...)

Arguments

Value

The updated map object.

Add a timeline control to the map or control panel

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,
  button_icons = list(),
  button_text = list()
)

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"
 )

Add a visibility toggle control to the map or control panel

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")

Add a zoom control to the map

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")

Check if Chrome or a Chromium-based browser is available

Description

Determines whether a Chrome/Chromium executable can be located, either via the CHROMOTE_CHROME environment variable or one of several common installation paths for macOS, Linux, and Windows. This is used to decide whether export_map_image() can render map images, since the underlying webshot packages require a Chromium-based browser to take screenshots.

Usage

check_chrome_available()

Value

A single logical value: TRUE if a Chrome/Chromium executable was found, FALSE otherwise.

Examples

check_chrome_available()

Provide helpful error message for missing Chrome

Description

Provide helpful error message for missing Chrome

Usage

chrome_error_message()

Value

No return value, prints to console.

Delete a drawn shape from the map

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)
}
}

Export map as an image (non-Shiny context)

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

if (check_chrome_available()) {
  # 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)
}

Get the sf data frame of a clicked feature from the map widget

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)
}
}

Get a column from a dataset to use as a paint or layout option in a map layer

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"))

Get the value for a paint or layout option in a map layer based on a column boolean value

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")

Get the values for a paint or layout option in a map layer based on a column value

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)

Get the properties for a column in a map layer based on step breaks

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"))

Get the drawn shape from the map widget

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)
}
}

Get a filter for a layer

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"))

Get layout options for a specific layer type

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)
   )
 )
)

Get paint options for a specific layer type

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))

Get available tile layer options

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()

Hide a layer from the map

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)
}
}

Helper function to convert local image to data URI

Description

Helper function to convert local image to data URI

Usage

image_to_data_uri(image_path)

Arguments

Value

A data URI string representing the image.

Helper function to detect if URL is a local file path

Description

Helper function to detect if URL is a local file path

Usage

is_local_file(url)

Arguments

Value

TRUE if it's a local file path, FALSE if it's a URL or data URI.

Create a MapLibre map widget

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)))

Create a MapLibre GL output for use in Shiny

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()
 })
}
}

Create a proxy object for updating the 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)
}
}

Pause a route animation on a toro map

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)
}
}

Play a route animation on a toro map

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)
}
}

Remove a cluster toggle control from the map

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)
}
}

Remove a control from the map

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)
}
}

Remove a control from a control panel

Description

Used by other toro control functions to remove controls from a panel.

Usage

remove_control_from_panel(proxy, panel_id, control_id)

Arguments

Value

The map proxy object for chaining.

Remove a control group from a control panel

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)
}
}

Remove the cursor coordinates control from the map

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)
}
}

Remove a custom control from the map

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)
}
}

Remove the draw control from the map

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)
}
}

Remove the layer selector control from the map

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)
}
}

Remove a legend from a map for a specific layer

Description

Remove a legend from a map for a specific layer

Usage

remove_legend(map, layer_id)

Arguments

Value

The modified map object with the removed legend.

Examples

library(shiny)
library(dplyr)
library(sf)
library(toro)

data(quakes)
quakes_data <- quakes |>
  dplyr::mutate(
    description = paste(
      "<div class='map-popup'>Location:",
      lat,
      ",",
      long,
      "<br>",
      "Magnitude:",
      mag,
      "</div>"
    )
  ) |>
  sf::st_as_sf(coords = c("long", "lat"), crs = 4326, remove = FALSE)


ui <- fluidPage(
  toro::mapOutput("map"),
  div(
    class = "row",
    checkboxInput(
      "include_quakes_legend",
      "Include earthquakes magnitude legend",
      value = TRUE
    ),
    checkboxInput(
      "include_quakes_lat_legend",
      "Include earthquakes latitude legend",
      value = TRUE
    )
  )
)

colours <- c(
  "#440154FF",
  "#414487FF",
  "#2A788EFF",
  "#22A884FF",
  "#7AD151FF",
  "#FDE725FF"
)

server <- function(input, output, session) {
  # Render UI -------------------------------------------------------

  output$map <- toro::renderMap({
    toro::map() |>
      set_zoom(3) |>
      add_circle_layer(
        id = "quakes",
        source = quakes_data,
        hover_column = "description",
        paint = get_paint_options(
          "circle",
          options = list(
            color = get_column_steps(
              "mag",
              breaks = quantile(quakes_data$mag),
              values = colours
            )
          )
        )
      ) |>
      add_circle_layer(
        id = "quakes_lat",
        source = quakes_data,
        hover_column = "description",
        paint = get_paint_options(
          "circle",
          options = list(
            color = get_column_steps(
              "lat",
              breaks = quantile(quakes_data$lat),
              values = colours
            )
          )
        )
      ) |>
      add_legend(
        title = "Earthquake magnitude",
        layer_id = "quakes"
      ) |>
      add_legend(
        title = "Earthquake latitude",
        layer_id = "quakes_lat"
      ) |>
      add_layer_selector_control(
        layer_ids = c("quakes", "quakes_lat"),
        position = "top-left"
      )
  })

  # Observers -------------------------------------------------------------

  observe({
    req(input$map_loaded)
    if (input$include_quakes_legend == TRUE) {
      toro::mapProxy("map") |>
        add_legend(
          title = "Earthquake magnitude",
          layer_id = "quakes"
        )
    } else {
      toro::mapProxy("map") |>
        remove_legend(layer_id = "quakes")
    }
  }) |>
    bindEvent(input$include_quakes_legend)

  observe({
    req(input$map_loaded)
    if (input$include_quakes_lat_legend == TRUE) {
      toro::mapProxy("map") |>
        add_legend(
          title = "Earthquake latitude",
          layer_id = "quakes_lat"
        )
    } else {
      toro::mapProxy("map") |>
        remove_legend(layer_id = "quakes_lat")
    }
  }) |>
    bindEvent(input$include_quakes_lat_legend)
}

if (interactive()) {
  shinyApp(ui, server)
}

Remove a paint control from the map

Description

Remove a paint control from the map

Usage

remove_paint_control(map, id)

Arguments

Value

The modified map object.

Examples

library(shiny)
library(dplyr)
library(sf)
library(toro)


ui <- fluidPage(
  mapOutput("map"),
  actionButton("remove_control", "Remove paint control"),
  actionButton("add_control", "Add paint control")
)

nz_long <- c(
  172.2041,
  182.2494,
  168.1286,
  163.9383,
  171.7449
)
nz_lat <- c(
  -32.56960,
  -38.85522,
  -48.49620,
  -46.43999,
  -34.62533
)

nz_line <- sf::st_sf(
  id = 1,
  geometry = sf::st_sfc(sf::st_linestring(cbind(nz_long, nz_lat)), crs = 4326)
)

nz_points <- sf::st_cast(nz_line, "POINT") |>
  mutate(id = row_number())

nz_points$date <- seq.Date(
  from = as.Date("2026-01-01"),
  to = as.Date("2026-01-05"),
  by = "day"
)
nz_points$lat <- nz_lat
nz_points$long <- nz_long
nz_points$tici <- seq_len(nrow(nz_points))
nz_points$group <- c("A", "B", "A", "C", "D")
nz_points$colour <- c("red", "pink", "green", "orange", "blue")
nz_points$bool <- c(FALSE, FALSE, FALSE, TRUE, TRUE)

options_list <- list(
  list(
    id = "default",
    label = "Default",
    paint = get_paint_options(
      "circle",
      list(
        colour = "#FFCD00",
        circle_radius = 5,
        outline_colour = "black"
      )
    )
  ),
  list(
    id = "colour",
    label = "Colour",
    paint = get_paint_options(
      "circle",
      list(
        colour = get_column("colour"),
        circle_radius = 6,
        outline_colour = "white"
      )
    )
  ),
  list(
    id = "bool",
    label = "Bool",
    paint = get_paint_options(
      "circle",
      list(
        colour = get_column_boolean("bool", "white", "red"),
        circle_radius = 6,
        outline_colour = "white"
      )
    )
  ),
  list(
    id = "steps",
    label = "Steps",
    paint = get_paint_options(
      "circle",
      list(
        colour = get_column_steps(
          "long",
          c(171, 172, 178),
          c("red", "orange", "yellow", "green")
        ),
        circle_radius = 6,
        outline_colour = "white"
      )
    )
  ),
  list(
    id = "group",
    label = "Group",
    paint = get_paint_options(
      "circle",
      list(
        colour = get_column_group(
          "group",
          c("A" = "red", "B" = "yellow"),
          "white"
        ),
        circle_radius = 6,
        outline_colour = "white",
        opacity = get_column_group(
          "group",
          stats::setNames(c(0.9, 0.7), c("A", "B")),
          0.3
        )
      )
    )
  )
)

server <- function(input, output, session) {
  # Render UI -------------------------------------------------------

  output$map <- toro::renderMap({
    toro::map() |>
      set_zoom(3) |>
      add_source("my_source", nz_points) |>
      add_circle_layer("circle_layer", "my_source") |>
      add_paint_control(
        "my_paint_control",
        "circle_layer",
        options_list,
        label = "Index",
        default = "steps"
      )
  })

  # Observers -------------------------------------------------------------

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

  observe({
    req(input$map_loaded)
    add_paint_control(
      mapProxy("map"),
      "my_paint_control",
      "circle_layer",
      options_list,
      default = "bool"
    )
  }) |>
    bindEvent(input$add_control)
}

if (interactive()) {
  shinyApp(ui, server)
}

Remove an animation route from a toro map

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)
}
}

Remove a scale control from the map

Description

Remove a scale control from the map

Usage

remove_scale_control(proxy, id = "scale_control")

Arguments

Value

The map proxy object for chaining.

Remove the speed control from the map

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")

Remove the tile selector control from the map

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)
}
}

Remove the timeline control from the map

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")

Remove a visibility toggle control from the map

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)
}
}

Remove the zoom control from the map

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)
}
}

Render a MapLibre GL map in Shiny

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()
 })
}
}

Save map as standalone HTML file

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"))

Set the map bounds

Description

Set the map bounds

Usage

set_bounds(
  map,
  bounds,
  padding = 50,
  options = list(maxZoom = map$maxZoom, linear = FALSE)
)

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)

Set a layout property for a layer on the map

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)
}
}

Set a paint property for a layer on the map

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)
}
}

Update the unit of an existing scale control

Description

Update the unit of an existing scale control

Usage

set_scale_control_unit(
  proxy,
  id = "scale_control",
  unit = c("metric", "imperial", "nautical")
)

Arguments

Value

The map proxy object for chaining.

Set data for a source on the map

Description

Set data for a source on the map

Usage

set_source_data(
  proxy,
  source_id,
  data,
  type = "geojson",
  options = list(bounds = NULL, padding = 50, max_zoom = NULL, linear = FALSE)
)

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)
}
}

Set the tile layer for the map

Description

Set the tile layer for the map

Usage

set_tile_layer(map, tiles)

Arguments

Value

The map or map proxy object for chaining.

See Also

get_tile_options() for retrieving all tile options.

Examples

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

all_tiles <- get_tile_options()

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   selectInput("tile_layer", "Select Tile Layer", choices = all_tiles)
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map(loadedTiles = all_tiles)
 })

 observe({
   mapProxy("map") |>
     set_tile_layer(tiles = input$tile_layer)
 }) |>
   bindEvent(input$tile_layer)
}
}

Set the map zoom level

Description

Set the map zoom level

Usage

set_zoom(map, zoom)

Arguments

Value

The map or map proxy object for chaining.

Examples

 map() |>
  set_zoom(5)

Show a previously hidden layer on the map

Description

Show a previously hidden layer on the map

Usage

show_layer(proxy, layer_id)

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("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)
}
}

Toggle clustering for a layer on the map

Description

Toggle clustering for a layer on the map

Usage

toggle_clustering(proxy, layer_id, cluster = FALSE)

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"),
   checkboxInput("toggle_cluster", "Toggle Clustering", value = TRUE)
 )
)
server <- function(input, output, session) {
 output$map <- renderMap({
   map() |>
     add_symbol_layer(
       id = "quakes",
       source = quakes_data,
       can_cluster = TRUE
     )
 })

 observe({
   mapProxy("map") |>
     toggle_clustering(layer_id = "quakes", cluster = input$toggle_cluster)
 }) |>
   bindEvent(input$toggle_cluster)
}
}

Toggle the visibility of a control on the map

Description

Toggle the visibility of a control on the map

Usage

toggle_control(proxy, control_id, show = TRUE)

Arguments

Value

The map proxy object for chaining.

Examples

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

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   checkboxInput("show_controls", "Show controls", value = TRUE)
 )
)
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") |>
     toggle_control("zoom_control", show = input$show_controls) |>
     toggle_control("custom_control", show = input$show_controls)
 }) |>
   bindEvent(input$show_controls)
}
}

Show/hide the latitude and longitude grid on the map

Description

Show/hide the latitude and longitude grid on the map

Usage

toggle_lat_lng_grid(proxy, show = TRUE)

Arguments

Value

The map proxy object for chaining.

Examples

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

ui <- fluidPage(
 tagList(
   mapOutput("map"),
   actionButton("show_grid", "Show Grid"),
   actionButton("hide_grid", "Hide Grid")
 )
)
server <- function(input, output, session) {

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

  observe({
    mapProxy("map") |>
      toggle_lat_lng_grid(show = TRUE)
  }) |>
    bindEvent(input$show_grid)

  observe({
    mapProxy("map") |>
      toggle_lat_lng_grid(show = FALSE)
   }) |>
     bindEvent(input$hide_grid)
}
}

Show or hide a scale control on the map

Description

Show or hide a scale control on the map

Usage

toggle_scale_control(proxy, id = "scale_control", show = TRUE)

Arguments

Value

The map proxy object for chaining.

Examples

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

ui <- fluidPage(
  tagList(
    mapOutput("map"),
    checkboxInput("show_scale", "Show scale control", value = TRUE)
  )
)
server <- function(input, output, session) {
  output$map <- renderMap({
    map() |> add_scale_control()
  })

  observe({
    req(input$map_loaded)
    mapProxy("map") |>
      toggle_scale_control(show = input$show_scale)
  }) |>
    bindEvent(input$show_scale)
}
}

Update the geometry of an existing drawn shape on the map

Description

Update the geometry of an existing drawn shape on the map

Usage

update_drawn_shape(proxy, shape_id, new_geometry)

Arguments

Value

The map proxy object for chaining.

Examples

library(shiny)
library(dplyr)
library(sf)
library(toro)

get_polygon <- function() {
  random_offset <- runif(1, -10, 10)
  sf::st_sf(
    geometry = sf::st_sfc(
      sf::st_polygon(list(matrix(
        c(
          174.7,
          -36.8,
          174.8,
          -36.8,
          174.8,
          -36.9,
          174.7,
          -36.9,
          174.7,
          -36.8
        ) +
          random_offset,
        ncol = 2,
        byrow = TRUE
      ))),
      crs = 4326
    )
  )
}

ui <- bootstrapPage(
  tagList(
    mapOutput("map"),
    actionButton("add", "Add shape"),
    actionButton("update", "Update shape"),
    actionButton("delete", "Delete shape"),
    h2("Selected shape ID"),
    textOutput("selected_shape")
  )
)

server <- function(
  input,
  output,
  session
) {
  selected_shape_id <- reactiveVal(NULL)

  output$map <- renderMap({
    map() |>
      add_draw_control(
        modes = c("polygon", "line", "delete"),
        features = get_polygon()
      )
  })

  output$selected_shape <- renderText({
    selected_shape_id()
  })

  observe({
    print(input$map_feature_click)
    selected_shape_id(input$map_feature_click$properties$id)
  }) |>
    bindEvent(input$map_feature_click)

  observe({
    add_drawn_shape(mapProxy("map"), get_polygon())
    selected_shape_id(NULL)
  }) |>
    bindEvent(input$add)

  observe({
    req(selected_shape_id())
    update_drawn_shape(mapProxy("map"), selected_shape_id(), get_polygon())
  }) |>
    bindEvent(input$update)

  observe({
    req(selected_shape_id())
    delete_drawn_shape(mapProxy("map"), selected_shape_id())
    selected_shape_id(NULL)
  }) |>
    bindEvent(input$delete)
}

if (interactive()) {
  shinyApp(ui, server)
}

Get the bounds in the correct format

Description

This function takes either a list of two coordinate pairs or an sf object and returns the bounds in the correct format for the JS function.

Usage

validate_bounds(bounds)

Arguments

Value

A list of two coordinate pairs in the format list(list(lon1, lat1), list(lon2, lat2)).