Criando e Publicando Análises com RMarkdown no RPubs

Introdução ao RMarkdown

O RMarkdown é uma ferramenta que transforma suas análises de dados em documentos de alta qualidade. Pense nele como um caderno de laboratório digital. Em vez de escrever seu código em um lugar, seus gráficos em outro e seu texto explicativo em um terceiro, o RMarkdown permite que você faça tudo isso em um único arquivo.

A filosofia é a da pesquisa reprodutível. Se um colega (ou você mesmo, daqui a seis meses) quiser entender ou replicar sua análise, basta ter este único arquivo .Rmd. Ao executá-lo (“tricotar”, ou knit), o resultado será exatamente o mesmo, garantindo transparência e consistência.

O destino final pode ser um relatório em PDF, uma apresentação de slides, um site ou, como focaremos hoje, uma página web interativa via RPubs.

Anatomia de um Arquivo .Rmd

Um arquivo RMarkdown (.Rmd) tem três componentes principais:

• Cabeçalho YAML: Um bloco de texto no topo do arquivo, cercado por ---, que define metadados e opções globais para o seu documento. É aqui que você define o título, autor, data e o formato de saída.
• Narrativa em Markdown: O texto comum que você escreve para explicar sua análise, introduzir seções e concluir suas ideias. Ele usa uma sintaxe simples chamada Markdown para formatação.
• Code Chunks (Blocos de Código): Blocos de código R (ou outras linguagens), cercados por ```{r} e ```. É aqui que a mágica acontece: você carrega dados, faz manipulações, cria tabelas e gera gráficos.

Vamos ver um exemplo de um chunk básico que carrega as bibliotecas.

# Este é um chunk especial de 'setup'.
# A opção 'include=FALSE' significa que este código será executado, 
# mas nem o código nem seu resultado aparecerão no documento final.
# Ela não foi aqui utilizada para que possam vizualizar as bibliotecas.
# É ótimo para carregar pacotes e definir opções globais.
knitr::opts_chunk$set(echo = TRUE, message = FALSE, warning = FALSE)
library(tidyverse)
library(plotly)
library(lubridate)
library(leaflet)
library(highcharter)
library(DT)
library(wooldridge)

Cabeçalho YAML utilizado nesse arquivo

—
title: “Criando e Publicando Análises com RMarkdown no RPubs”
author: “Bruno Melo de Oliveira Santos”
date: “2025-08-18”
output:
html_document:
toc: false
toc_float: false
theme: lumen
highlight: tango
—

Como Formatar o Texto no RMarkdown

A sintaxe Markdown é projetada para ser fácil de ler e escrever. Aqui estão os elementos de formatação mais comuns que você usará para construir a narrativa do seu documento.

Cabeçalhos de Seção

Para criar hierarquia no seu documento, use o #.

Um #:

Título Principal (Nível 1)

Dois #:

Subtítulo (Nível 2)

Três #:

Um Nível Mais Abaixo (Nível 3)

Ênfase no Texto

Você pode deixar o texto em itálico adicionando um asterísco (*) de cada lado, ou em negrito adicionando dois asteríscos de cada lado (**).

Este texto ficará em itálico.

Este texto ficará em negrito.

Listas

Listas Não Ordenadas:

Use *, + ou -, endentando para sub-itens.

• Primeiro item
• Segundo item
  • Um sub-item aninhado
• Terceiro item

Listas Ordenadas:

Use números seguidos de um ponto.

1. Primeiro passo
2. Segundo passo
3. Terceiro passo

Links e Imagens

Links: [Posit](https://posit.co/)

Posit

Imagens: ![Texto alternativo para a imagem](caminho/para/imagem.jpg)

Texto alternativo para a imagem

Obs: A imagem precisa estar na mesma pasta do seu arquivo .Rmd ou você deve fornecer o caminho completo.

Caixinha Para colocar o texto dentro de uma caixa, utilize um (`) de cada lado.

Aula_RPubs.Rmd

Citações (Blockquotes) Para destacar um texto ou uma citação, use >.

“A arte de programar consiste na arte de organizar e dominar a complexidade.” - Edsger Dijkstra

Equações As equações deverão ser digitadas no formato Latex utilizando dois cifrões de cada lado

$$r\_{t} = {\phi}*{0} + {*\phi}{1}r\_{t-1} + {\phi}*{2}r*{t-2} + a\_{t}$$

\[ r_{t} = {\phi}_{0} + {\phi}_{1}r_{t-1} + {\phi}_{2}r_{t-2} + a_{t} \]

Como Fazer Gráficos Interativos Básicos com Plotly

Análise de Dados: Salários e Educação

Para nossos exemplos, usaremos o conjunto de dados wage1 do pacote wooldridge. Este dataset contém informações sobre salários e outras variáveis para 526 trabalhadores.

Vamos carregar os dados e dar uma olhada em sua estrutura.

# Carrega o dataset "wage1" para o nosso ambiente
data("wage1")

# Visualiza as primeiras linhas e a estrutura dos dados
head(wage1)

##   wage educ exper tenure nonwhite female married numdep smsa northcen south
## 1 3.10   11     2      0        0      1       0      2    1        0     0
## 2 3.24   12    22      2        0      1       1      3    1        0     0
## 3 3.00   11     2      0        0      0       0      2    0        0     0
## 4 6.00    8    44     28        0      0       1      0    1        0     0
## 5 5.30   12     7      2        0      0       1      1    0        0     0
## 6 8.75   16     9      8        0      0       1      0    1        0     0
##   west construc ndurman trcommpu trade services profserv profocc clerocc
## 1    1        0       0        0     0        0        0       0       0
## 2    1        0       0        0     0        1        0       0       0
## 3    1        0       0        0     1        0        0       0       0
## 4    1        0       0        0     0        0        0       0       1
## 5    1        0       0        0     0        0        0       0       0
## 6    1        0       0        0     0        0        1       1       0
##   servocc    lwage expersq tenursq
## 1       0 1.131402       4       0
## 2       1 1.175573     484       4
## 3       0 1.098612       4       0
## 4       0 1.791759    1936     784
## 5       0 1.667707      49       4
## 6       0 2.169054      81      64

glimpse(wage1)

## Rows: 526
## Columns: 24
## $ wage     <dbl> 3.10, 3.24, 3.00, 6.00, 5.30, 8.75, 11.25, 5.00, 3.60, 18.18,…
## $ educ     <int> 11, 12, 11, 8, 12, 16, 18, 12, 12, 17, 16, 13, 12, 12, 12, 16…
## $ exper    <int> 2, 22, 2, 44, 7, 9, 15, 5, 26, 22, 8, 3, 15, 18, 31, 14, 10, …
## $ tenure   <int> 0, 2, 0, 28, 2, 8, 7, 3, 4, 21, 2, 0, 0, 3, 15, 0, 0, 10, 0, …
## $ nonwhite <int> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0…
## $ female   <int> 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1…
## $ married  <int> 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0…
## $ numdep   <int> 2, 3, 2, 0, 1, 0, 0, 0, 2, 0, 0, 0, 2, 0, 1, 1, 0, 0, 3, 0, 0…
## $ smsa     <int> 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1…
## $ northcen <int> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0…
## $ south    <int> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0…
## $ west     <int> 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1…
## $ construc <int> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0…
## $ ndurman  <int> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0…
## $ trcommpu <int> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0…
## $ trade    <int> 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0…
## $ services <int> 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0…
## $ profserv <int> 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1…
## $ profocc  <int> 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1…
## $ clerocc  <int> 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0…
## $ servocc  <int> 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0…
## $ lwage    <dbl> 1.1314021, 1.1755733, 1.0986123, 1.7917595, 1.6677068, 2.1690…
## $ expersq  <int> 4, 484, 4, 1936, 49, 81, 225, 25, 676, 484, 64, 9, 225, 324, …
## $ tenursq  <int> 0, 4, 0, 784, 4, 64, 49, 9, 16, 441, 4, 0, 0, 9, 225, 0, 0, 1…

O dataset contém variáveis interessantes como:

• wage: salário por hora em dólares.

• educ: anos de educação.

• exper: anos de experiência no mercado de trabalho.

• female: variável binária (1 se for mulher, 0 se for homem).

• married: variável binária (1 se for casado(a), 0 se não).

A maneira mais fácil e poderosa de criar gráficos interativos a partir de uma sintaxe que muitos já conhecem é usar a função ggplotly() do pacote plotly. Ela transforma um gráfico estático criado com ggplot2 em uma visualização interativa em HTML.

Gráfico de Dispersão Interativo (Scatter Plot)

Vamos investigar a relação entre anos de educação (educ) e o salário por hora (wage). Para deixar a visualização mais rica, vamos colorir os pontos de acordo com o gênero (female).

Interatividade: Passe o mouse sobre um ponto para ver os valores exatos de educação, salário e gênero. Você também pode usar as ferramentas no canto superior direito do gráfico para dar zoom, mover a área de visualização e salvar o gráfico como uma imagem.

# Criamos o objeto ggplot primeiro
p_dispersao <- ggplot(wage1, aes(x = educ, y = wage,
                                # A transformação ocorre aqui, apenas para o gráfico:
                                color = factor(female,
                                               levels = c(0, 1),
                                               labels = c("Homem", "Mulher")),
                                # A estética 'text' personaliza o que aparece no tooltip
                                text = paste("Educação:", educ, "anos<br>",
                                             "Salário/h: $", round(wage, 2)))) +
  geom_point(alpha = 0.7) +
  # Mapeamos as cores para as novas etiquetas ("Homem", "Mulher")
  scale_color_manual(name = "Gênero", values = c("Homem" = "#02023C", "Mulher" = "#FEB712")) +
  labs(title = "Relação entre Educação e Salário por Gênero",
       x = "Anos de Educação",
       y = "Salário por Hora (USD)") +
  theme_minimal()

# Agora, transformamos o objeto ggplot em um gráfico interativo
ggplotly(p_dispersao, tooltip = "text")

Explicação do código:

1. Criação do Gráfico Estático com ggplot2

O primeiro bloco de código cria um objeto de gráfico chamado p_dispersao.

• p_dispersao <-: Atribui o resultado do código à direita a uma variável chamada p_dispersao.

• ggplot(data = wage1, ...): Esta é a função principal que inicializa o gráfico.

  • data = wage1: Especifica que o conjunto de dados a ser usado é o wage1.

  • aes(x = educ, y = wage, ...): A função aes() (de aesthetics ou “estética”) mapeia as variáveis do conjunto de dados a propriedades visuais do gráfico.

    • x = educ: Mapeia a variável educ (educação) para o eixo X.

    • y = wage: Mapeia a variável wage (salário) para o eixo Y.

    • color = factor(...): Define que a cor dos pontos será determinada pela variável female.

      • factor(female, levels = c(0, 1), labels = c("Homem", "Mulher")): Esta parte é crucial. Ela transforma a variável female (que provavelmente contém valores numéricos como 0 e 1) em uma variável categórica (um “fator” em R). O valor 0 é rotulado como "Homem" e o 1 como "Mulher". Essa transformação é feita apenas para a visualização no gráfico.

    • text = paste(...): Cria um texto personalizado para cada ponto de dados. Esse texto será usado mais tarde pela função ggplotly para criar as caixas de informação (tooltips) interativas.

      • paste("Educação:", educ, "anos<br>", "Salário/h: $", round(wage, 2)): Concatena (junta) vários textos e valores para formar uma única string. Por exemplo: “Educação: 16 anos<br>Salário/h: $ 25.50”.

      • <br>: É uma tag HTML para quebra de linha, que fará o texto aparecer em duas linhas na caixa de informação.

      • round(wage, 2): Arredonda o valor do salário para duas casas decimais.

• + geom_point(alpha = 0.7): Adiciona uma camada de pontos ao gráfico, criando o gráfico de dispersão.

  • alpha = 0.7: Define a transparência dos pontos em 70%. Isso é útil para visualizar áreas com alta concentração de pontos sobrepostos.

• + scale_color_manual(...): Permite personalizar manualmente as cores usadas no mapeamento de color.

  • name = "Gênero": Define o título da legenda das cores como “Gênero”.

  • values = c("Homem" = "#02023C", "Mulher" = "#FEB712"): Atribui cores específicas (em código hexadecimal) para cada um dos rótulos que criamos. A cor azul escuro (#02023C) será usada para “Homem” e a cor amarela (#FEB712) para “Mulher”.

• + labs(...): Adiciona ou modifica os rótulos do gráfico.

  • title = "...": Define o título principal do gráfico.

  • x = "...": Define o rótulo do eixo X.

  • y = "...": Define o rótulo do eixo Y.

• + theme_minimal(): Aplica um tema visual “limpo” ao gráfico, com fundo branco e linhas de grade suaves, sem muitos elementos visuais de fundo.

2. Transformação em Gráfico Interativo com plotly

O segundo bloco de código pega o gráfico estático criado anteriormente e o torna interativo.

• ggplotly(p_dispersao, tooltip = "text"):

  • ggplotly(): É a função da biblioteca plotly que converte um objeto ggplot em um gráfico interativo (HTML).

  • p_dispersao: O primeiro argumento é o objeto do gráfico ggplot que queremos converter.

  • tooltip = "text": Este é o argumento chave. Ele diz à função ggplotly para usar o mapeamento estético text que definimos dentro de aes() como o conteúdo da caixa de informação que aparece quando o usuário passa o mouse sobre um ponto no gráfico.

Gráfico de Barras Interativo (Bar Plot)

Qual é o salário médio por gênero? Um gráfico de barras é ideal para responder a essa pergunta. Primeiro, precisamos preparar os dados, calculando a média de salário para homens e mulheres.

Interatividade: Passe o mouse sobre as barras para ver o salário médio exato para cada grupo.

# 1. Preparar os dados: agrupar por gênero e calcular o salário médio
salario_medio_genero <- wage1 %>%
  mutate(genero_label = factor(female, labels = c("Homem", "Mulher"))) %>%
  group_by(genero_label) %>%
  summarise(salario_medio = mean(wage))

# 2. Criar o gráfico de barras com ggplot
p_barras <- ggplot(salario_medio_genero, aes(x = genero_label, y = salario_medio, fill = genero_label,
                                             text = paste("Salário Médio: $", round(salario_medio, 2)))) +
  geom_col() + # geom_col é usado quando a altura da barra já é um valor no dataset
  scale_fill_manual(values = c("Homem" = "#02023C", "Mulher" = "#FEB712")) +
  labs(title = "Salário Médio por Hora por Gênero",
       x = "Gênero",
       y = "Salário Médio por Hora (USD)") +
  theme_minimal() +
  theme(legend.position = "none") # Remove a legenda, pois a informação já está no eixo x

# 3. Transformar em interativo
ggplotly(p_barras, tooltip = "text")

Explicação do código:

1. Preparação e Sumarização dos Dados com dplyr

Esta seção usa o operador “pipe” (%>%) da biblioteca dplyr para criar um novo dataframe resumido chamado salario_medio_genero. O pipe pega o resultado do comando à sua esquerda e o usa como o primeiro argumento do comando à sua direita, tornando o código mais legível.

• salario_medio_genero <- wage1 %>% ...: Inicia a sequência de operações com o dataframe wage1 e atribui o resultado final à variável salario_medio_genero.

• mutate(genero_label = ...): A função mutate cria uma nova coluna no dataframe.

  • genero_label = factor(female, labels = c("Homem", "Mulher")): Cria uma coluna chamada genero_label. Assim como no exemplo anterior, ela converte a variável numérica female (com valores 0 e 1) em uma variável categórica com os rótulos “Homem” e “Mulher”.

• group_by(genero_label): Agrupa o dataframe pela nova coluna genero_label. A partir deste ponto, qualquer operação subsequente será realizada separadamente para cada grupo (para todos os “Homem” e para todas as “Mulher”).

• summarise(salario_medio = mean(wage)): A função summarise (ou summarize) colapsa os dados agrupados em uma única linha por grupo, criando colunas de resumo.

  • salario_medio = mean(wage): Cria uma nova coluna chamada salario_medio que contém a média (mean) da coluna wage (salário) para cada um dos grupos definidos anteriormente.

O resultado final é um pequeno dataframe com duas linhas e duas colunas: genero_label e salario_medio.

2. Criação do Gráfico de Barras Estático com ggplot2

Este bloco usa o dataframe recém-criado para gerar um gráfico de barras.

• p_barras <- ggplot(...): Inicia a criação do objeto de gráfico e o atribui à variável p_barras.

• ggplot(salario_medio_genero, aes(x = genero_label, ...)): Usa o dataframe salario_medio_genero como fonte.

  • aes(x = genero_label, y = salario_medio, fill = genero_label, text = ...): Mapeia as variáveis às estéticas do gráfico.

    • x = genero_label: As categorias no eixo X serão “Homem” e “Mulher”.

    • y = salario_medio: A altura das barras será determinada pelo valor na coluna salario_medio.

    • fill = genero_label: A cor de preenchimento (fill) de cada barra será determinada pela categoria de gênero.

    • text = paste(...): Novamente, cria o texto personalizado para o tooltip interativo. Por exemplo: “Salário Médio: $ 7.09”.

• + geom_col(): Adiciona a camada de barras ao gráfico. É importante notar que se usa geom_col() (e não geom_bar()) porque a altura das barras (y) já é um valor explícito no dataframe. geom_bar() seria usado se quiséssemos que o próprio ggplot contasse o número de ocorrências de cada categoria.

• + scale_fill_manual(...): Personaliza as cores de preenchimento das barras.

  • values = c(...): Atribui as mesmas cores do exemplo anterior (azul escuro e amarelo) às categorias “Homem” e “Mulher”.

• + labs(...): Define os títulos e rótulos do gráfico.

• + theme_minimal(): Aplica o tema visual minimalista.

• + theme(legend.position = "none"): Modifica o tema para remover a legenda de cores. Isso é feito porque a informação de cor já está representada de forma clara no eixo X, tornando a legenda redundante.

3. Transformação em Gráfico Interativo com plotly

Esta linha final converte o gráfico estático em uma visualização interativa.

• ggplotly(p_barras, tooltip = "text"):

  • ggplotly(): Converte o objeto ggplot (p_barras) em um gráfico interativo.

  • tooltip = "text": Instrui o plotly a usar a string de texto que criamos na estética text para exibir uma caixa de informação personalizada quando o usuário passar o mouse sobre as barras do gráfico.

Gráfico de Barras Empilhadas Interativo (Stacked Bar Plot)

Agora, vamos analisar a composição do estado civil (married) dentro de cada gênero. Um gráfico de barras empilhadas nos mostrará a contagem de pessoas casadas e não casadas para homens e mulheres.

Interatividade: Passe o mouse sobre cada segmento da barra para ver a contagem exata daquele grupo específico (ex: mulheres casadas, homens não casados).

# --- 1. Opções de Cores Personalizadas (Fácil de Modificar) ---
# Crie um vetor nomeado para as cores. Mudar as cores aqui é simples e direto.
# O nome ("Não Casado(a)") deve corresponder exatamente à etiqueta do fator.
cores_estado_civil <- c(
  "Não Casado(a)" = "#02023C", # Uma cor para os não casados
  "Casado(a)"     = "#FEB712"  # Uma cor para os casados
)


# --- 2. Criação do Gráfico ggplot ---
p_empilhado <- ggplot(wage1, aes(
    x = factor(female, labels = c("Homem", "Mulher")),
    fill = factor(married, labels = c("Não Casado(a)", "Casado(a)")),
    
    # --- 3. Adicionando um "Bom Tooltip" ---
    # A estética 'text' define o conteúdo do tooltip. Usamos paste() para juntar o texto.
    # <br> é uma tag HTML para criar uma nova linha no tooltip.
    text = paste("Gênero:", factor(female, labels = c("Homem", "Mulher")),
                 "<br>Estado Civil:", factor(married, labels = c("Não Casado(a)", "Casado(a)")))
  )) +
  geom_bar(position = "stack") +
  
  # Usando as cores que definimos anteriormente
  scale_fill_manual(values = cores_estado_civil) +
  
  labs(
    title = "Distribuição do Estado Civil por Gênero",
    x = "Gênero",
    y = "Contagem de Indivíduos",
    fill = "Estado Civil" # Controla o título da legenda
  ) +
  theme_minimal() +
  theme(plot.title = element_text(hjust = 0.5)) # Centraliza o título


# --- 4. Transformar em Interativo com o Tooltip Personalizado ---
# ggplotly vai usar a estética 'text' que definimos para criar o tooltip.
# Ele é inteligente o suficiente para adicionar a contagem automaticamente.
ggplotly(p_empilhado, tooltip = c("text", "y"))

Explicação do gráfico:

1. Criação do Gráfico Estático com ggplot2

Construção do gráfico visual usando a biblioteca ggplot2.

• cores_estado_civil <- c(...): Cria um “vetor nomeado” em R chamado cores_estado_civil. Pense nisso como um pequeno dicionário ou uma lista de pares chave-valor.

  • "Não Casado(a)" = "#02023C": Associa a string (o rótulo) "Não Casado(a)" ao código de cor hexadecimal para azul escuro.

  • "Casado(a)" = "#FEB712": Associa o rótulo "Casado(a)" ao código de cor para amarelo/laranja.

• p_empilhado <- ggplot(wage1, aes(...)): Inicia o gráfico usando o dataframe wage1 e o atribui ao objeto p_empilhado.

• aes(...): Define o mapeamento das variáveis do dataframe para as propriedades visuais (“estéticas”) do gráfico.

  • x = factor(female, labels = c("Homem", "Mulher")): Mapeia o eixo X à variável female, transformando-a em um fator com os rótulos “Homem” e “Mulher”. Isso criará duas barras principais no gráfico.

  • fill = factor(married, labels = c("Não Casado(a)", "Casado(a)")): Esta é a estética chave para o empilhamento. Ela determina que a cor de preenchimento (fill) das barras será baseada na variável married (estado civil). O ggplot irá dividir cada barra do eixo X em segmentos coloridos, um para cada estado civil.

  • text = paste(...): Cria a string de texto personalizada para o tooltip interativo. A função paste() junta os textos e variáveis. Por exemplo, para um ponto de dados de uma mulher casada, o texto seria: "Gênero: Mulher<br>Estado Civil: Casado(a)". A tag <br> garante uma quebra de linha no tooltip.

• + geom_bar(position = "stack"): Adiciona a camada de geometria que desenha as barras.

  • geom_bar(): Como estamos fornecendo apenas uma variável x (e uma fill), esta função automaticamente conta o número de observações para cada combinação de x e fill. O resultado dessa contagem é mapeado para a altura no eixo Y.

  • position = "stack": Especifica que os segmentos definidos pela estética fill devem ser empilhados uns sobre os outros.

• + scale_fill_manual(values = cores_estado_civil): Personaliza as cores de preenchimento. Ele instrui o ggplot a usar as cores que definimos no nosso vetor cores_estado_civil. A correspondência é feita pelos nomes (“Casado(a)”, “Não Casado(a)”).

• + labs(...): Configura os textos de rótulos e títulos do gráfico.

  • fill = "Estado Civil": Um detalhe importante aqui é que fill dentro de labs() define o título da legenda associada à estética de preenchimento.

• + theme_minimal(): Aplica o tema visual limpo.

• + theme(plot.title = element_text(hjust = 0.5)): Faz um ajuste fino no tema.

  • plot.title: Seleciona o elemento do título do gráfico para modificação.

  • element_text(hjust = 0.5): hjust significa “justificação horizontal”. Um valor de 0.5 (ou seja, 50%) centraliza o texto. 0 alinha à esquerda e 1 à direita.

2. Transformação em Gráfico Interativo com plotly

A linha final dá vida ao gráfico estático.

• ggplotly(p_empilhado, tooltip = c("text", "y")):

  • ggplotly(): Converte o objeto ggplot (p_empilhado) em uma visualização HTML interativa.

  • tooltip = c("text", "y"): Este argumento controla o que é exibido na caixa de informação (tooltip) ao passar o mouse. Ao fornecer um vetor com c("text", "y"), você está pedindo para o plotly mostrar duas informações:

    • "text": O conteúdo da sua estética text personalizada.

    • "y": O valor do eixo Y para aquele segmento da barra (neste caso, a contagem de indivíduos).

Como Fazer Gráficos Interativos Complexos com Highchart

Carregamento e Preparação dos Dados

Primeiro, carregamos e preparamos o dataset intdef para a visualização, criando uma coluna de data e as colunas necessárias para o sombreamento entre as séries.

# Carregar os dados
data("intdef")

# Preparar o dataframe para o highcharter
df_analise <- intdef %>%
  # Selecionar e renomear variáveis para maior clareza
  select(ano = year, juros = i3, inflacao = inf) %>%
  # Criar uma coluna de data formal
  mutate(data = as.Date(paste0(ano, "-01-01"))) %>%
  # Ordenar por data, uma boa prática para séries temporais
  arrange(data)

# Visualizar o dataframe transformado
head(df_analise)

##    ano juros inflacao       data
## 1 1948  1.04      8.1 1948-01-01
## 2 1949  1.10     -1.2 1949-01-01
## 3 1950  1.22      1.3 1950-01-01
## 4 1951  1.55      7.9 1951-01-01
## 5 1952  1.77      1.9 1952-01-01
## 6 1953  1.93      0.8 1953-01-01

Construção do Gráfico Interativo

Agora, vamos construir nosso gráfico. Além das séries de dados e dos marcadores de eventos, adicionaremos as faixas de recessão.

Dados para os Marcadores (Flags)

Criamos um dataframe para os eventos (choques do petróleo) que queremos destacar.

flags_data <- data.frame(
  data = as.Date(c("1973-10-01", "1979-01-01")),
  title = c("C1", "C2"),
  text = c("Primeiro Choque do Petróleo (1973)", "Segundo Choque do Petróleo (1979)")
)

Explicação do código:

• flags_data <-: Inicia a atribuição. O resultado do comando à direita será armazenado em um novo objeto (uma variável) chamado flags_data.

• data.frame(...): Esta é a função principal em R para criar um data.frame, que é a estrutura padrão para armazenar dados em formato de tabela (linhas e colunas), similar a uma planilha. Cada argumento dentro da função define uma coluna da tabela.

  • data = as.Date(c("1973-10-01", "1979-01-01")):

    • data = ...: Cria uma coluna chamada data.

    • c("1973-10-01", "1979-01-01"): Cria um vetor (uma lista) de strings de texto contendo duas datas.

    • as.Date(...): Esta é uma função crucial. Ela converte as strings de texto em um formato especial de Data que o R entende. Isso é fundamental para que bibliotecas de gráficos como ggplot2 ou plotly saibam posicionar corretamente esses pontos em um eixo de tempo.

  • title = c("C1", "C2"):

    • title = ...: Cria uma segunda coluna chamada title.

    • c("C1", "C2"): Cria um vetor de texto com rótulos curtos. Em um gráfico, estes são frequentemente usados como pequenos textos que aparecem diretamente sobre ou ao lado de um marcador de evento.

  • text = c("Primeiro Choque do Petróleo (1973)", "Segundo Choque do Petróleo (1979)"):

    • text = ...: Cria uma terceira coluna chamada text.

    • c(...): Cria um vetor de texto com descrições mais longas. Este texto é ideal para ser usado como o conteúdo da caixa de informação (tooltip) que aparece quando um usuário passa o mouse sobre o marcador do evento em um gráfico interativo.

Dados para as Faixas de Recessão (Plot Bands)

Para adicionar as faixas de recessão, precisamos de uma lista contendo as datas de início e fim de cada período. Utilizaremos as datas oficiais do National Bureau of Economic Research (NBER) para os EUA. O highcharter espera que as datas de início (from) e fim (to) estejam em formato de timestamp (milissegundos desde 1970-01-01), mas ele faz a conversão automaticamente a partir de objetos Date.

# Função para converter data para timestamp em milissegundos
date_to_timestamp <- function(date_string) {
  as.numeric(as.POSIXct(date_string)) * 1000
}

# Lista que define cada faixa de recessão com o formato de data corrigido
recession_bands <- list(
  list(from = date_to_timestamp("1948-11-01"), to = date_to_timestamp("1949-10-01"), color = "rgba(100, 100, 100, 0.2)", label = list(style = list(color = "gray"))),
  list(from = date_to_timestamp("1953-07-01"), to = date_to_timestamp("1954-05-01"), color = "rgba(100, 100, 100, 0.2)"),
  list(from = date_to_timestamp("1957-08-01"), to = date_to_timestamp("1958-04-01"), color = "rgba(100, 100, 100, 0.2)"),
  list(from = date_to_timestamp("1960-04-01"), to = date_to_timestamp("1961-02-01"), color = "rgba(100, 100, 100, 0.2)"),
  list(from = date_to_timestamp("1969-12-01"), to = date_to_timestamp("1970-11-01"), color = "rgba(100, 100, 100, 0.2)"),
  list(from = date_to_timestamp("1973-11-01"), to = date_to_timestamp("1975-03-01"), color = "rgba(100, 100, 100, 0.2)"),
  list(from = date_to_timestamp("1980-01-01"), to = date_to_timestamp("1980-07-01"), color = "rgba(100, 100, 100, 0.2)"),
  list(from = date_to_timestamp("1981-07-01"), to = date_to_timestamp("1982-11-01"), color = "rgba(100, 100, 100, 0.2)"),
  list(from = date_to_timestamp("1990-07-01"), to = date_to_timestamp("1991-03-01"), color = "rgba(100, 100, 100, 0.2)"),
  list(from = date_to_timestamp("2001-03-01"), to = date_to_timestamp("2001-11-01"), color = "rgba(100, 100, 100, 0.2)")
)

Explicação do código:

1. Função para conversão de datas.

• date_to_timestamp <- function(date_string) { ... }: Define uma nova função chamada date_to_timestamp que aceita um argumento, date_string (uma data em formato de texto).

• as.POSIXct(date_string): Esta é a primeira etapa da conversão. Ela pega a string de texto (ex: "1948-11-01") e a converte para um formato de data/hora que o R entende, chamado POSIXct. Internamente, este formato armazena a data como o número de segundos passados desde o início da “era Unix” (01 de janeiro de 1970).

• as.numeric(...): Extrai apenas o valor numérico (o número de segundos) do objeto POSIXct.

• * 1000: Multiplica o número de segundos por 1000. Isso converte o valor para milissegundos. Essa conversão é muito comum porque bibliotecas de gráficos interativos baseadas em JavaScript (como Highcharts, que é usada pelo pacote highcharter em R) exigem que os tempos sejam fornecidos em milissegundos.

Em resumo, a função pega uma data em texto e a transforma em um número que representa essa mesma data em milissegundos, pronta para ser usada por uma biblioteca de gráficos.

2. Estrutura de Dados: recession_bands

Esta parte do código cria o objeto principal, uma lista chamada recession_bands.

• recession_bands <- list(...): Cria uma lista. Em R, uma lista é uma coleção que pode conter diversos tipos de objetos, inclusive outras listas. Isso a torna perfeita para armazenar configurações complexas.

• list(from = ..., to = ..., color = ...): A lista recession_bands contém uma série de outras listas. Cada uma dessas listas internas representa uma única faixa de recessão e possui os seguintes elementos nomeados:

  • from: Define o início da faixa de recessão. O valor é obtido chamando a função date_to_timestamp() com a data de início.

  • to: Define o fim da faixa de recessão, também usando a função para converter a data.

  • color = "rgba(100, 100, 100, 0.2)": Define a cor da faixa sombreada. O formato rgba significa Vermelho (Red), Verde (Green), Azul (Blue) e Alpha (transparência). Neste caso, (100, 100, 100) é um tom de cinza, e 0.2 é o nível de alpha, que torna a faixa 80% transparente, permitindo que os dados do gráfico (como uma linha) sejam vistos através dela.

  • label = list(...): Um elemento opcional para configurar um rótulo de texto que pode ser exibido sobre a faixa.

Código do Gráfico Final

Juntamos todas as peças, incluindo a chamada à função hc_xAxis para adicionar as plotBands.

highchart(type = "stock") %>%
  # Adição das séries de dados (Juros e Inflação)
  hc_add_series(data = df_analise, type = "line", hcaes(x = data, y = juros), name = "Taxa de Juros (i3)", id = "juros", color = "#02023C") %>%
  hc_add_series(data = df_analise, type = "line", hcaes(x = data, y = inflacao), name = "Inflação (inf)", color = "#FEB712") %>%
  
  # A SÉRIE 'arearange' FOI REMOVIDA DESTA SEÇÃO
  
  # Adição dos marcadores de eventos (flags)
  hc_add_series(data = flags_data, type = "flags", hcaes(x = data, title = title, text = text), onSeries = "juros", name = "Eventos Históricos") %>%
  
  # Adição das Faixas de Recessão ao Eixo X
  hc_xAxis(
    plotBands = recession_bands
  ) %>%

  # Títulos e legendas
  hc_title(text = "Relação entre Taxa de Juros e Inflação nos EUA (1948-2003)") %>%
  hc_subtitle(text = "Períodos de recessão (NBER) indicados por faixas sombreadas") %>%
  hc_credits(enabled = TRUE, text = "Fonte: Wooldridge, NBER | Gráfico: Highcharter") %>%
  hc_legend(enabled = TRUE) %>% 
  
  #Disponibilização de download do gráfico e dos dados
  hc_exporting(enabled = TRUE) %>% 
  
  # Tooltip customizado
  hc_tooltip(
    shared = TRUE, 
    crosshairs = TRUE,
    valueDecimals = 2,
    pointFormat = '<span style="color:{point.color}">\u25CF</span> {series.name}: <b>{point.y} %</b><br/>'
  )

Explicação do código:

• highchart(type = "stock"):

  • Esta é a função que inicializa o objeto do gráfico.

  • type = "stock": Especifica que queremos criar um “gráfico de ações”. Este tipo de gráfico é otimizado para séries temporais e inclui automaticamente ferramentas úteis, como um navegador de intervalo de datas (o “navigator” na parte inferior) e botões de zoom predefinidos (1m, 3m, 1a, etc.).

• hc_add_series(...):

  • Esta função é usada para adicionar camadas de dados (séries) ao gráfico. É chamada três vezes aqui:

  1. Primeira chamada (Juros):

     • data = df_analise, type = "line", hcaes(x = data, y = juros): Adiciona os dados do dataframe df_analise como uma linha (type = "line"), mapeando a coluna data para o eixo X e juros para o eixo Y.

     • name = "...": Define o nome da série que aparecerá na legenda e no tooltip.

     • id = "juros": Atribui um identificador único a esta série. Isso é crucial, pois permite que outras camadas (como as “flags”) se refiram a esta linha específica.

     • color = "...": Define a cor da linha.

  2. Segunda chamada (Inflação): Faz o mesmo que a anterior, mas para a coluna inflacao, com uma cor diferente.

  3. Terceira chamada (Flags/Eventos):

     • data = flags_data: Usa o dataframe flags_data que criamos anteriormente.

     • type = "flags": Especifica um tipo de série especial para marcar eventos no gráfico.

     • hcaes(x = data, title = title, text = text): Mapeia as colunas do flags_data para as propriedades das flags: x para a posição no tempo, title para o rótulo curto no gráfico (C1, C2) e text para a descrição longa no tooltip.

     • onSeries = "juros": Instrui o Highcharter a ancorar essas flags diretamente na linha que tem o id = "juros". Isso faz com que os marcadores apareçam sobre a linha de juros.

• hc_xAxis(plotBands = recession_bands):

  • Esta função personaliza o eixo X.

  • plotBands = recession_bands: Este é o argumento chave que recebe a lista recession_bands que definimos no código anterior. O Highcharter usa essa lista para desenhar as faixas sombreadas no fundo do gráfico, indicando os períodos de recessão.

• hc_title(...), hc_subtitle(...), hc_credits(...), hc_legend(...):

  • Este bloco de funções configura os elementos textuais e de metadados do gráfico: o título principal, o subtítulo, os créditos (fonte dos dados) no canto inferior e garante que a legenda esteja habilitada.

• hc_exporting(enabled = TRUE):

  • Adiciona o menu “hambúrguer” (☰) no canto superior direito do gráfico, que permite ao usuário final baixar a visualização como uma imagem (PNG, JPEG, SVG) ou exportar os dados brutos (CSV, XLS).

• hc_tooltip(...):

  • Personaliza a caixa de informações (tooltip) que aparece quando o mouse passa sobre o gráfico.

  • shared = TRUE: Faz com que uma única caixa de informações apareça para todas as séries em um ponto específico do tempo. Ao passar o mouse sobre uma data, você verá os valores de juros e inflação juntos.

  • crosshairs = TRUE: Ativa as linhas de mira (vertical e horizontal) que seguem o cursor, facilitando a leitura dos valores nos eixos.

  • valueDecimals = 2: Formata os números no tooltip para terem sempre duas casas decimais.

  • pointFormat = '...': Define um modelo (template) HTML para formatar cada linha dentro do tooltip compartilhado.

    • <span style="color:{point.color}">\u25CF</span>: Cria um marcador de círculo (\u25CF) que herda a cor da série ({point.color}).

    • {series.name}: Insere o nome da série (ex: “Taxa de Juros (i3)”).

    • <b>{point.y} %</b>: Insere o valor do ponto no eixo Y ({point.y}), em negrito (<b>), seguido de um sinal de porcentagem.

    • <br/>: Adiciona uma quebra de linha.

Mapas Interativos com leaflet

Quando você tem dados geográficos, o leaflet é a ferramenta ideal. Vamos criar um mapa simples que marca a localização de algumas capitais brasileiras.

# Criamos um dataframe com as coordenadas das cidades
capitais <- data.frame(
  nome = c("Belo Horizonte", "Rio de Janeiro", "São Paulo", "Salvador"),
  lat = c(-19.9245, -22.9068, -23.5505, -12.9777),
  lon = c(-43.9352, -43.1729, -46.6333, -38.5016),
  populacao = c("2.5 milhões", "6.7 milhões", "12.3 milhões", "2.9 milhões")
)

# Criando o mapa
leaflet(data = capitais) %>%
  addTiles() %>%  # Adiciona o mapa base (OpenStreetMap)
  addMarkers(
    lng = ~lon, 
    lat = ~lat, 
    popup = ~paste0("<strong>", nome, "</strong><br>População Aprox.: ", populacao)
  )

1. Criação do Dataframe capitais

Esta primeira parte do código simplesmente organiza os dados que serão exibidos no mapa em uma tabela.

• capitais <- data.frame(...): Cria um objeto do tipo data.frame (a estrutura de tabela padrão do R) e o armazena na variável capitais.

• Dentro do data.frame(), cada argumento cria uma coluna na tabela:

  • nome = c(...): Cria a coluna nome, contendo um vetor de texto com os nomes das capitais.

  • lat = c(...): Cria a coluna lat, contendo as coordenadas de latitude para cada cidade.

  • lon = c(...): Cria a coluna lon, contendo as coordenadas de longitude para cada cidade.

  • populacao = c(...): Cria a coluna populacao, com a população aproximada de cada cidade armazenada como texto.

O resultado é uma tabela organizada, onde cada linha representa uma cidade e suas respectivas propriedades (nome, coordenadas, etc.).

2. Construção do Mapa com leaflet

Esta seção usa o data.frame criado e o encadeamento de funções (através do pipe %>%) para construir o mapa camada por camada.

• leaflet(data = capitais):

  • Esta é a função que inicializa o objeto do mapa.

  • data = capitais: Informa ao leaflet que o conjunto de dados padrão para as camadas seguintes será o dataframe capitais. Isso evita que precisemos especificar a fonte de dados em cada função subsequente.

• %>% addTiles():

  • Adiciona a camada de “azulejos” (tiles), que é o mapa base visual. Por padrão, ele busca os mapas do OpenStreetMap, um projeto de mapeamento colaborativo e gratuito. Sem esta linha, você teria apenas um quadro em branco.

• %>% addMarkers(...):

  • Adiciona os marcadores (alfinetes) ao mapa, um para cada linha do nosso dataframe.

  • lng = ~lon e lat = ~lat: Estes argumentos especificam de onde virão as coordenadas para os marcadores. O til (~) é uma forma de dizer ao leaflet para “procurar por uma coluna com este nome (lon ou lat) dentro do dataframe que foi fornecido na função leaflet()”.

  • popup = ~paste0(...): Este argumento define o conteúdo da janela pop-up que aparece quando um usuário clica em um marcador.

    • paste0(...): É uma função do R que junta (concatena) textos.

    • "<strong>", nome, "</strong>": Pega o valor da coluna nome e o envolve com as tags HTML <strong>, o que fará com que o nome da cidade apareça em negrito.

    • "<br>": Adiciona uma quebra de linha em HTML.

    • "População Aprox.: ", populacao: Junta um texto fixo com o valor da coluna populacao.

Publicando no RPubs

Agora que seu documento está pronto, com texto formatado e gráficos interativos, é hora de compartilhá-lo. O RPubs é uma plataforma gratuita e simples, perfeitamente integrada ao RStudio.

Passo 1: Instalar o Pacote rsconnect Se você nunca publicou antes, precisará instalar o pacote que gerencia a conexão. Você só precisa fazer isso uma vez.

# Execute este código no seu Console do R, não precisa estar em um chunk.
install.packages("rsconnect")  

Passo 2: “Tricotar” (Knit) seu Documento Clique no botão Knit (ou use o atalho Ctrl+Shift+K) no RStudio. Isso irá gerar o arquivo html final. Uma janela de visualização aparecerá com o seu relatório.

Passo 3: Publicar Na janela de visualização do seu relatório, no canto superior direito, você verá um botão Publish.

1. Clique em Publish.

2. Escolha a opção RPubs.

3. Se for sua primeira vez, o RStudio pedirá para você se autenticar. Ele abrirá uma página no seu navegador para você criar ou logar em uma conta no RPubs. Siga as instruções.

4. Após a autenticação, dê um nome e uma descrição para sua publicação e clique em Publish.

Pronto! O RStudio fará o upload do seu documento e de todos os arquivos necessários (como os gráficos interativos) para o servidor do RPubs. Ao final, ele abrirá o seu navegador na página da sua publicação recém-criada, com um link que você pode compartilhar com quem quiser.