Como montar um Dashboard para acompanhar seus dados de Monitoramento Ambiental usando R?

Confira nosso curso online de Word

Monitoramentos ambientais geram uma grande quantidade de dados que podem ser acompanhados por meio de um painel (dashboard). Aprenda a criar o seu no R nesta postagem.

Assim que uma licença ambiental é aprovada pelo órgão público, já são estabelecidas condicionantes para que o empreendimento minimize ou elimine os impactos ambientais vinculados à sua atividade.

Muita das condicionantes estão relacionadas ao acompanhamento da qualidade de efluentes, níveis de ruído, concentração de poluentes no ar, sendo necessário medições frequentes.

E para acompanhar e analisar os resultados, muitas vezes perdemos muito tempo atualizando os gráficos nas nossas planilhas do Excel.

Embora você ainda precisará alimentar o seu banco de dados, uma forma de facilitar e agilizar a análise dos dados ambientais é por meio de um dashboard.

Um dashboard é um painel que permite agregar vários gráficos e dados simultaneamente.

No R, ele é possível utilizando o pacote flexdashboard, o qual permite trazer o potencial de análises estatísticas do R e a facilidade dos códigos de Markdown. Além disso, podemos adicionar algumas funcionalidades do pacote shiny, tal como a interatividade dos gráficos.

Nesta postagem, vamos criar um dashboard com os dados dos Índices de Qualidade da Água (IQA) de vários rios brasileiros, mostrandos os dados por estado, criando abas específicas para média, desvio padrão e outros, e comparando com boxplots os dados entre dois rios.

Leia também: O que é Índice de Qualidade da Água – IQA e como Calculá-lo no Excel?

Baixando os dados e preparando o RStudio

Os dados que usaremos estão disponívels no Portal Brasileiro de Dados Abertos, sendo que você pode baixar o arquivo CSV clicando aqui.

Agora que já temos nossos dados, vamos criar um arquivo do tipo R Markdown no RStudio para desenvolver nosso dashboard. Mas antes de criar esse arquivo, precisamos instalar o pacote flexdashboard para termos ele no nosso banco de templates. Você pode usar o código abaixo no terminal do RStudio para instalar e carregar ele.

install.packages("flexdashboard")
library("flexdashboard")

Após executar esse comando, clique em Arquivo (File) > Arquivo Novo (New File) > R Markdown. Vá na opção “Do Template” (From Template) e selecione Flex Dashboard.

Janela do RStudio para criação de um novo markdown.
Janela do RStudio para criação de um novo markdown.

Após clicar em OK, você terá um documento padrão para criar o seu dashboard.

Entendendo a estrutura do Flex Dashboard

O arquivo em branco que será carregado já terá algumas estruturas básicas do R Markdown. Logo no inicio temos o cabeçalho, onde informamos dados como:

  • Título (Title): Nome do documento;
  • Saída (Output): Define diferentes parâmetros para o arquivo;
  • Orientação (Orientation): Estabelece se o documento deve conter linhas ou colunas, sendo este último o padrão;
  • Layout Vertical (Vertical Layout): Ao gerar seus gráficos, é possível definir se eles ajustarão sua altura automaticamente (fill) ou não (scroll);
  • Logo (Logo): Permite inserir uma imagem no canto do seu dashboard;
  • Tema (Theme): Modifica a fonte e esquema de cores do dashboard.

Esses são apenas alguns itens que pode ser inseridos no cabeçalho, sendo que outros podem ser inseridos conforme a necessidade.

Em seguida, temos um bloco de código do R, o qual é iniciado e finalizado por três crases (`). Note que entre as chaves, há o parâmetro Include definido como FALSE, indicado que o resultado dentro deste bloco de código não deverá aparecer quando executarmos nosso R Markdown.

Após o bloco de código, temos o inicio de um quadro (Chart).

Os quadros são iniciados com o nome da sua linha (ou coluna), sendo possível inserir alguns parâmetros para ele entre chaves e na linha seguinte devemos inserir, no mínimo, três hifens. Em seguida, criamos o quadro em si, onde são colocados três quadrados (#) e o nome do quadro.

As linhas seguintes são repetições do que já explicamos, ou seja, estão inserindo novos quadros no dashboard criado.

É importante comentar de mais uma estrutura, aquela para criação de páginas, onde ao gerar o dashboards, essas irão aparecer como se fossem novas abas. Elas são semelhantes aos quadros, mas ao invés de usarmos hifens, usamos o sinal de igual (=).

Agora que entendemos um pouco da estrutura do nosso código padrão, vamos modificá-lo para criarmos nosso dashboard.

Criando o dashboard no R

Vamos alterar o título do nosso dashboard e inserir alguns parâmetros dele. O código seguinte insere nosso logo e define um tema.

Além disso, também vamos estabelecer que o nosso R Markdown rode usando a funcionalidade shiny, isso é obtido usando o parâmetro runtime, conforme código abaixo.

---
title: "Indicador de Qualidade da Água (2001-2014)"
output: 
  flexdashboard::flex_dashboard:
    logo: B2E.png
    theme: spacelab
runtime: shiny
---

Após o cabeçalho, temos nosso espaço para inserir alguns códigos R. Aqui vamos definir algumas bibliotecas que devem ser carregadas (pela função library) e definiremos o local de trabalho (função setwd) e criaremos uma variável chamada “dados” para abrigar nossa planilha de dados (usando a função read.csv).

```{r setup, include=FALSE}
library(flexdashboard)
library(ggplot2)
library(plotly)
library(dplyr)

setwd("c:/Users/ferna/Desktop/blogPost/")
dados <- read.csv("IQA_2001_2014.csv", encoding = "UTF-8")

```

Veja que carregamos, além da biblioteca flexdashboard, as bibliotecas ggplot2 (para criação dos gráficos), plotly (para criação de gráficos interativos) e a dplyr (para tratamentos dos nossos dados).

Agora precisamos ter em mente o formato do nosso dashboard para facilitar sua criação.

Vamos trabalhar com duas páginas (abas), uma contendo os dados brutos e a outra com boxplots. Na primeira página vamos inserir nossos gráficos em apenas uma coluna (ou seja, teremos duas linhas), onde a segunda alinha apresenta gráficos agrupados. Na segunda página, teremos duas colunas, cada uma com um boxplot do rio selecionado.

A figura abaixo mostra o resultado que pretendemos.

Dashboard após sua finalização no R.
Dashboard após sua finalização no R.

Agora que sabemos como deverá ficar nosso dashboard, vamos criar os cabeçalhos de cada quadro. O código abaixo mostra como criar esses quadros.

Dados Brutos {data-orientation=rows}
===

Comandos1 {.sidebar}
---
```{r}

```

Quadro01
-----------------------------------------------------------------------

### IQA
```{r}

```

QuadroAgrupado {.tabset}
---------------------------------

### Média
```{r}

```

### Mínimo
```{r}

```

### Máximo
```{r}

```

### Desvio Padrão
```{r}

```

No código, temos as seguintes páginas e quadros:

  • Dados Brutos: Esse é o nome da nossa primeira página, sendo que usamos, entre chaves, o parâmetro data-orientation para modificá-lo para linhas (pois o padrão do documento são colunas);
  • Comandos1: Usando o parâmetro .sidebar indicamos ao R que este quadro é uma barra lateral, onde vamos inserir os comandos para o usuários modificar;
  • Quadro01: Este é nosso quadro com os dados brutos selecionados;
  • QuadroAgrupado: Este quadro irá agrupar, usando o parâmetro .tabset, diferentes quadros.

Dentro de cada quadro temos um bloco de código R, nos quais estaremos inserindo nossos códigos para criar as listas de seleção e os nossos gráficos.

No bloco referente ao quadro Comandos1, vamos usar a função selectInput() para indicar quais são os dados de entrada.

Comandos1 {.sidebar}
---
```{r}
selectInput("estados", label = "Estado: ", choices = unique(dados$UF), selected = "SP")
```

O primeiro argumento desta função (“estados”) é o nome deste campo de entrada e usaremos ele para referenciar essa entrada. Em seguida indicamos qual é o rótulo que vai aparecer para o usuário (label), quais são as escolhas possíveis (choices) e qual deverá começar sendo selecionada (selected).

No parâmetro choices, usamos a função unique() para dizer ao R que não queremos repetições na nossa lista e nossa lista será composta pelos estados do nosso banco de dados (dados$UF).

O código para criar os gráficos gerais, de média, desvio padrão e outros é semelhante, sendo apenas alterado qual é o valor de y.

Quadro01
-----------------------------------------------------------------------

### IQA
```{r}
renderPlotly({
  grafico = filter(dados, UF == input$estados) %>%
    ggplot(., aes(x=CODIGO_EST, y = NU1IQA))+geom_point()+labs(x = "Código Estação", y="IQA")+
    theme(axis.text.x = element_text(angle = 90, hjust = 1))
  ggplotly(grafico)})
```

QuadroAgrupado {.tabset}
-----------------------------------------------------------------------

### Média
```{r}
renderPlotly({
  grafico = filter(dados, UF == input$estados) %>%
    ggplot(., aes(x=CODIGO_EST, y = ME1IQA))+geom_point()+labs(x = "Código Estação", y="Média IQA")+theme(axis.text.x = element_text(angle = 90, hjust = 1))
  ggplotly(grafico)})
```

### Mínimo
```{r}
renderPlotly({
  grafico = filter(dados, UF == input$estados) %>%
    ggplot(., aes(x=CODIGO_EST, y = MI1IQA))+geom_point()+labs(x = "Código Estação", y="Mínimo IQA")+theme(axis.text.x = element_text(angle = 90, hjust = 1))
  ggplotly(grafico)})
```

### Máximo
```{r}
renderPlotly({
  grafico = filter(dados, UF == input$estados) %>%
    ggplot(., aes(x=CODIGO_EST, y = MA1IQA))+geom_point()+labs(x = "Código Estação", y="Máximo IQA")+theme(axis.text.x = element_text(angle = 90, hjust = 1))
  ggplotly(grafico)})
```

### Desvio Padrão
```{r}
renderPlotly({
  grafico = filter(dados, UF == input$estados) %>%
    ggplot(., aes(x=CODIGO_EST, y = SD1IQA))+geom_point()+labs(x = "Código Estação", y="Desvio Padrão IQA")+theme(axis.text.x = element_text(angle = 90, hjust = 1))
  ggplotly(grafico)})
```

Vamos explicar um pouco das funções utilizadas.

  • renderPlotly(): Essa função é usada para carregar nosso gráfico interativo, note que o gráfico gerado terá seu código entre chaves;
  • filter(): Função para filtrar nossos dados conforme o dado de entrada (input$estados);
  • ggplot(): Função para criar nosso gráfico, onde o ponto (.) faz referência ao que foi filtrado na linha anterior e aes() são os dados do gráfico;
  • geom_point(): Função para criar os pontos;
  • labs(): Função para criar os rótulos do gráfico;
  • theme(): Função para modificar o tema do gráfico (sendo que neste caso, alteramos o rótulo no eixo x para ele ficar na vertical);
  • ggplotly(): Criar o nosso gráfico.

Leia também: Como criar múltiplos gráficos com loops utilizando R e ggplot2?

Agora que terminamos nossa primeira página, vamos passar para a nossa segunda página. Ela será composta por uma barra lateral e dois gráficos em duas colunas.

Boxplots
===

Comandos2 {.sidebar}
---
```{r}

```

Boxplot01
-------------------------------------

### Rio X
```{r}

```

Boxplot02
-------------------------------------
### Rio Y
```{r}

```

Com os nosso quadros alinhados, vamos inserir o código dos nossos gráficos e menu de entrada.

Boxplots
===

Comandos2 {.sidebar}
---
```{r}
selectInput("rioX", label = "Rio X: ", choices = unique(dados$CORPO_DAGU))
selectInput("rioY", label = "Rio Y: ", choices = unique(dados$CORPO_DAGU))
```

Boxplot01
-------------------------------------

### Rio X
```{r}
renderPlotly({
  grafico = filter(dados, CORPO_DAGU == input$rioX) %>%
    ggplot(., aes(x=CORPO_DAGU, y = NU1IQA))+geom_boxplot()+labs(x=NULL,y=NULL)
  ggplotly(grafico)})
```

Boxplot02
-------------------------------------
### Rio Y
```{r}
renderPlotly({
  grafico = filter(dados, CORPO_DAGU == input$rioY) %>%
    ggplot(., aes(x=CORPO_DAGU, y = NU1IQA))+geom_boxplot()+labs(x=NULL,y=NULL)
  ggplotly(grafico)})
```

O código na segunda página é bastante semelhante ao da primeira, sendo que neste momento, selecionamos os corpos d’água (CORPO_DAGU) da nossa planilha de dados e não indicamos qual dado deverá começar sendo selecionado.

Outra diferença é a troca da função geom_point() pela função geom_boxplot() para criarmos nossos boxplots.

O resultado é apresentado na figura abaixo.

Boxplots criados dentro do dashboard no R.
Boxplots criados dentro do dashboard no R.

Após finalizar todo o seu código, clique em “Run Document” e o RStudio começará a montar o seu dashboard e você terá uma nova janela contendo o seu dashboard.

Agora que você já sabe criar um dashboard no R.

Imagine você ter que apresentar seus dados de monitoramento ambiental para o seu cliente, há uma diferença bem grande entre mostrar um gráfico estático e um cheio de interatividade como estes (além de possibilitar explorar os dados no momento da discussão de forma mais rápida).

Outra possibilidade, no caso de dados históricos, é o acompanhamento da evolução do parâmetro, como exemplo, evolução da qualidade química do solo (fertilidade) de uma área recuperada da mineração de carvão.

Quer ver como ficou o dashboard que montamos funcionando? Clique aqui e confira nosso vídeo.

Leia também: Como automatizar a geração de relatórios usando R Markdown?

Ficou com alguma dúvida relacionado aos códigos ou variáveis usadas, fique a vontade e use os comentários. Comente também outras possibilidades de uso do dashboard.

Referencias consultadas

EstaTiDados.  Flexdashboard - Aprenda a fazer dashboards em R - Caio Moreira. Disponível em <https://www.youtube.com/watch?v=mdsx8WNEOgc>. Acesso em 10 jan. 2020.

flexdashboard for R. Using shiny with flexdashboad. Disponível em <https://rmarkdown.rstudio.com/flexdashboard/shiny.html>. Acesso em 10 jan. 2020.

flexdashboard for R. Using flexdashboard. Disponível em <https://rmarkdown.rstudio.com/flexdashboard/using.html>. Acesso em 10 jan. 2020.


Clique na figura abaixo e assine nossa lista de emails para receber nosso ebook "Como criar mapas de localização com ArcGIS 10.x".

Apostila Mapa de Localização Banner

Author: Fernando BS

Engenheiro Ambiental e de Segurança do Trabalho. Atua nas áreas de geoprocessamento, mineração e hidrologia. Busca soluções utilizando softwares como QGIS, R e Python.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *