Type:	Package
Title:	Create Interactive Web Maps with the JavaScript 'Leaflet' Library
Version:	2.2.2
Description:	Create and customize interactive maps using the 'Leaflet' JavaScript library and the 'htmlwidgets' package. These maps can be used directly from the R console, from 'RStudio', in Shiny applications and R Markdown documents.
License:	GPL-3
URL:	https://rstudio.github.io/leaflet/, https://github.com/rstudio/leaflet
BugReports:	https://github.com/rstudio/leaflet/issues
Depends:	R (≥ 3.1.0)
Imports:	crosstalk, htmltools, htmlwidgets (≥ 1.5.4), jquerylib, leaflet.providers (≥ 2.0.0), magrittr, methods, png, raster (≥ 3.6.3), RColorBrewer, scales (≥ 1.0.0), sp, stats, viridisLite, xfun
Suggests:	knitr, maps, purrr, R6, RJSONIO, rmarkdown, s2, sf (≥ 0.9-6), shiny, terra, testthat (≥ 3.0.0)
Config/testthat/edition:	3
Config/Needs/website:	dplyr, geojsonio, ncdf4, tidyverse/tidytemplate
Encoding:	UTF-8
LazyData:	true
RoxygenNote:	7.3.1
NeedsCompilation:	no
Packaged:	2024-03-25 22:40:52 UTC; cpsievert
Author:	Joe Cheng [aut, cre], Barret Schloerke [aut], Bhaskar Karambelkar [aut], Yihui Xie [aut], Hadley Wickham [ctb], Kenton Russell [ctb], Kent Johnson [ctb], Vladimir Agafonkin [ctb, cph] (Leaflet library), CloudMade [cph] (Leaflet library), Leaflet contributors [ctb] (Leaflet library), Brandon Copeland [ctb, cph] (leaflet-measure plugin), Joerg Dietrich [ctb, cph] (Leaflet.Terminator plugin), Benjamin Becquet [ctb, cph] (Leaflet.MagnifyingGlass plugin), Norkart AS [ctb, cph] (Leaflet.MiniMap plugin), L. Voogdt [ctb, cph] (Leaflet.awesome-markers plugin), Daniel Montague [ctb, cph] (Leaflet.EasyButton plugin), Kartena AB [ctb, cph] (Proj4Leaflet plugin), Robert Kajic [ctb, cph] (leaflet-locationfilter plugin), Mapbox [ctb, cph] (leaflet-omnivore plugin), Michael Bostock [ctb, cph] (topojson), Posit Software, PBC [cph, fnd]
Maintainer:	Joe Cheng <joe@posit.co>
Repository:	CRAN
Date/Publication:	2024-03-26 19:10:06 UTC

leaflet: Create Interactive Web Maps with the JavaScript 'Leaflet' Library

Description

Create and customize interactive maps using the 'Leaflet' JavaScript library and the 'htmlwidgets' package. These maps can be used directly from the R console, from 'RStudio', in Shiny applications and R Markdown documents.

Author(s)

Maintainer: Joe Cheng joe@posit.co

Authors:

• Barret Schloerke barret@posit.co (ORCID)

• Bhaskar Karambelkar

• Yihui Xie

Other contributors:

• Hadley Wickham [contributor]

• Kenton Russell [contributor]

• Kent Johnson [contributor]

• Vladimir Agafonkin (Leaflet library) [contributor, copyright holder]

• CloudMade (Leaflet library) [copyright holder]

• Leaflet contributors (Leaflet library) [contributor]

• Brandon Copeland (leaflet-measure plugin) [contributor, copyright holder]

• Joerg Dietrich (Leaflet.Terminator plugin) [contributor, copyright holder]

• Benjamin Becquet (Leaflet.MagnifyingGlass plugin) [contributor, copyright holder]

• Norkart AS (Leaflet.MiniMap plugin) [contributor, copyright holder]

• L. Voogdt (Leaflet.awesome-markers plugin) [contributor, copyright holder]

• Daniel Montague (Leaflet.EasyButton plugin) [contributor, copyright holder]

• Kartena AB (Proj4Leaflet plugin) [contributor, copyright holder]

• Robert Kajic (leaflet-locationfilter plugin) [contributor, copyright holder]

• Mapbox (leaflet-omnivore plugin) [contributor, copyright holder]

• Michael Bostock (topojson) [contributor, copyright holder]

• Posit Software, PBC [copyright holder, funder]

See Also

Useful links:

• https://rstudio.github.io/leaflet/

• https://github.com/rstudio/leaflet

• Report bugs at https://github.com/rstudio/leaflet/issues

Visual Testing scripts for vistest

Description

Visual testing examples to be used by the vistest package.

Examples

### Start addGeoJSON properties - https://github.com/rstudio/leaflet/pull/625
polygon = list(
  type = "Polygon",
  coordinates = list(
    list(
      c(8.330469, 48.261570),
      c(8.339052, 48.261570),
      c(8.339052, 48.258227),
      c(8.330469, 48.258227),
      c(8.330469, 48.261570)
    )
  )
)

# should produce an orange-ish rectangle around `Ramsel`
leaflet() %>%
  addTiles() %>%
  addGeoJSON(polygon, color="#F00") %>%
  setView(lng = 8.330469, lat = 48.26157, zoom = 15)
### End PR #625


 # end donttest

Add Awesome Markers

Description

Add Awesome Markers

Usage

addAwesomeMarkers(
  map,
  lng = NULL,
  lat = NULL,
  layerId = NULL,
  group = NULL,
  icon = NULL,
  popup = NULL,
  popupOptions = NULL,
  label = NULL,
  labelOptions = NULL,
  options = markerOptions(),
  clusterOptions = NULL,
  clusterId = NULL,
  data = getMapData(map)
)

Arguments

Graphics elements and layers

Description

Add graphics elements and layers to the map widget.

Usage

addControl(
  map,
  html,
  position = c("topleft", "topright", "bottomleft", "bottomright"),
  layerId = NULL,
  className = "info legend",
  data = getMapData(map)
)

addTiles(
  map,
  urlTemplate = "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
  attribution = NULL,
  layerId = NULL,
  group = NULL,
  options = tileOptions(),
  data = getMapData(map)
)

addWMSTiles(
  map,
  baseUrl,
  layerId = NULL,
  group = NULL,
  options = WMSTileOptions(),
  attribution = NULL,
  layers = "",
  data = getMapData(map)
)

addPopups(
  map,
  lng = NULL,
  lat = NULL,
  popup,
  layerId = NULL,
  group = NULL,
  options = popupOptions(),
  data = getMapData(map)
)

addMarkers(
  map,
  lng = NULL,
  lat = NULL,
  layerId = NULL,
  group = NULL,
  icon = NULL,
  popup = NULL,
  popupOptions = NULL,
  label = NULL,
  labelOptions = NULL,
  options = markerOptions(),
  clusterOptions = NULL,
  clusterId = NULL,
  data = getMapData(map)
)

addLabelOnlyMarkers(
  map,
  lng = NULL,
  lat = NULL,
  layerId = NULL,
  group = NULL,
  icon = NULL,
  label = NULL,
  labelOptions = NULL,
  options = markerOptions(),
  clusterOptions = NULL,
  clusterId = NULL,
  data = getMapData(map)
)

addCircleMarkers(
  map,
  lng = NULL,
  lat = NULL,
  radius = 10,
  layerId = NULL,
  group = NULL,
  stroke = TRUE,
  color = "#03F",
  weight = 5,
  opacity = 0.5,
  fill = TRUE,
  fillColor = color,
  fillOpacity = 0.2,
  dashArray = NULL,
  popup = NULL,
  popupOptions = NULL,
  label = NULL,
  labelOptions = NULL,
  options = pathOptions(),
  clusterOptions = NULL,
  clusterId = NULL,
  data = getMapData(map)
)

highlightOptions(
  stroke = NULL,
  color = NULL,
  weight = NULL,
  opacity = NULL,
  fill = NULL,
  fillColor = NULL,
  fillOpacity = NULL,
  dashArray = NULL,
  bringToFront = NULL,
  sendToBack = NULL
)

addCircles(
  map,
  lng = NULL,
  lat = NULL,
  radius = 10,
  layerId = NULL,
  group = NULL,
  stroke = TRUE,
  color = "#03F",
  weight = 5,
  opacity = 0.5,
  fill = TRUE,
  fillColor = color,
  fillOpacity = 0.2,
  dashArray = NULL,
  popup = NULL,
  popupOptions = NULL,
  label = NULL,
  labelOptions = NULL,
  options = pathOptions(),
  highlightOptions = NULL,
  data = getMapData(map)
)

addPolylines(
  map,
  lng = NULL,
  lat = NULL,
  layerId = NULL,
  group = NULL,
  stroke = TRUE,
  color = "#03F",
  weight = 5,
  opacity = 0.5,
  fill = FALSE,
  fillColor = color,
  fillOpacity = 0.2,
  dashArray = NULL,
  smoothFactor = 1,
  noClip = FALSE,
  popup = NULL,
  popupOptions = NULL,
  label = NULL,
  labelOptions = NULL,
  options = pathOptions(),
  highlightOptions = NULL,
  data = getMapData(map)
)

addRectangles(
  map,
  lng1,
  lat1,
  lng2,
  lat2,
  layerId = NULL,
  group = NULL,
  stroke = TRUE,
  color = "#03F",
  weight = 5,
  opacity = 0.5,
  fill = TRUE,
  fillColor = color,
  fillOpacity = 0.2,
  dashArray = NULL,
  smoothFactor = 1,
  noClip = FALSE,
  popup = NULL,
  popupOptions = NULL,
  label = NULL,
  labelOptions = NULL,
  options = pathOptions(),
  highlightOptions = NULL,
  data = getMapData(map)
)

addPolygons(
  map,
  lng = NULL,
  lat = NULL,
  layerId = NULL,
  group = NULL,
  stroke = TRUE,
  color = "#03F",
  weight = 5,
  opacity = 0.5,
  fill = TRUE,
  fillColor = color,
  fillOpacity = 0.2,
  dashArray = NULL,
  smoothFactor = 1,
  noClip = FALSE,
  popup = NULL,
  popupOptions = NULL,
  label = NULL,
  labelOptions = NULL,
  options = pathOptions(),
  highlightOptions = NULL,
  data = getMapData(map)
)

addGeoJSON(
  map,
  geojson,
  layerId = NULL,
  group = NULL,
  stroke = TRUE,
  color = "#03F",
  weight = 5,
  opacity = 0.5,
  fill = TRUE,
  fillColor = color,
  fillOpacity = 0.2,
  dashArray = NULL,
  smoothFactor = 1,
  noClip = FALSE,
  options = pathOptions(),
  data = getMapData(map)
)

addTopoJSON(
  map,
  topojson,
  layerId = NULL,
  group = NULL,
  stroke = TRUE,
  color = "#03F",
  weight = 5,
  opacity = 0.5,
  fill = TRUE,
  fillColor = color,
  fillOpacity = 0.2,
  dashArray = NULL,
  smoothFactor = 1,
  noClip = FALSE,
  options = pathOptions()
)

Arguments

Value

the new map object

Functions

• addControl(): Add arbitrary HTML controls to the map

• addTiles(): Add a tile layer to the map

• addWMSTiles(): Add a WMS tile layer to the map

• addPopups(): Add popups to the map

• addMarkers(): Add markers to the map

• addLabelOnlyMarkers(): Add Label only markers to the map

• addCircleMarkers(): Add circle markers to the map

• highlightOptions(): Options to highlight a shape on hover

• addCircles(): Add circles to the map

• addPolylines(): Add polylines to the map

• addRectangles(): Add rectangles to the map

• addPolygons(): Add polygons to the map

• addGeoJSON(): Add GeoJSON layers to the map

• addTopoJSON(): Add TopoJSON layers to the map

References

The Leaflet API documentation: https://web.archive.org/web/20220702182250/https://leafletjs.com/reference-1.3.4.html

See Also

tileOptions, WMSTileOptions, popupOptions, markerOptions, pathOptions

Add a Graticule on the map see https://github.com/turban/Leaflet.Graticule

Description

Add a Graticule on the map see https://github.com/turban/Leaflet.Graticule

Usage

addGraticule(
  map,
  interval = 20,
  sphere = FALSE,
  style = list(color = "#333", weight = 1),
  layerId = NULL,
  group = NULL,
  options = pathOptions(pointerEvents = "none", clickable = FALSE)
)

Arguments

Examples

leaf <- leaflet() %>%
  addTiles() %>%
  addGraticule()
leaf

Add UI controls to switch layers on and off

Description

Uses Leaflet's built-in layers control feature to allow users to choose one of several base layers, and to choose any number of overlay layers to view.

Usage

addLayersControl(
  map,
  baseGroups = character(0),
  overlayGroups = character(0),
  position = c("topright", "bottomright", "bottomleft", "topleft"),
  options = layersControlOptions(),
  data = getMapData(map)
)

layersControlOptions(collapsed = TRUE, autoZIndex = TRUE, ...)

removeLayersControl(map)

Arguments

Examples

leaflet() %>%
  addTiles(group = "OpenStreetMap") %>%
  addProviderTiles("Stamen.Toner", group = "Toner by Stamen") %>%
  addMarkers(runif(20, -75, -74), runif(20, 41, 42), group = "Markers") %>%
  addLayersControl(
    baseGroups = c("OpenStreetMap", "Toner by Stamen"),
    overlayGroups = c("Markers")
  )

Add a color legend to a map

Description

When a color palette function is used in a map (e.g. colorNumeric), a color legend can be automatically derived from the palette function. You can also manually specify the colors and labels for the legend.

Usage

addLegend(
  map,
  position = c("topright", "bottomright", "bottomleft", "topleft"),
  pal,
  values,
  na.label = "NA",
  bins = 7,
  colors,
  opacity = 0.5,
  labels = NULL,
  labFormat = labelFormat(),
  title = NULL,
  className = "info legend",
  layerId = NULL,
  group = NULL,
  data = getMapData(map)
)

labelFormat(
  prefix = "",
  suffix = "",
  between = " – ",
  digits = 3,
  big.mark = ",",
  transform = identity
)

Arguments

Details

The labFormat argument is a function that takes the argument type = c("numeric", "bin", "quantile", "factor"), plus, arguments for different types of color palettes. For the colorNumeric() palette, labFormat takes a single argument, which is the breaks of the numeric vector, and returns a character vector of the same length. For colorBin(), labFormat also takes a vector of breaks of length n but should return a character vector of length n - 1, with the i-th element representing the interval c(x[i], x[i + 1]). For colorQuantile, labFormat takes two arguments, the quantiles and the associated probabilities (each of length n), and should return a character vector of length n - 1 (similar to the colorBin() palette). For colorFactor(), labFormat takes one argument, the unique values of the factor, and should return a character vector of the same length.

By default, labFormat is basically format(scientific = FALSE, big.mark = ",") for the numeric palette, as.character() for the factor palette, and a function to return labels of the form ‘⁠x[i] - x[i + 1]⁠’ for bin and quantile palettes (in the case of quantile palettes, x is the probabilities instead of the values of breaks).

Examples

# !formatR
library(leaflet)
# a manual legend
leaflet() %>% addTiles() %>% addLegend(
  position = "bottomright",
  colors = rgb(t(col2rgb(palette())) / 255),
  labels = palette(), opacity = 1,
  title = "An Obvious Legend"
)



# an automatic legend derived from the color palette
df <- local({
  n <- 300; x <- rnorm(n); y <- rnorm(n)
  z <- sqrt(x ^ 2 + y ^ 2); z[sample(n, 10)] <- NA
  data.frame(x, y, z)
})
pal <- colorNumeric("OrRd", df$z)
leaflet(df) %>%
  addTiles() %>%
  addCircleMarkers(~x, ~y, color = ~pal(z), group = "circles") %>%
  addLegend(pal = pal, values = ~z, group = "circles", position = "bottomleft") %>%
  addLayersControl(overlayGroups = c("circles"))

# format legend labels
df <- data.frame(x = rnorm(100), y = rexp(100, 2), z = runif(100))
pal <- colorBin("PuOr", df$z, bins = c(0, .1, .4, .9, 1))
leaflet(df) %>%
  addTiles() %>%
  addCircleMarkers(~x, ~y, color = ~pal(z), group = "circles") %>%
  addLegend(pal = pal, values = ~z, group = "circles", position = "bottomleft") %>%
  addLayersControl(overlayGroups = c("circles"))

leaflet(df) %>%
  addTiles() %>%
  addCircleMarkers(~x, ~y, color = ~pal(z), group = "circles") %>%
  addLegend(pal = pal, values = ~z, labFormat = labelFormat(
    prefix = "(", suffix = ")%", between = ", ",
    transform = function(x) 100 * x
  ),  group = "circles", position = "bottomleft" ) %>%
  addLayersControl(overlayGroups = c("circles"))

Add additional panes to leaflet map to control layer order

Description

map panes can be created by supplying a name and a zIndex to control layer ordering. We recommend a zIndex value between 400 (the default overlay pane) and 500 (the default shadow pane). You can then use this pane to render overlays (points, lines, polygons) by setting the pane argument in leafletOptions. This will give you control over the order of the layers, e.g. points always on top of polygons. If two layers are provided to the same pane, overlay will be determined by order of adding. See examples below. See https://web.archive.org/web/20220702182250/https://leafletjs.com/reference-1.3.4.html#map-pane for details.

If the error "Cannot read property 'appendChild' of undefined" occurs, make sure the pane being used for used for display has already been added to the map.

Usage

addMapPane(map, name, zIndex)

Arguments

Examples

rand_lng <- function(n = 10) rnorm(n, -93.65, .01)
rand_lat <- function(n = 10) rnorm(n, 42.0285, .01)

random_data <- data.frame(
  lng = rand_lng(50),
  lat = rand_lat(50),
  radius = runif(50, 50, 150),
  circleId = paste0("circle #", 1:50),
  lineId = paste0("circle #", 1:50)
)

# display circles (zIndex: 420) above the lines (zIndex: 410), even when added first
leaflet() %>%
  addTiles() %>%
  # move the center to Snedecor Hall
  setView(-93.65, 42.0285, zoom = 14) %>%
  addMapPane("ames_lines", zIndex = 410) %>% # shown below ames_circles
  addMapPane("ames_circles", zIndex = 420) %>% # shown above ames_lines
  # points above polygons
  addCircles(
    data = random_data, ~lng, ~lat, radius = ~radius, popup = ~circleId,
    options = pathOptions(pane = "ames_circles")
  ) %>%
  # lines in 'ames_lines' pane
  addPolylines(
    data = random_data, ~lng, ~lat, color = "#F00", weight = 20,
    options = pathOptions(pane = "ames_lines")
  )


# same example but circles (zIndex: 420) are below the lines (zIndex: 430)
leaflet() %>%
  addTiles() %>%
  # move the center to Snedecor Hall
  setView(-93.65, 42.0285, zoom = 14) %>%
  addMapPane("ames_lines", zIndex = 430) %>% # shown below ames_circles
  addMapPane("ames_circles", zIndex = 420) %>% # shown above ames_lines
  # points above polygons
  addCircles(
    data = random_data, ~lng, ~lat, radius = ~radius, popup = ~circleId,
    options = pathOptions(pane = "ames_circles")
  ) %>%
  # lines in 'ames_lines' pane
  addPolylines(
    data = random_data, ~lng, ~lat, color = "#F00", weight = 20,
    options = pathOptions(pane = "ames_lines")
  )

Add a measure control to the map.

Description

Add a measure control to the map.

Usage

addMeasure(
  map,
  position = "topright",
  primaryLengthUnit = "feet",
  secondaryLengthUnit = NULL,
  primaryAreaUnit = "acres",
  secondaryAreaUnit = NULL,
  activeColor = "#ABE67E",
  completedColor = "#C8F2BE",
  popupOptions = list(className = "leaflet-measure-resultpopup", autoPanPadding = c(10,
    10)),
  captureZIndex = 10000,
  localization = "en",
  decPoint = ".",
  thousandsSep = ","
)

Arguments

Value

modified map

Examples

leaf <- leaflet() %>%
  addTiles() %>%
  # central park
  fitBounds( -73.9, 40.75, -73.95, 40.8 ) %>%
  addMeasure()

leaf

# customizing
leaf %>% addMeasure(
  position = "bottomleft",
  primaryLengthUnit = "meters",
  primaryAreaUnit = "sqmeters",
  activeColor = "#3D535D",
  completedColor = "#7D4479",
  localization = "de"
)

Add a minimap to the Map https://github.com/Norkart/Leaflet-MiniMap

Description

Add a minimap to the Map https://github.com/Norkart/Leaflet-MiniMap

Usage

addMiniMap(
  map,
  position = "bottomright",
  width = 150,
  height = 150,
  collapsedWidth = 19,
  collapsedHeight = 19,
  zoomLevelOffset = -5,
  zoomLevelFixed = FALSE,
  centerFixed = FALSE,
  zoomAnimation = FALSE,
  toggleDisplay = FALSE,
  autoToggleDisplay = FALSE,
  minimized = FALSE,
  aimingRectOptions = list(color = "#ff7800", weight = 1, clickable = FALSE),
  shadowRectOptions = list(color = "#000000", weight = 1, clickable = FALSE, opacity = 0,
    fillOpacity = 0),
  strings = list(hideText = "Hide MiniMap", showText = "Show MiniMap"),
  tiles = NULL,
  mapOptions = list()
)

Arguments

See Also

providers

Examples

leaf <- leaflet() %>%
  addTiles() %>%
  addMiniMap()
leaf

Add a tile layer from a known map provider

Description

Add a tile layer from a known map provider

Usage

addProviderTiles(
  map,
  provider,
  layerId = NULL,
  group = NULL,
  options = providerTileOptions()
)

providerTileOptions(
  errorTileUrl = "",
  noWrap = FALSE,
  opacity = NULL,
  zIndex = NULL,
  updateWhenIdle = NULL,
  detectRetina = FALSE,
  ...
)

Arguments

Value

modified map object

Examples

leaflet() %>%
  addProviderTiles("Stamen.Watercolor") %>%
  addProviderTiles("Stamen.TonerHybrid")

Add a raster image as a layer

Description

Create an image overlay from a RasterLayer or a SpatRaster object. This is only suitable for small to medium sized rasters, as the entire image will be embedded into the HTML page (or passed over the websocket in a Shiny context).

Usage

addRasterImage(
  map,
  x,
  colors = if (is.factor(x)[1]) "Set1" else "Spectral",
  opacity = 1,
  attribution = NULL,
  layerId = NULL,
  group = NULL,
  project = TRUE,
  method = c("auto", "bilinear", "ngb"),
  maxBytes = 4 * 1024 * 1024,
  options = gridOptions(),
  data = getMapData(map)
)

projectRasterForLeaflet(x, method)

Arguments

Details

The maxBytes parameter serves to prevent you from accidentally embedding an excessively large amount of data into your htmlwidget. This value is compared to the size of the final compressed image (after the raster has been projected, colored, and PNG encoded, but before base64 encoding is applied). Set maxBytes to Inf to disable this check, but be aware that very large rasters may not only make your map a large download but also may cause the browser to become slow or unresponsive.

To reduce the size of a SpatRaster, you can use spatSample as in x = spatSample(x, 100000, method="regular", as.raster=TRUE). With a RasterLayer you can use sampleRegular as in sampleRegular(x, 100000, asRaster=TRUE).

By default, the addRasterImage function will project the raster data x to the Pseudo-Mercator projection (EPSG:3857). This can be a time-consuming operation for even moderately sized rasters; although it is much faster for SpatRasters than for RasterLayers. If you are repeatedly adding a particular raster to your Leaflet maps, you can perform the projection ahead of time using projectRasterForLeaflet(), and call addRasterImage with project = FALSE.

See Also

addRasterLegend for an easy way to add a legend for a SpatRaster with a color table.

Examples

library(raster)

r <- raster(xmn = -2.8, xmx = -2.79, ymn = 54.04, ymx = 54.05, nrows = 30, ncols = 30)
values(r) <- matrix(1:900, nrow(r), ncol(r), byrow = TRUE)
crs(r) <- CRS("+init=epsg:4326")

pal <- colorNumeric("Spectral", domain = c(0, 1000))
leaflet() %>% addTiles() %>%
  addRasterImage(r, colors = pal, opacity = 0.8) %>%
  addLegend(pal = pal, values = c(0, 1000))

Add a color legend for a SpatRaster to a map

Description

A function for adding a legend that is specifically designed for terra::SpatRaster objects, with categorical values, that carry their own color table.

Usage

addRasterLegend(map, x, layer = 1, ...)

Arguments

See Also

addRasterImage()

Examples

library(terra)

r <- rast("/vsicurl/https://geodata.ucdavis.edu/test/pr_nlcd.tif")
leaflet() %>%
  addTiles() %>%
  addRasterImage(r, opacity = 0.75) %>%
  addRasterLegend(r, opacity = 0.75)

plot.new() # pause in interactive mode

rr <- r
levels(rr)  <- NULL
leaflet() %>%
  addTiles() %>%
  addRasterImage(rr, opacity = 0.75) %>%
  addRasterLegend(rr, opacity = 0.75)

Add or remove a scale bar

Description

Uses Leaflet's built-in scale bar feature to add a scale bar.

Usage

addScaleBar(
  map,
  position = c("topright", "bottomright", "bottomleft", "topleft"),
  options = scaleBarOptions()
)

scaleBarOptions(
  maxWidth = 100,
  metric = TRUE,
  imperial = TRUE,
  updateWhenIdle = TRUE
)

removeScaleBar(map)

Arguments

Examples

leaflet() %>%
  addTiles() %>%
  addScaleBar()

Add a simple Graticule on the map see https://github.com/ablakey/Leaflet.SimpleGraticule

Description

Add a simple Graticule on the map see https://github.com/ablakey/Leaflet.SimpleGraticule

Usage

addSimpleGraticule(
  map,
  interval = 20,
  showOriginLabel = TRUE,
  redraw = "move",
  hidden = FALSE,
  zoomIntervals = list(),
  layerId = NULL,
  group = NULL
)

Arguments

Examples

leaflet() %>%
  addTiles() %>%
  addSimpleGraticule()

Add a daylight layer on top of the map

Description

See https://github.com/joergdietrich/Leaflet.Terminator

Usage

addTerminator(
  map,
  resolution = 2,
  time = NULL,
  layerId = NULL,
  group = NULL,
  options = pathOptions(pointerEvents = "none", clickable = FALSE)
)

Arguments

Examples

leaf <- leaflet() %>%
  addTiles() %>%
  addTerminator()
leaf

Atlantic Ocean storms 2005

Description

Atlantic Ocean storms 2005

Format

sp::SpatialLinesDataFrame

Details

This dataset contains storm tracks for selected storms in the Atlantic Ocean basin for the year 2005

Make awesome-icon set

Description

Make awesome-icon set

Usage

awesomeIconList(...)

Arguments

Examples

iconSet <- awesomeIconList(
  home = makeAwesomeIcon(icon = "Home", library = "fa"),
  flag = makeAwesomeIcon(icon = "Flag", library = "fa")
)

iconSet[c("home", "flag")]

Create a list of awesome icon data see https://github.com/lennardv2/Leaflet.awesome-markers

Description

An icon can be represented as a list of the form list(icon, library, ...). This function is vectorized over its arguments to create a list of icon data. Shorter argument values will be re-cycled. NULL values for these arguments will be ignored.

Usage

awesomeIcons(
  icon = "home",
  library = "glyphicon",
  markerColor = "blue",
  iconColor = "white",
  spin = FALSE,
  extraClasses = NULL,
  squareMarker = FALSE,
  iconRotate = 0,
  fontFamily = "monospace",
  text = NULL
)

Arguments

Value

A list of awesome-icon data that can be passed to the icon

Selected breweries in Franconia

Description

Selected breweries in Franconia (zip code starting with 91...)

Format

sp::SpatialPointsDataFrame

Details

This dataset contains selected breweries in Franconia. It is a subset of a larger database that was compiled by students at the University of Marburg for a seminar called "The Geography of Beer, sustainability in the food industry"

Color mapping

Description

Conveniently maps data values (numeric or factor/character) to colors according to a given palette, which can be provided in a variety of formats.

Usage

colorNumeric(
  palette,
  domain,
  na.color = "#808080",
  alpha = FALSE,
  reverse = FALSE
)

colorBin(
  palette,
  domain,
  bins = 7,
  pretty = TRUE,
  na.color = "#808080",
  alpha = FALSE,
  reverse = FALSE,
  right = FALSE
)

colorQuantile(
  palette,
  domain,
  n = 4,
  probs = seq(0, 1, length.out = n + 1),
  na.color = "#808080",
  alpha = FALSE,
  reverse = FALSE,
  right = FALSE
)

colorFactor(
  palette,
  domain,
  levels = NULL,
  ordered = FALSE,
  na.color = "#808080",
  alpha = FALSE,
  reverse = FALSE
)

Arguments

Details

colorNumeric is a simple linear mapping from continuous numeric data to an interpolated palette.

colorBin also maps continuous numeric data, but performs binning based on value (see the cut function). colorBin defaults for the cut function are include.lowest = TRUE and right = FALSE.

colorQuantile similarly bins numeric data, but via the quantile function.

colorFactor maps factors to colors. If the palette is discrete and has a different number of colors than the number of factors, interpolation is used.

The palette argument can be any of the following:

1. A character vector of RGB or named colors. Examples: palette(), c("#000000", "#0000FF", "#FFFFFF"), topo.colors(10)

2. The name of an RColorBrewer palette, e.g. "BuPu" or "Greens".

3. The full name of a viridis palette: "viridis", "magma", "inferno", or "plasma".

4. A function that receives a single value between 0 and 1 and returns a color. Examples: colorRamp(c("#000000", "#FFFFFF"), interpolate = "spline").

Value

A function that takes a single parameter x; when called with a vector of numbers (except for colorFactor, which expects factors/characters), #RRGGBB color strings are returned (unless alpha = TRUE in which case #RRGGBBAA may also be possible).

Examples

pal <- colorBin("Greens", domain = 0:100)
pal(runif(10, 60, 100))

if (interactive()) {
  # Exponential distribution, mapped continuously
  previewColors(colorNumeric("Blues", domain = NULL), sort(rexp(16)))
  # Exponential distribution, mapped by interval
  previewColors(colorBin("Blues", domain = NULL, bins = 4), sort(rexp(16)))
  # Exponential distribution, mapped by quantile
  previewColors(colorQuantile("Blues", domain = NULL), sort(rexp(16)))

  # Categorical data; by default, the values being colored span the gamut...
  previewColors(colorFactor("RdYlBu", domain = NULL), LETTERS[1:5])
  # ...unless the data is a factor, without droplevels...
  previewColors(colorFactor("RdYlBu", domain = NULL), factor(LETTERS[1:5], levels = LETTERS))
  # ...or the domain is stated explicitly.
  previewColors(colorFactor("RdYlBu", levels = LETTERS), LETTERS[1:5])
}

Legacy functions

Description

These functions are provided for backwards compatibility with the first iteration of the leaflet bindings (https://github.com/jcheng5/leaflet-shiny).

Usage

createLeafletMap(session, outputId)

leafletMap(
  outputId,
  width,
  height,
  initialTileLayer = "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
  initialTileLayerAttribution = NULL,
  options = NULL
)

Arguments

Given a data object and lng/lat arguments (which may be NULL [meaning infer from data], formula [which should be evaluated with respect to the data], or vector data [which should be used as-is]) return a lng/lat data frame.

Description

Given a data object and lng/lat arguments (which may be NULL [meaning infer from data], formula [which should be evaluated with respect to the data], or vector data [which should be used as-is]) return a lng/lat data frame.

Usage

derivePoints(
  data,
  lng = NULL,
  lat = NULL,
  missingLng = missing(lng),
  missingLat = missing(lat),
  funcName = "f"
)

Arguments

Given a data object and lng/lat arguments (which may be NULL [meaning infer from data], formula [which should be evaluated with respect to the data], or vector data [which should be used as-is]) return a spatial object

Description

Given a data object and lng/lat arguments (which may be NULL [meaning infer from data], formula [which should be evaluated with respect to the data], or vector data [which should be used as-is]) return a spatial object

Usage

derivePolygons(
  data,
  lng = NULL,
  lat = NULL,
  missingLng = missing(lng),
  missingLat = missing(lat),
  funcName = "f"
)

Arguments

Extension points for plugins

Description

Extension points for plugins

Usage

dispatch(
  map,
  funcName,
  leaflet = stop(paste(funcName, "requires a map proxy object")),
  leaflet_proxy = stop(paste(funcName, "does not support map proxy objects"))
)

invokeMethod(map, data, method, ...)

Arguments

Value

dispatch returns the value of leaflet or leaflet_proxy, or an error. invokeMethod returns the map object that was passed in, possibly modified.

Create an easyButton statestate

Description

Create an easyButton statestate

Creates an easy button.

Add a EasyButton on the map see https://github.com/CliffCloud/Leaflet.EasyButton

Add a easyButton bar on the map see https://github.com/CliffCloud/Leaflet.EasyButton

Usage

easyButtonState(stateName, icon, title, onClick)

easyButton(
  icon = NULL,
  title = NULL,
  onClick = NULL,
  position = "topleft",
  id = NULL,
  states = NULL
)

addEasyButton(map, button)

addEasyButtonBar(map, ..., position = "topleft", id = NULL)

Arguments

Functions

• easyButtonState(): state of an easyButton.

• addEasyButton(): add an EasyButton to the map

• addEasyButtonBar(): add an EasyButton to the map

See Also

easyButton

https://github.com/CliffCloud/Leaflet.EasyButton

addEasyButton

Examples

leaf <- leaflet() %>%
  addTiles() %>%
  addEasyButton(easyButton(
     icon = htmltools::span(class = "star", htmltools::HTML("&starf;")),
     onClick = JS("function(btn, map){ map.setZoom(1);}")))
leaf

leaf <- leaflet() %>%
  addTiles() %>%
  addEasyButtonBar(
   easyButton(
     icon = htmltools::span(class = "star", htmltools::HTML("&starf;")),
     onClick = JS("function(btn, map){ alert(\"Button 1\");}")),
   easyButton(
     icon = htmltools::span(class = "star", htmltools::HTML("&target;")),
     onClick = JS("function(btn, map){ alert(\"Button 2\");}")))
leaf

Evaluate list members that are formulae, using the map data as the environment (if provided, otherwise the formula environment)

Description

Evaluate list members that are formulae, using the map data as the environment (if provided, otherwise the formula environment)

Usage

evalFormula(list, data)

Arguments

Notifies the map of new latitude/longitude of items of interest on the map

Description

Notifies the map of new latitude/longitude of items of interest on the map

Usage

expandLimits(map, lat, lng)

Arguments

Same as expandLimits, but takes a polygon (that presumably has a bbox attr) rather than lat/lng.

Description

Same as expandLimits, but takes a polygon (that presumably has a bbox attr) rather than lat/lng.

Usage

expandLimitsBbox(map, poly)

Arguments

remove NULL elements from a list

Description

remove NULL elements from a list

Usage

filterNULL(x)

Arguments

Administrative borders of Switzerland (level 1)

Description

Administrative borders of Switzerland (level 1)

Format

sp::SpatialPolygonsDataFrame

Details

This dataset comes from https://gadm.org. It was downloaded using getData.

Source

https://gadm.org

returns the map's data

Description

returns the map's data

Usage

getMapData(map)

Arguments

Set options on layer groups

Description

Change options on layer groups. Currently the only option is to control what zoom levels a layer group will be displayed at. The zoomLevels option is not compatible with layers control; do not both assign a group to zoom levels and use it with addLayersControl.

Usage

groupOptions(map, group, zoomLevels = NULL)

Arguments

Examples

pal <- colorQuantile("YlOrRd", quakes$mag)

leaflet() %>%
  # Basic markers
  addTiles(group = "basic") %>%
  addMarkers(data = quakes, group = "basic") %>%
  # When zoomed in, we'll show circles at the base of each marker whose
  # radius and color reflect the magnitude
  addProviderTiles(providers$Stamen.TonerLite, group = "detail") %>%
  addCircleMarkers(data = quakes, group = "detail", fillOpacity = 0.5,
    radius = ~mag * 5, color = ~pal(mag), stroke = FALSE) %>%
  # Set the detail group to only appear when zoomed in
  groupOptions("detail", zoomLevels = 7:18)

Make icon set

Description

Make icon set

Usage

iconList(...)

Arguments

Examples

iconSet <- iconList(
  red = makeIcon("leaf-red.png", iconWidth = 32, iconHeight = 32),
  green = makeIcon("leaf-green.png", iconWidth = 32, iconHeight = 32)
)

iconSet[c("red", "green", "red")]

Create a list of icon data

Description

An icon can be represented as a list of the form list(iconUrl, iconSize, ...). This function is vectorized over its arguments to create a list of icon data. Shorter argument values will be re-cycled. NULL values for these arguments will be ignored.

Usage

icons(
  iconUrl = NULL,
  iconRetinaUrl = NULL,
  iconWidth = NULL,
  iconHeight = NULL,
  iconAnchorX = NULL,
  iconAnchorY = NULL,
  shadowUrl = NULL,
  shadowRetinaUrl = NULL,
  shadowWidth = NULL,
  shadowHeight = NULL,
  shadowAnchorX = NULL,
  shadowAnchorY = NULL,
  popupAnchorX = NULL,
  popupAnchorY = NULL,
  className = NULL
)

Arguments

Value

A list of icon data that can be passed to the icon argument of addMarkers().

Examples

library(leaflet)

# adapted from https://leafletjs.com/examples/custom-icons.html

iconData <- data.frame(
  lat = c(rnorm(10, 0), rnorm(10, 1), rnorm(10, 2)),
  lng = c(rnorm(10, 0), rnorm(10, 3), rnorm(10, 6)),
  group = rep(sort(c("green", "red", "orange")), each = 10),
  stringsAsFactors = FALSE
)

leaflet() %>% addMarkers(
  data = iconData,
  icon = ~ icons(
    iconUrl = sprintf("https://leafletjs.com/examples/custom-icons/leaf-%s.png", group),
    shadowUrl = "https://leafletjs.com/examples/custom-icons/leaf-shadow.png",
    iconWidth = 38, iconHeight = 95, shadowWidth = 50, shadowHeight = 64,
    iconAnchorX = 22, iconAnchorY = 94, shadowAnchorX = 4, shadowAnchorY = 62,
    popupAnchorX = -3, popupAnchorY = -76
  )
)



# use point symbols from base R graphics as icons
pchIcons <- function(pch = 0:14, width = 30, height = 30, ...) {
  n <- length(pch)
  files <- character(n)
  # create a sequence of png images
  for (i in seq_len(n)) {
    f <- tempfile(fileext = ".png")
    png(f, width = width, height = height, bg = "transparent")
    par(mar = c(0, 0, 0, 0))
    plot.new()
    points(.5, .5, pch = pch[i], cex = min(width, height) / 8, ...)
    dev.off()
    files[i] <- f
  }
  files
}

iconData <- matrix(rnorm(500), ncol = 2)
res <- kmeans(iconData, 10)
iconData <- cbind(iconData, res$cluster)
colnames(iconData) <- c("lat", "lng", "group")
iconData <- as.data.frame(iconData)

# 10 random point shapes for the 10 clusters in iconData
shapes <- sample(0:14, 10)
iconFiles <- pchIcons(shapes, 40, 40, col = "steelblue", lwd = 2)

# note the data has 250 rows, and there are 10 icons in iconFiles; they are
# connected by the `group` variable: the i-th row of iconData uses the
# group[i]-th icon in the icon list
leaflet() %>% addMarkers(
  data = iconData,
  icon = ~ icons(
    iconUrl = iconFiles[group],
    popupAnchorX = 20, popupAnchorY = 0
  ),
  popup = ~ sprintf(
    "lat = %.4f, long = %.4f, group = %s, pch = %s", lat, lng, group, shapes[group]
  )
)

unlink(iconFiles)  # clean up the tmp png files that have been embedded

Create a Leaflet map widget

Description

This function creates a Leaflet map widget using htmlwidgets. The widget can be rendered on HTML pages generated from R Markdown, Shiny, or other applications.

Usage

leaflet(
  data = NULL,
  width = NULL,
  height = NULL,
  padding = 0,
  options = leafletOptions(),
  elementId = NULL,
  sizingPolicy = leafletSizingPolicy(padding = padding)
)

leafletOptions(
  minZoom = NULL,
  maxZoom = NULL,
  crs = leafletCRS(),
  worldCopyJump = NULL,
  preferCanvas = NULL,
  ...
)

leafletCRS(
  crsClass = "L.CRS.EPSG3857",
  code = NULL,
  proj4def = NULL,
  projectedBounds = NULL,
  origin = NULL,
  transformation = NULL,
  scales = NULL,
  resolutions = NULL,
  bounds = NULL,
  tileSize = NULL
)

Arguments

Details

The data argument is only needed if you are going to reference variables in this object later in map layers. For example, data can be a data frame containing columns latitude and longtitude, then we may add a circle layer to the map by leaflet(data) %>% addCircles(lat = ~latitude, lng = ~longtitude), where the variables in the formulae will be evaluated in the data.

Value

A HTML widget object, on which we can add graphics layers using %>% (see examples).

Functions

• leafletOptions(): Options for map creation

• leafletCRS(): class to create a custom CRS

See Also

leafletCRS for creating a custom CRS.

See https://web.archive.org/web/20220702182250/https://leafletjs.com/reference-1.3.4.html#map-option for details and more options.

Examples

# !formatR
library(leaflet)
m <- leaflet() %>% addTiles()
m  # a map with the default OSM tile layer


# set bounds
m %>% fitBounds(0, 40, 10, 50)

# move the center to Snedecor Hall
m <- m %>% setView(-93.65, 42.0285, zoom = 17)
m

# popup
m %>% addPopups(-93.65, 42.0285, "Here is the <b>Department of Statistics</b>, ISU")
rand_lng <- function(n = 10) rnorm(n, -93.65, .01)
rand_lat <- function(n = 10) rnorm(n, 42.0285, .01)

# use automatic bounds derived from lng/lat data
m <- m %>% clearBounds()

# popup
m %>% addPopups(rand_lng(), rand_lat(), "Random popups")

# marker
m %>% addMarkers(rand_lng(), rand_lat())
m %>% addMarkers(
  rand_lng(), rand_lat(), popup = paste("A random letter", sample(LETTERS, 10))
)

Rlogo <- file.path(R.home("doc"), "html", "logo.jpg")
m %>% addMarkers(
  174.7690922, -36.8523071, icon = list(
    iconUrl = Rlogo, iconSize = c(100, 76)
  ), popup = "R was born here!"
)

m %>% addMarkers(rnorm(30, 175), rnorm(30, -37), icon = list(
  iconUrl = Rlogo, iconSize = c(25, 19)
))

# circle (units in metres)
m %>% addCircles(rand_lng(50), rand_lat(50), radius = runif(50, 50, 150))

# circle marker (units in pixels)
m %>% addCircleMarkers(rand_lng(50), rand_lat(50), color = "#ff0000")
m %>% addCircleMarkers(rand_lng(100), rand_lat(100), radius = runif(100, 5, 15))

# rectangle
m %>% addRectangles(
  rand_lng(), rand_lat(), rand_lng(), rand_lat(),
  color = "red", fill = FALSE, dashArray = "5,5", weight = 3
)

# polyline
m %>% addPolylines(rand_lng(50), rand_lat(50))

# polygon
m %>% addPolygons(rand_lng(), rand_lat(), layerId = "foo")

# geoJSON
seattle_geojson <- list(
  type = "Feature",
  geometry = list(
    type = "MultiPolygon",
    coordinates = list(list(list(
      c(-122.36075812146,  47.6759920119894),
      c(-122.360781646764, 47.6668890126755),
      c(-122.360782108665,  47.6614990696722),
      c(-122.366199035722, 47.6614990696722),
      c(-122.366199035722,  47.6592874248973),
      c(-122.364582509469, 47.6576254522105),
      c(-122.363887331445,  47.6569107302038),
      c(-122.360865528129, 47.6538418253251),
      c(-122.360866157644,  47.6535254473167),
      c(-122.360866581103, 47.6533126275176),
      c(-122.362526540691,  47.6541872926348),
      c(-122.364442114483, 47.6551892850798),
      c(-122.366077719797,  47.6560733960606),
      c(-122.368818463838, 47.6579742346694),
      c(-122.370115159943,  47.6588730808334),
      c(-122.372295967029, 47.6604350102328),
      c(-122.37381369088,  47.660582362063),
      c(-122.375522972109, 47.6606413027949),
      c(-122.376079703095,  47.6608793094619),
      c(-122.376206315662, 47.6609242364243),
      c(-122.377610811371,  47.6606160735197),
      c(-122.379857378879, 47.6610306942278),
      c(-122.382454873022,  47.6627496239169),
      c(-122.385357955057, 47.6638573778241),
      c(-122.386007328104,  47.6640865692306),
      c(-122.387186331506, 47.6654326177161),
      c(-122.387802656231,  47.6661492860294),
      c(-122.388108244121, 47.6664548739202),
      c(-122.389177800763,  47.6663784774359),
      c(-122.390582858689, 47.6665072251861),
      c(-122.390793942299,  47.6659699214511),
      c(-122.391507906234, 47.6659200946229),
      c(-122.392883050767,  47.6664166747017),
      c(-122.392847210144, 47.6678696739431),
      c(-122.392904778401,  47.6709016021624),
      c(-122.39296705153, 47.6732047491624),
      c(-122.393000803496,  47.6759322346303),
      c(-122.37666945305, 47.6759896300663),
      c(-122.376486363943,  47.6759891899754),
      c(-122.366078869215, 47.6759641734893),
      c(-122.36075812146,  47.6759920119894)
    )))
  ),
  properties = list(
    name = "Ballard",
    population = 48000,
    # You can inline styles if you want
    style = list(
      fillColor = "yellow",
      weight = 2,
      color = "#000000"
    )
  ),
  id = "ballard"
)
m %>% setView(-122.36075812146, 47.6759920119894, zoom = 13) %>% addGeoJSON(seattle_geojson)


# use the Dark Matter layer from CartoDB
leaflet() %>% addTiles("https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png",
  attribution = paste(
    "&copy; <a href=\"https://openstreetmap.org\">OpenStreetMap</a> contributors",
    "&copy; <a href=\"https://cartodb.com/attributions\">CartoDB</a>"
  )
) %>% setView(-122.36, 47.67, zoom = 10)

# provide a data frame to leaflet()
categories <- LETTERS[1:10]
df <- data.frame(
  lat = rand_lat(100), lng = rand_lng(100), size = runif(100, 5, 20),
  category = factor(sample(categories, 100, replace = TRUE), levels = categories),
  value = rnorm(100)
)
m <- leaflet(df) %>% addTiles()
m %>% addCircleMarkers(~lng, ~lat, radius = ~size)
m %>% addCircleMarkers(~lng, ~lat, radius = runif(100, 4, 10), color = c("red"))

# Discrete colors using the "RdYlBu" colorbrewer palette, mapped to categories
RdYlBu <- colorFactor("RdYlBu", domain = categories)
m %>% addCircleMarkers(~lng, ~lat, radius = ~size,
  color = ~RdYlBu(category), fillOpacity = 0.5)

# Continuous colors using the "Greens" colorbrewer palette, mapped to value
greens <- colorNumeric("Greens", domain = NULL)
m %>% addCircleMarkers(~lng, ~lat, radius = ~size,
  color = ~greens(value), fillOpacity = 0.5)

Objects imported from other packages

Description

These objects are imported from other packages. Follow the links to their documentation.

htmlwidgets

JS

magrittr

%>%

Various leaflet dependency functions for use in downstream packages

Description

Various leaflet dependency functions for use in downstream packages

Usage

leafletDependencies

Format

An object of class list of length 13.

Examples

## Not run: 
addBootStrap <- function(map) {
  map$dependencies <- c(map$dependencies, leafletDependencies$bootstrap())
  map
}

## End(Not run)

Wrapper functions for using leaflet in shiny

Description

Use leafletOutput() to create a UI element, and renderLeaflet() to render the map widget.

Usage

leafletOutput(outputId, width = "100%", height = 400)

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

Arguments

Examples

# !formatR
library(shiny)
app <- shinyApp(
  ui = fluidPage(leafletOutput('myMap')),
  server = function(input, output) {
    map = leaflet() %>% addTiles() %>% setView(-93.65, 42.0285, zoom = 17)
    output$myMap = renderLeaflet(map)
  }
)

if (interactive()) app

Send commands to a Leaflet instance in a Shiny app

Description

Creates a map-like object that can be used to customize and control a map that has already been rendered. For use in Shiny apps and Shiny docs only.

Usage

leafletProxy(
  mapId,
  session = shiny::getDefaultReactiveDomain(),
  data = NULL,
  deferUntilFlush = TRUE
)

Arguments

Details

Normally, you create a Leaflet map using the leaflet function. This creates an in-memory representation of a map that you can customize using functions like addPolygons and setView. Such a map can be printed at the R console, included in an R Markdown document, or rendered as a Shiny output.

In the case of Shiny, you may want to further customize a map, even after it is rendered to an output. At this point, the in-memory representation of the map is long gone, and the user's web browser has already realized the Leaflet map instance.

This is where leafletProxy comes in. It returns an object that can stand in for the usual Leaflet map object. The usual map functions like addPolygons and setView can be called, and instead of customizing an in-memory representation, these commands will execute on the live Leaflet map instance.

Examples

library(shiny)

ui <- fluidPage(
  leafletOutput("map1")
)

map <- leaflet() %>% addCircleMarkers(
  lng = runif(10),
  lat = runif(10),
  layerId = paste0("marker", 1:10))
server <- function(input, output, session) {
  output$map1 <- renderLeaflet(map)

  observeEvent(input$map1_marker_click, {
    leafletProxy("map1", session) %>%
      removeMarker(input$map1_marker_click$id)
  })
}

app <- shinyApp(ui, server)
if (interactive()) app

Leaflet sizing policy

Description

Sizing policy used withing leaflet htmlwidgets. All arguments are passed directly to htmlwidgets::sizingPolicy

Usage

leafletSizingPolicy(
  defaultWidth = "100%",
  defaultHeight = 400,
  padding = 0,
  browser.fill = TRUE,
  ...
)

Arguments

Value

An htmlwidgets::sizingPolicy object

Make Awesome Icon

Description

Make Awesome Icon

Usage

makeAwesomeIcon(
  icon = "home",
  library = "glyphicon",
  markerColor = "blue",
  iconColor = "white",
  spin = FALSE,
  extraClasses = NULL,
  squareMarker = FALSE,
  iconRotate = 0,
  fontFamily = "monospace",
  text = NULL
)

Arguments

Define icon sets

Description

Define icon sets

Usage

makeIcon(
  iconUrl = NULL,
  iconRetinaUrl = NULL,
  iconWidth = NULL,
  iconHeight = NULL,
  iconAnchorX = NULL,
  iconAnchorY = NULL,
  shadowUrl = NULL,
  shadowRetinaUrl = NULL,
  shadowWidth = NULL,
  shadowHeight = NULL,
  shadowAnchorX = NULL,
  shadowAnchorY = NULL,
  popupAnchorX = NULL,
  popupAnchorY = NULL,
  className = NULL
)

Arguments

Set options on a leaflet map object

Description

Set options on a leaflet map object

Usage

mapOptions(map, zoomToLimits = c("always", "first", "never"))

Arguments

Examples

# Don't auto-zoom to the objects (can be useful in interactive applications)
leaflet() %>%
  addTiles() %>%
  addPopups(174.7690922, -36.8523071, "R was born here!") %>%
  mapOptions(zoomToLimits = "first")

Color previewing utility

Description

Color previewing utility

Usage

previewColors(pal, values)

Arguments

Value

An HTML-based list of the colors and values

Providers

Description

List of all providers with their variations

Format

A list of characters

Source

https://github.com/leaflet-extras/leaflet-providers/blob/0a9e27f8c6c26956b4e78c26e1945d748e3c2869/leaflet-providers.js

Remove elements from a map

Description

Remove one or more features from a map, identified by layerId; or, clear all features of the given type or group.

Usage

removeControl(map, layerId)

clearControls(map)

clearGroup(map, group)

removeImage(map, layerId)

clearImages(map)

removeTiles(map, layerId)

clearTiles(map)

removePopup(map, layerId)

clearPopups(map)

removeMarker(map, layerId)

clearMarkers(map)

removeMarkerCluster(map, layerId)

clearMarkerClusters(map)

removeMarkerFromCluster(map, layerId, clusterId)

removeShape(map, layerId)

clearShapes(map)

removeGeoJSON(map, layerId)

clearGeoJSON(map)

removeMeasure(map)

removeTopoJSON(map, layerId)

clearTopoJSON(map)

Arguments

Value

the new map object

Note

When used with a leaflet() map object, these functions don't actually remove the features from the map object, but simply add an operation that will cause those features to be removed after they are added. In other words, if you add a polygon "foo" and the call removeShape("foo"), it's not smart enough to prevent the polygon from being added in the first place; instead, when the map is rendered, the polygon will be added and then removed.

For that reason, these functions aren't that useful with leaflet map objects and are really intended to be used with leafletProxy instead.

WMS tile layers are extensions of tile layers, so they can also be removed or cleared via removeTiles() or clearTiles().

Sanitize textual labels

Description

This is a helper function used internally to HTML-escape user-provided labels. It prevents strings from unintentionally being treated as HTML when they are intended to be plaintext.

Usage

safeLabel(label, data)

Arguments

Methods to manipulate the map widget

Description

A series of methods to manipulate the map.

Usage

setView(map, lng, lat, zoom, options = list())

flyTo(map, lng, lat, zoom, options = list())

fitBounds(map, lng1, lat1, lng2, lat2, options = list())

flyToBounds(map, lng1, lat1, lng2, lat2, options = list())

setMaxBounds(map, lng1, lat1, lng2, lat2)

clearBounds(map)

Arguments

Value

The modified map widget.

Functions

• setView(): Set the view of the map (center and zoom level)

• flyTo(): Flys to a given location/zoom-level using smooth pan-zoom.

• fitBounds(): Set the bounds of a map

• flyToBounds(): Flys to given bound using smooth pan/zoom.

• setMaxBounds(): Restricts the map view to the given bounds

• clearBounds(): Clear the bounds of a map, and the bounds will be automatically determined from latitudes and longitudes of the map elements if available (otherwise the full world view is used)

References

https://web.archive.org/web/20220702182250/https://leafletjs.com/reference-1.3.4.html#map-methods-for-modifying-map-state

Examples

m <- leaflet() %>% addTiles() %>% setView(-71.0382679, 42.3489054, zoom = 18)
m  # the RStudio 'headquarter'
m %>% fitBounds(-72, 40, -70, 43)
m %>% clearBounds()  # world view

Show or hide layer groups

Description

Hide groups of layers without removing them from the map entirely. Groups are created using the group parameter that is included on most layer adding functions.

Usage

showGroup(map, group)

hideGroup(map, group)

Arguments

See Also

addLayersControl to allow users to show/hide layer groups interactively

Extra options for map elements and layers

Description

The rest of all possible options for map elements and layers that are not listed in the layer functions.

Usage

tileOptions(
  minZoom = 0,
  maxZoom = 18,
  maxNativeZoom = NULL,
  tileSize = 256,
  subdomains = "abc",
  errorTileUrl = "",
  tms = FALSE,
  noWrap = FALSE,
  zoomOffset = 0,
  zoomReverse = FALSE,
  opacity = 1,
  zIndex = 1,
  unloadInvisibleTiles = NULL,
  updateWhenIdle = NULL,
  detectRetina = FALSE,
  ...
)

gridOptions(
  tileSize = 256,
  updateWhenIdle = NULL,
  zIndex = 1,
  minZoom = 0,
  maxZoom = NULL,
  ...
)

WMSTileOptions(
  styles = "",
  format = "image/jpeg",
  transparent = FALSE,
  version = "1.1.1",
  crs = NULL,
  ...
)

popupOptions(
  maxWidth = 300,
  minWidth = 50,
  maxHeight = NULL,
  autoPan = TRUE,
  keepInView = FALSE,
  closeButton = TRUE,
  zoomAnimation = NULL,
  closeOnClick = NULL,
  className = "",
  ...
)

labelOptions(
  interactive = FALSE,
  clickable = NULL,
  noHide = NULL,
  permanent = FALSE,
  className = "",
  direction = "auto",
  offset = c(0, 0),
  opacity = 1,
  textsize = "10px",
  textOnly = FALSE,
  style = NULL,
  zoomAnimation = NULL,
  sticky = TRUE,
  ...
)

markerOptions(
  interactive = TRUE,
  clickable = NULL,
  draggable = FALSE,
  keyboard = TRUE,
  title = "",
  alt = "",
  zIndexOffset = 0,
  opacity = 1,
  riseOnHover = FALSE,
  riseOffset = 250,
  ...
)

markerClusterOptions(
  showCoverageOnHover = TRUE,
  zoomToBoundsOnClick = TRUE,
  spiderfyOnMaxZoom = TRUE,
  removeOutsideVisibleBounds = TRUE,
  spiderLegPolylineOptions = list(weight = 1.5, color = "#222", opacity = 0.5),
  freezeAtZoom = FALSE,
  ...
)

pathOptions(
  lineCap = NULL,
  lineJoin = NULL,
  clickable = NULL,
  interactive = TRUE,
  pointerEvents = NULL,
  className = "",
  ...
)

Arguments

Functions

• tileOptions(): Options for tile layers

• gridOptions(): Options for grid layers

• WMSTileOptions(): Options for WMS tile layers

• popupOptions(): Options for popups

• labelOptions(): Options for labels

• markerOptions(): Options for markers

• markerClusterOptions(): Options for marker clusters

• pathOptions(): Options for vector layers (polylines, polygons, rectangles, and circles, etc)

See Also

leafletCRS to map CRS (don't change this if you're not sure what it means)

Utility function to check if a coordinates is valid

Description

Utility function to check if a coordinates is valid

Usage

validateCoords(lng, lat, funcName, warn = TRUE, mode = c("point", "polygon"))

Arguments