Mapas interativos com leaflet
Renderize mapas interativos da web com marcadores, pop-ups e camadas de blocos.
Mapas interativos com leaflet é uma aula grátis de R Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.
Introdução ao leaflet
O pacote leaflet encapsula a biblioteca Leaflet.js para criar mapas interativos e ampliáveis na web diretamente a partir do R. Os mapas são widgets HTML que podem ser renderizados no visualizador do RStudio, no R Markdown e em aplicativos Shiny sem exigir conhecimentos de JavaScript.
library(leaflet)
# Minimal leaflet map: tiles + one marker
leaflet() |>
addTiles() |> # OpenStreetMap base layer
setView(
lng = -74.006,
lat = 40.713,
zoom = 12
) |>
addMarkers(
lng = -74.006,
lat = 40.713,
popup = '<b>New York City</b>'
)addTiles: Camadas do mapa-base
addTiles() adiciona a camada padrão de blocos do OpenStreetMap. Use addProviderTiles(providers$ para alternar para imagens de satélite, CartoDB, Esri, Stamen ou qualquer outro provedor de blocos. Os nomes das camadas estão na lista integrada providers.
library(leaflet)
# Default OpenStreetMap
map1 <- leaflet() |> addTiles()
# CartoDB light theme (great for data overlay)
map2 <- leaflet() |>
addProviderTiles(providers$CartoDB.Positron)
# Satellite imagery
map3 <- leaflet() |>
addProviderTiles(providers$Esri.WorldImagery)
# Custom tile URL
custom <- leaflet() |>
addTiles(
urlTemplate = 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
attribution = '(c) OpenStreetMap contributors'
)
map2addMarkers com janelas pop-up
addMarkers(lng, lat, popup) adiciona marcadores de pino ao mapa. O argumento popup aceita strings HTML, portanto você pode incluir texto em negrito, links ou imagens. O argumento label exibe texto ao passar o cursor, sem precisar clicar.
library(leaflet)
cities <- data.frame(
name = c('New York', 'Los Angeles', 'Chicago'),
lon = c(-74.006, -118.244, -87.629),
lat = c( 40.713, 34.052, 41.878),
pop = c(8336817, 3979576, 2693976)
)
leaflet(cities) |>
addTiles() |>
addMarkers(
lng = ~lon,
lat = ~lat,
popup = ~paste0(
'<b>', name, '</b><br>',
'Population: ', format(pop, big.mark = ',')
),
label = ~name
)addCircleMarkers
addCircleMarkers() renderiza círculos cujo tamanho é fixo em pixels na tela (ao contrário de addCircles(), que varia conforme o zoom). Eles são ideais para representar símbolos proporcionais — associe o radius a uma variável dos dados.
library(leaflet)
cities <- data.frame(
name = c('New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix'),
lon = c(-74.006, -118.244, -87.629, -95.369, -112.074),
lat = c( 40.713, 34.052, 41.878, 29.760, 33.449),
pop = c(8336817, 3979576, 2693976, 2304580, 1608139)
)
leaflet(cities) |>
addProviderTiles(providers$CartoDB.Positron) |>
addCircleMarkers(
lng = ~lon,
lat = ~lat,
radius = ~sqrt(pop / 50000),
color = 'steelblue',
fill = TRUE,
fillOpacity = 0.6,
popup = ~paste0(name, ': ', format(pop, big.mark = ','))
)addPolygons: Mapas coropléticos
addPolygons() renderiza geometrias de polígonos diretamente de um objeto sf. A cor de preenchimento pode ser associada a uma coluna dos dados usando as funções de paleta colorNumeric() ou colorBin(). A opção highlight adiciona efeitos ao passar o cursor.
library(leaflet)
library(sf)
nc <- st_transform(
read_sf(system.file('shape/nc.shp', package = 'sf')), 4326
)
# Colour palette based on birth count
pal <- colorNumeric('YlOrRd', domain = nc$BIR74)
leaflet(nc) |>
addProviderTiles(providers$CartoDB.Positron) |>
addPolygons(
fillColor = ~pal(BIR74),
fillOpacity = 0.7,
color = 'white',
weight = 1,
popup = ~paste0('<b>', NAME, '</b><br>Births 1974: ', BIR74),
highlight = highlightOptions(
weight = 3,
color = '#333',
bringToFront = TRUE
)
) |>
addLegend('bottomright', pal = pal, values = ~BIR74, title = 'Births 1974')setView e fitBounds
setView(lng, lat, zoom) centraliza o mapa em uma localização e um nível de zoom fixos. fitBounds(lng1, lat1, lng2, lat2) ajusta automaticamente o zoom para enquadrar uma caixa delimitadora geográfica, o que é útil quando a extensão dos dados não é conhecida antecipadamente.
library(leaflet)
library(sf)
nc <- st_transform(
read_sf(system.file('shape/nc.shp', package = 'sf')), 4326
)
bbox <- st_bbox(nc)
# fitBounds: auto-zoom to data extent
leaflet() |>
addTiles() |>
fitBounds(
lng1 = bbox['xmin'], lat1 = bbox['ymin'],
lng2 = bbox['xmax'], lat2 = bbox['ymax']
) |>
addPolygons(
data = nc,
fillColor = 'lightblue',
fillOpacity = 0.4,
color = 'steelblue',
weight = 1
)addLayersControl: Alternar camadas
addLayersControl() adiciona um controle de opções/caixas de seleção para ativar e desativar mapas-base e camadas de sobreposição. Use baseGroups para camadas de blocos mutuamente exclusivas e overlayGroups para camadas de dados que possam ser alternadas independentemente.
library(leaflet)
library(sf)
nc <- st_transform(
read_sf(system.file('shape/nc.shp', package = 'sf')), 4326
)
high_birth <- nc[nc$BIR74 > 3000, ]
low_birth <- nc[nc$BIR74 <= 3000, ]
leaflet() |>
addProviderTiles(providers$CartoDB.Positron, group = 'Light') |>
addProviderTiles(providers$Esri.WorldImagery, group = 'Satellite') |>
addPolygons(data = high_birth, color = 'red', group = 'High Births (>3000)') |>
addPolygons(data = low_birth, color = 'blue', group = 'Low Births (<=3000)') |>
addLayersControl(
baseGroups = c('Light', 'Satellite'),
overlayGroups = c('High Births (>3000)', 'Low Births (<=3000)'),
options = layersControlOptions(collapsed = FALSE)
)addPopups e addLegend
addPopups() adiciona caixas pop-up persistentes (sempre visíveis). addLegend() cria uma legenda do mapa vinculada a uma paleta de cores. Ambos aceitam conteúdo HTML e podem ser totalmente personalizados com classes CSS.
library(leaflet)
leaflet() |>
addTiles() |>
setView(-79.0, 35.5, zoom = 7) |>
addPopups(
lng = -78.639,
lat = 35.779,
popup = '<b>Raleigh</b><br>State Capital of NC'
) |>
addLegend(
position = 'bottomleft',
colors = c('red', 'blue', 'green'),
labels = c('High', 'Medium', 'Low'),
title = 'Risk Level',
opacity = 0.8
)Paletas de cores: colorNumeric e colorBin
As funções colorNumeric(), colorBin(), colorQuantile() e colorFactor() criam funções de paleta que associam valores dos dados a cores hexadecimais. Passe o resultado para fillColor e use a mesma paleta em addLegend().
library(leaflet)
library(sf)
nc <- st_transform(
read_sf(system.file('shape/nc.shp', package = 'sf')), 4326
)
# Continuous palette
pal_num <- colorNumeric('Blues', domain = nc$BIR74)
# Binned palette (5 equal bins)
pal_bin <- colorBin('RdYlGn', domain = nc$BIR74, bins = 5)
# Quantile palette (equal number of features per class)
pal_qtl <- colorQuantile('YlOrRd', domain = nc$BIR74, n = 4)
# Use binned palette
leaflet(nc) |>
addTiles() |>
addPolygons(
fillColor = ~pal_bin(BIR74),
fillOpacity = 0.7, weight = 1, color = 'white'
) |>
addLegend('bottomright', pal = pal_bin, values = ~BIR74,
title = 'Births 1974 (5 bins)')leafletProxy: Atualização de mapas no Shiny
leafletProxy('mapId') atualiza um mapa leaflet existente em um aplicativo Shiny sem renderizar novamente o mapa inteiro desde o início. Use-o com clearMarkers(), clearShapes() ou addMarkers() para responder de forma eficiente à entrada do usuário.
library(shiny)
library(leaflet)
# Minimal Shiny app with leafletProxy
ui <- fluidPage(
selectInput('colour', 'Marker colour:', choices = c('red', 'blue', 'green')),
leafletOutput('map')
)
server <- function(input, output, session) {
output$map <- renderLeaflet({
leaflet() |> addTiles() |>
setView(-79.0, 35.5, zoom = 7)
})
observeEvent(input$colour, {
leafletProxy('map') |>
clearMarkers() |>
addCircleMarkers(
lng = -78.639, lat = 35.779,
color = input$colour,
label = paste('Raleigh -', input$colour)
)
})
}
# shinyApp(ui, server) # uncomment to runMapa coroplético interativo completo
Aqui está um mapa coroplético pronto para produção, combinando todos os principais recursos: blocos de provedores, preenchimento de polígonos, destaques ao passar o cursor, pop-ups dinâmicos, uma legenda de cores e controles de camadas — tudo em menos de 25 linhas.
library(leaflet)
library(sf)
nc <- st_transform(
read_sf(system.file('shape/nc.shp', package = 'sf')), 4326
)
pal <- colorQuantile('YlOrRd', domain = nc$SID74, n = 5)
leaflet(nc) |>
addProviderTiles(providers$CartoDB.Positron) |>
addPolygons(
fillColor = ~pal(SID74),
fillOpacity = 0.75,
color = 'white',
weight = 0.5,
popup = ~paste0('<b>', NAME, '</b><br>SIDS 1974: ', SID74),
highlight = highlightOptions(
weight = 2, color = '#555', bringToFront = TRUE
)
) |>
addLegend(
position = 'bottomright',
pal = pal, values = ~SID74,
title = 'SIDS Deaths 1974<br>(Quintiles)'
) |>
addControl('<b>NC SIDS Data 1974</b>', position = 'topright')Verificação rápida
Em um aplicativo Shiny, você quer atualizar as posições dos marcadores em um mapa leaflet existente quando o usuário altera uma lista suspensa — sem renderizar novamente o mapa inteiro. Qual função você deve usar?
Recapitulação: pacote leaflet
Principais conclusões:
leaflet() |> addTiles()cria um mapa interativo com blocos do OpenStreetMapaddProviderTiles(providers$alterna para outros provedores de blocos) addMarkers()/addCircleMarkers()para dados de pontos; usepopupelabeladdPolygons(fillColor = ~pal(col))para mapas coropléticoscolorNumeric(),colorBin(),colorQuantile()criam funções de paletaaddLegend()combina com funções de paleta;addLayersControl()alterna camadasleafletProxy()para atualizações eficientes de mapas no ShinyfitBounds()ajusta automaticamente o zoom à extensão dos dados
library(leaflet)
# Three-line interactive map
leaflet() |>
addProviderTiles(providers$CartoDB.Positron) |>
addCircleMarkers(lng = c(-74, -118, -88), lat = c(41, 34, 42),
label = c('NYC', 'LA', 'Chicago'), color = 'steelblue')
Aprenda R com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 43
- Aulas
- 159
Perguntas Frequentes
A aula “Mapas interativos com leaflet” é grátis?
Sim — o texto completo de “Mapas interativos com leaflet” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.
O que vou aprender em “Mapas interativos com leaflet”?
Renderize mapas interativos da web com marcadores, pop-ups e camadas de blocos. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar R Academy?
Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Mapas interativos com leaflet”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de R Academy?
Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Elementos simples com o pacote sf
- Sistemas de referência de coordenadas e projeções
- Junções e operações espaciais
- Mapas interativos com leaflet