library (tidyverse)
library (gt)8 Visualização de Dados com GGPLOT2
8.1 Introdução
A seguir temos vários exemplos de visualização de dados utilizando o pacote GGPLOT2 do R. Este é um pacote muito flexível para gerar diversos tipos de gráficos.
Nota
Apesar de visualização de dados não ser especificamente parte das etapas de transformação e manipulação de dados, acreditamos ser importante um conhecimento básico sobre o tema, pois muitas vezes, para explicarmos aquilo que estamos transformando ou manipulando, o fazemos de forma gráfica para melhor compreensão.
O objetivo não é explicar a aplicabilidade e/ou o a função de cada gráfico, mas sim, como ele pode ser construído.
Para saber mais sobre este pacote, acesse:
https://cran.r-project.org/package=ggplot2.
Aviso
Para melhor utilizar este material, é importante que você tenha uma introdução à linguagem R e saiba carregar pacotes (packages) no R. Para mais informações acesse:
Para os exemplos, iremos carregar os seguintes pacotes:
tidyverse
gt
8.1.1 Exemplos da Folha de Referência
A maioria dos exemplos, visam ajudar na interpretação dos exemplos e funções encontradas na Folha de Referência do stringr disponível no site do RStudio.
8.1.1.1 Variáveis Discretas e Contínuas no GGPLOT
O ggplot2, em geral irá associar as variáveis caractere (char) e fatores (factors) em escalas discretas de forma automática. Já as variáveis numéricas, o ggplot irá associar automaticamente com escalas contínuas.
Você verá nas seções seguintes este tipo de segregação, ou seja, um gráfico para variáveis discretas, contínuas ou um mix de ambas e assim por diante.
Importante
Quando tivermos variáveis que não seguem este padrão, devemos “transformá-las, usando funções como as_factor(), as.integer(), as.double, etc.
Por exemplo, para representar uma variável que é do tipo inteiro, porém é discreta, deveremos antes alterá-la para um fator antes de submeter ao ggplot preferencialmente.
8.2 Gramática dos Gráficos
O pacote ggplot2 é uma implementação do livro “Grammar of Graphics”, que apresenta um conceito de quais seriam os elementos de um gráfico e suas interconexões. O modelo teórico proposto no livro é que através de camadas definidas qualquer gráfico pode ser construído. Abaixo o modelo, que deve ser interpretado de baixo para cima.
De uma forma bem resumida, a idéia é que você possa construir minimamente qualquer gráfico com base nestes mesmos elementos: um conjunto de dados, um sistema de coordenadas e geometrias, que seriam marcas visuais que representas os pontos dos dados.
No caso do ggplot2, para mostrar valores no gráfico, as varíaveis do conjunto de dados podem ser mapeadas em propriedadas visuais da geometria (geom).
Este mapeamento de estética (aesthetic) é feito através da função aes() e podemos fazer mapeamentos estéticos como cor, tamanho, forma, etc.
8.3 Modelo para Construção de um Gráfico
No caso do ggplot2, podemos definir uma espécie de modelo (template) para a sintaxe de construção de gráficos:
Vejamos a seguir uma introdução ao uso do modelo visto acima:
8.3.0.1 ggplot
A função ggplot() inicia um gráfico que será completado com as camadas adicionadas na sequência, como uma geometria, um sistema de coordenada ou até um tema.
Usando o modelo acima, vamos gerar nosso primeiro gráfico.
Como base de dados usaremos a tabela mtcars. Para maiores informação sobre as variáveis (colunas) e observações (linhas) do mtcars, digite ?mtcars.
mtcarsggplot(data = mtcars) +
geom_point (mapping = aes(x = hp, y = mpg ))
Nota
Observe que mesmo sem definirmos escalas, temas, transformações estatísticas ou outras camadas, o gráfico ainda assim foi gerado.
Isto acontece porque o ggplot tem valores padrões dinâmicos que tentam prover o melhor resultado possível com o mínimo de esforço.
Dica
A definição da estética com seu mapeamento, feito neste exemplo na função de geometria (geom_point) poderá ser feito também na função ggplot().
Apesar do gráfico final ser similar, a estética mapeamento poderá ser utilizada pelas funções geom_*() nas camadas seguintes, sem a necessidade de repetí-la, caso contrário, ela será restrito apenas àquela geom() na qual foi declarada. Veja:
ggplot(data = mtcars, mapping = aes(x = hp, y = mpg))+
geom_point()
Por ser comum o uso do argumento data = e mapping =, podemos excluídas do código, deixando-o mais enxuto, porém mais difícil para quem não tem tanta familiaridade, veja:
ggplot(mtcars,aes(x = hp, y = mpg)) +
geom_point()
8.3.0.2 last_plot
Use para retornar o último gráfico gerado.
last_plot()
8.3.0.3 ggsave
Use para salvar o gráfico em uma imagem. O tipo de imagem é selecionado pela extensão do arquivo de saída.
Por exemplo, para salvar o diretório atual um arquivo com o gráfico chamado “plot-01.png” com o formato de imagem “.PNG” de tamanho 5x5 centímetros, fazemos:
ggsave("plot-01.png", width = 5, height = 5, units = "cm")8.4 Camadas
8.4.1 Introdução
A seguir iremos apresentar as principais camadas do ggplot e suas principais funções.
Nota
Para a camada de dados, o ggplot aceitará qualquer conjunto de dados (data frame). Para facilitar a criação do gráfico recomenda-se que os dados já estejam organizados (tidy) com observações em linhas e variáveis em colunas.
Estéticas
Geometrias
Estatísticas
Escalas
Coordenadas
Facetas
Tema
8.4.2 Estéticas
Podemos mapear a estética de uma camada à variáveis presentes em nossa camada de dados até definí-las manualmente. Se não especificarmos de forma explícita, o ggplot tentará assumir valores padrões que serão usados por determinada função outras camadas, como a de geometria ou de estatística.
Existem estéticas que são comuns a quase todas as camadas, como cor, forma, tamanho, etc.
A estética é vinculada à uma variável através da função aes(). É comum, apesar de não ser mandatório para todas as estéticas, que determinemos os valores para x e y.
A seguir veremos algumas delas:
8.4.2.1 color e fill
Use para definir a cor (color) ou preenchimento (fill) para a estética.
ggplot(mtcars)+
geom_point(aes(x = hp, y = mpg, color = "red"))
No exemplo acima, definimos que a estética “x”, assumirá valores provenientes da variável que existe em nossos dados chamada “hp”. Já a estética “y”, assumirá valores provenientes da variável “mpg”.
Já a estética “color” assumirá o valor constante “red”. Na string de color =, podemos usar valores de cores em inglês, como “red” ou “blue”, ou também códigos RGB, como ““#00ABFF” ou “FF00AA”.
Importante
Observe que o valor definido da cor, foi dentro dos parênteses da função aes(), ou seja, ela está fazendo o mapeamento da estética cor (color) com os dados. Se utilizarmos o argumento color = da função geom_point(),estaremos definindo um valor fora do mapeamento.
ggplot(mtcars)+
geom_point(aes(x = hp, y = mpg) , color = "red")
Apesar do resultado ser similar, observe que no exemplo anterior tivemos color como um mapeamento da estética, como definimos o valor fixo com a cor “red”, seria como tivessemos em nossos dados uma coluna onde todas as linhas tivessem o valor “red”. Já no exemplo acima, estamos simplemente dizendo à função da geometria que queremos a cor vermelha para ela.
Vejamos um outro exemplo para que fique claro este ponto.
Vamos gerar o mesmo gráfico onde colocamos “red” como parte da estética, porém agora, iremos mapeá-la com a coluna “qsec” de nossos dados mtcars:
ggplot(mtcars)+
geom_point(aes(x = hp, y = mpg, color = qsec))
Observe que neste caso a estética de cor foi mapeada com a variável qsec. Por se tratar de uma variável contínua, o ggplot escolheu autometicamente uma sequência de cores, neste caso do azul claro para o azul escuro, para representar este tipo de variável. Veremos mais adiante como customizar esta e outras escolhar automáticas feitas nas escalas.
8.4.2.2 linetype
Use para definir a linha utilizada no gráfico. Podemos utilizar um número de 0 a 6 ou um nome:
(0 = “blank”, 1 = “solid”, 2 = “dashed”, 3 = “dotted”, 4 = “dotdash”, 5 = “longdash”,6 = “twodash”)
Por exemplo, ao invés de utilizarmos a geometria de pontos (geom_point), vamos utilzar a geometria de linha (geom_line):
ggplot(mtcars)+
geom_line(aes(x = hp, y = mpg) , linetype = "dotted")
8.4.2.3 size
Use para definir o tamanho, no caso de uma linha em “mm”.
Como dito anteriormente, estes valores são comuns para vários geometrias. Por exemplo, podemos utilizar o argumento size também na geometria de pontos (geom_point):
ggplot(mtcars)+
geom_line(aes(x = hp, y = mpg), size = 5)
ggplot(mtcars)+
geom_point(aes(x = hp, y = mpg), size = 5)
8.4.2.4 lineend
Use para definir o terminador da linha. Os valores podem ser: round, butt e square.
ggplot(mtcars)+
geom_line(aes(x = hp, y = mpg), lineend = "square", size = 4)
ggplot(mtcars)+
geom_line(aes(x = hp, y = mpg), lineend = "butt", size = 4)
ggplot(mtcars)+
geom_line(aes(x = hp, y = mpg), lineend = "round", size = 4)
8.4.2.5 linejoin
Use para definir a junção da linha. Os valores podem ser: round, mitre e bevel.
ggplot(mtcars)+
geom_line(aes(x = hp, y = mpg), linejoin = "round", size = 4)
ggplot(mtcars)+
geom_line(aes(x = hp, y = mpg), linejoin = "mitre", size = 4)
ggplot(mtcars)+
geom_line(aes(x = hp, y = mpg), linejoin = "bevel", size = 4)
8.4.2.6 shape
Use para definir a forma. Podemos passar um número ou um nome em inglês da forma conforme abaixo:
ggplot(mtcars)+
geom_point(aes(x = hp, y = mpg), shape = "square cross", size = 3)
ggplot(mtcars)+
geom_point(aes(x = hp, y = mpg), shape = 5, size = 3)
8.4.3 Geometrias
O ggplot nos permite selecionar para o mesmo gráfico uma ou mais formas geométrias. Por exemplo, eu posso ter o mesmo gráfico final, mas ao invés de ter pontos representando os dados, podemos ter barras e assim por diante.
Aviso
Lembre-se que cada função retornará uma camada, portanto, a ordem de criação das camadas afeta o resultado do gráfico, pois uma será criada sobre a anterior.
8.4.3.1 Gráficos Primitivos
Para os exemplos a seguir, utilizaremos duas bases de dados, uma chamada economics e outra chamada seals.
economicssealsPara simplificar o código dos próximos exemplos, iremos criar dois objetos gráfico do ggplot:
O primeiro chamado “a”, irá conter um objeto ggplot com os dados de economics, mapeando a estética de x para a variável “date” e y para a variável “unemployed”.
O segundo chamado “b”, irá conter um objeto ggplot com os dados de seals, mapeando a estética de x para a variável “long” e y para a variável “lat”.
Desta forma trabalharemos com os mesmos objetos base e adicionaremos apenas novas camadas utilizando o operador “+” a fim de identificar os detalhes das diversas funções de geometria e não precisarmos repetir o código das camadas iniciais do gráfico.
a <- ggplot(economics, aes(date, unemploy))
b <- ggplot(seals, aes(x = long, y = lat))
Nota
Para simplificar o código, em algum momentos podemos omitir o argumento, como data=, mapping = , x = , y = . Isto porque já estamos os valores na ordem que a função nos pede.
Agora com os objetos inicialmente criados, iremos adicionar novas camadas afim de obtermos os gráficos e entendermos algumas das funções de geometria para gráficos primitivos.
8.4.3.2 geom_blank
Use para garantir limites para todos os gráficos de acordo com os dados.
a + geom_blank()
Dica
Use a função expand_limits() para expandir os limites do gráfico usando dados. Ver ?expand_limits para mais detalhes.
8.4.3.3 geom_curve
Use para criar curvas.
b + geom_curve(aes(yend = lat + 1, xend = long + 1), curvature = 1)
8.4.3.4 geom_path
Use para conectar observações.
a + geom_path(lineend = "butt", linejoin = "round", linemitre = 1)
8.4.3.5 geom_polygon
Use para criar poligonos. É similar a geom_path(), porém a parte interna é preenchida com argumento fill =.
a + geom_polygon(aes(alpha = 50))
Nota
O argumento alpha = , é muito comum na definição de cores. De maneira simplificada, ele indica o nível de transparência de uma cor, sendo 0, nenhuma transparência e 1 transparência total.
8.4.3.6 geom_rect
Use para criar retângulos.
b + geom_rect(aes(xmin = long, ymin = lat,
xmax = long + 1, ymax = lat + 1))
Nota
A função geom_title() fazem a mesma coisa, porém são parametrizadas de forma diferente. A geom_rect usa a localização dos 4 cantos do quadrado, enquanto a geom_tile usa o centro e seu tamanho (largura e altura) para dimensionar.
8.4.3.7 geom_ribbon
Use para criar uma “fita”. Para cada valor de x, ela mostra um intervalo y, definido por ymin e ymax. Veja que geom_area() é um caso especial do geom_ribbon(), onde o ymin é fixo em 0 e y é usado no lugar de ymax.
a + geom_ribbon (aes(ymin = unemploy - 900,
ymax = unemploy + 900))
8.4.3.8 Segmentos de Linhas
Estas funções de geometrias, permitem criar diversos tipo de segmentos de linha e são úteis quando precisamos “marcar” ou definir algo no gráfico, com linhas verticais ou horizontais por exemplo.
8.4.3.9 geom_abline
Use para criar uma linha de um ponto “a” até um ponto “b”, passando o intercepto e a inclinação da reta.
b + geom_abline(aes(intercept = 0, slope = 1))
8.4.3.10 geom_hline
Use para criar uma ou mais linhas horizontais.
b + geom_hline(aes(yintercept = lat))
Veja que no exemplo anterior, fizemos o mapeamento do argumento yintercept como parte da estética (aes), mapeando este argumento com a variável “lat” de nossos dados.
Se quisermos simplesmente traçar uma linha com o intercepto do eixo y, correspondendo ao valor 40 (por exemplo, se fosse um tipo de meta), podemos definir este valor fora do mapeamento:
b + geom_hline(yintercept = 40)
8.4.3.11 geom_vline
Use para criar uma ou mais linhas horizontais.
b + geom_vline(aes(xintercept = long))
8.4.3.12 geom_segment
É similar ao geom_curve, porém ao invés de criar uma curva, criar um segmento de reta.
b + geom_segment(aes(yend = lat + 1, xend = long + 1))
8.4.3.13 geom_spoke
Use para criar um segmento, parametrizado pela localização, direção e distância.
b + geom_spoke(aes(angle = 1:1155, radius = 1))
8.4.3.14 Uma Variável Contínua
Quando precisamos analisar um varíavel contínua, as geometrias a seguir ajudam a fornecer um gráfico apropriado.
Novamente, iremos preparar nossos objetos básicos para evitar repetição de código. Agora teremos um objeto “c” e outro “c2”, aos quais iremos adicionar novas camadas. Similar ao que fizemos anteriormente, porém agora utilizaremos a base de dados “mpg”.
mpgCriando os objetos ggplot:
c <- ggplot(mpg, aes(hwy))
c2 <- ggplot(mpg)
Importante
Observe que o objeto “c”, usa a base “mpg” já atribuindo a variável “hwy” para x= da estética. Esta configuração será aplicada para qualquer funções geom_*() a não ser que explicitamente tenhamos uma estética redefinindo isso dentro de outra camanda de geometria.
Já para o objeto “c2”, não temos a estética de x definida, portanto, teremos que definí-la em nas próximas camadas com a funções de geometria (geom_*()).
8.4.3.15 geom_histogram
Use para criar histogramas, ou seja, uma forma de visualizar uma variável contínua dividindo no eixo x em classes e contando o número de observações de cada classe no eixo y.
O argumento binwidth = define o tamanho das classes.
No exemplo a seguir, dividimos a variável contínua de consumo por rodagem (hwy) em classes com 2 observações cada.
c + geom_histogram(binwidth = 2) 
Se desejar definir o número de classes ao invés de quantas observações terão cada classe, utilize o argumento bins =.
c + geom_histogram(bins = 16) 
8.4.3.16 geom_freqpoly
Use para gerar um gráfico de polígonos de frequência. Enquanto o histograma gera um gráfico de barras, esta geometria gera uma linha.
c + geom_freqpoly(bins = 30)
8.4.3.17 geom_area
Use para criar um gráfico de área, onde para cada valor no eixo x, há um valor y máximo e o valor de y mínimo é sempre zero.
Nota
Você verá um argument (stat = “bin”) abaixo. Veremos as estatísticas na seção ESTATÍSTICAS (STATS). Por hora, pense apenas que é uma forma de definirmos os valores que iremos mostrar para o eixo y. Por padrão o número de agrupamento (bin) é 30.
c + geom_area(stat = "bin", bins = 32)
8.4.3.18 geom_density
Use para fazer um gráfico de densidade. Usando funções de estimativa de densidade de kernel, seria uma versão mais “arredondada” do histogram, mostrando a função densidade de probabilidade da variável.
Há a possibilidade de configurar vários kernels das funções de densidade, como “gaussian”, “rectangular”, “triangular”, “epanechnikov”, “biweight”, “cosine” ou “optcosine”.
c + geom_density(kernel = "gaussian")
Dica
Veja que podemos criar duas geometrias, uma com o histograma e outra de densidade sobrepostas. Para isto temos que sobreescrever a estética definida previamente para o eixo y (antes era count) usando ..density..
c + geom_histogram(aes(y = ..density..)) +
geom_density()
8.4.3.19 geom_dotplot
Use para criar um gráfico de pontos, com a largura dos pontos correspondem à largura do agrupamento e os pontos são empilhados. Cada ponto corresponde à uma observação dos dados, portanto em geral é utilizado quando temos poucas observações.
c + geom_dotplot() 
8.4.3.20 geom_qq
Use para criar um gráfico de quantil-quantil. Em geral utilizado para confirmar se uma variável tem uma distribuição gaussiana.
c2 + geom_qq(aes(sample = hwy))
8.4.3.21 Uma Variável Discreta
Quando precisamos analisar um varíavel discreta, as geometrias a seguir ajudam a fornecer um gráfico apropriado.
Novamente, iremos preparar nosso objeto básico para evitar repetição de código. Agora teremos um objeto “d” ao qual iremos adicionar novas camadas. Similar ao que fizemos anteriormente usando a base de dados mpg. Utilizaremos a variável combustível (fl).
d <- ggplot(mpg, aes(fl))8.4.3.22 geom_bar
Use para criar um gráfico de barras.
d + geom_bar()
Veja outro exemplo: Como aconteceu com o combustível (fl), podemos pegar a variável tipo da classe do veículo (class) e gerar um gráfico de barras também.
d + geom_bar(aes(x = class))
Usando o argumento da estética para cor do preenchimento (fill), podemos mapear uma variável igual ou diferente. Com isto, o ggplot automaticamente criará uma legenda para os diferentes valores da varíavel. Veja o que acontece quando temos x=fl e fill = class:
d + geom_bar(aes(fill =class))
Note que como a estética herdada do objeto ggplot base (d) tinha o mapeamento de x para a variável combustível (fl), ela ainda permanece no eixo x.
Se sobrescrevermos este mapeamento para a estética do geom_bar com a mesma variável para x e fill, teremos:
d + geom_bar (aes(x = class, fill = class)) 
Note que o resultado automático do gráfico foi um pouco diferente. Quando tivemos x = fl e fill = class as barras foram empilhadas (stack) e quando tivemos x = class e fill = class, as barras foram lado colocadas lado a lado (dogde).
Por padrão, o ggplot, quando múltiplas barras ocupam o mesmo ponto, elas são empilhadas. Este comportamento pode ser definido através do argumento position = .
Veja as diferentes opções:
d + geom_bar(aes(fill =class), position = "dodge")
d + geom_bar(aes(fill =class), position = "dodge2")
d + geom_bar(aes(fill = class) , position = "stack")
d + geom_bar(aes(fill =class), position = "fill")
Dica
As geometrias podem ter valores calculados autometicamente “computed variables”. Isto é para faciliar a geração dos gráficos com valores padrões. No caso da geom_bar, não precisamos passar que no eixo y gostaríamos de ter a contagem da variável que está no eixo x. Veja que então, a variável y não ficou sem um valor, ele apenas foi substituído pela contagem (count) automaticamente. A geom_bar tem “count” e “prop” como varíveis computadas.
Para saber quais varíaveis são computadas automaticamente para cada geometria, veja a ajuda com ?geom_bar.
8.4.3.23 Duas Variáveis Discretas
Quando precisamos analisar um duas varáveis discretas, as geometrias a seguir ajudam a fornecer um gráfico apropriado.
Novamente, iremos preparar nosso objeto básico para evitar repetição de código. Agora teremos um objeto “g” ao qual iremos adicionar novas camadas. Similar ao que fizemos anteriormente, só que agora usando a base de dados diamonds. Utilizaremos as variáveis corte (cut) e cor (color).
g <- ggplot(diamonds, aes(cut, color))8.4.3.24 geom_count
Esta é uma variante do geom_point() que conta o número de observação em cada localização e então mapeia a contagem na área do ponto.
g + geom_count()
8.4.3.25 geom_jitter
É similar ao geom_point, porém adiciona uma variação aleatória em cada ponto.
g + geom_jitter(height = 2, width = 2)
Como várias outras geometrias, podemos adicionar uma cor na estética do geom_jitter, mapeando outra váriável, como por exemplo o corte (cut) para facilitar a visualização:
g + geom_jitter(aes(color = cut), height = 2, width = 2)
8.4.3.26 Uma Variável Contínua e Outra Discreta
Quando precisamos analisar uma varável contínua e outra discreta, as geometrias a seguir ajudam a fornecer um gráfico apropriado.
Novamente, iremos preparar nosso objeto básico para evitar repetição de código. Agora teremos um objeto “f” ao qual iremos adicionar novas camadas. Similar ao que fizemos anteriormente, só que agora usando a base de dados mpg. Utilizaremos as variáveis classe (class) e consumo na estrada (hwy).
f <- ggplot(mpg, aes(class, hwy))8.4.3.27 geom_col
Use para criar um gráfico de colunas. Ele é similar ao gráfico de barras, porém agora, no eixo y, teremos uma variável contínua. Observe que enquanto no geom_bar, o eixo y é calculado automaticamente, aqui na geom_col, você precisa ter a variável já nos seus dados.
f + geom_col()
Assim, como no geom_bar, podemos definir a cor de preenchimento da estética para geom_col, usando fill =.
Vamos usar a variável de número de cilindros (cyl) como exemplo.
f + geom_col(aes(fill = cyl))
Aviso
Veja que no caso acima, o ggplot tentou automaticamente ajustar a escala de cores para uma escala contínua. Dá a impressão que temos veículos com 7 cilindros inclusive.
Isto é porque em nossos dados, a variável “cyl” é do tipo inteiro (integer) e com isto, o ggplot2 entende como um variável contínua.
Para obter o efeito pretendido, temos algumas opções. Uma seria mudar a variável cyl para o tipo fator (factor) usando a função as_factor(). Veja:
f + geom_col(aes(fill = as_factor(cyl)))
Por padrão, as classes são colocadas de forma empilhada, similar ao que vimos na geom_bar. Se quisermos colocadas lado a lado, devemos fazer:
f + geom_col(aes(y= hwy, x=class, fill = factor(cyl)), position = "dodge")
Dica
A largura das colunas é expandida automaticamente, pois não temos valores para todas as combinações. Por exemplo, não temos 8 cilindros em carros compatos. Há formas difrentes de ajutar isso, uma delas é ajustar a base de dados, criando as combinações possíveis utilização a função tidyr::complete()
complete(mpg, class, cyl) |> ggplot () +
geom_col(aes(y= hwy, x=class, fill = factor(cyl)), position = "dodge")
8.4.3.28 geom_boxplot
Use para criar um gráfico boxplot (box e whiskers). Este gráfico é bastante interessante, pois mostra cinco estatísticas automaticamente (a mediana, primeiro e terceiro quartis e os limites max e min) e os pontos fora da curva individualmente (outlyers).
Para este exemplo, iremos além de definir uma cor de preenchimento através do argumento fill = , iremos remover a legenda desta camada usando show.legend = FALSE.
f + geom_boxplot(aes(fill = factor(class)), show.legend = FALSE)
Para mostrar a média ao invés da media, podemos fazer:
f + geom_boxplot(aes(middle = mean(hwy)))8.4.3.29 geom_dotplot
Use para criar um gráfico de pontos, com a largura dos pontos correspondem à largura do agrupamento e os pontos são empilhados. Cada ponto corresponde à uma observação dos dados, portanto em geral é utilizado quando temos poucas observações.
f + geom_dotplot(aes(color = class),binaxis = "y", stackdir = "center")
8.4.3.30 geom_violin
Use para criar um gráfico de violino. Ele mostra de forma compacta a distribuição de uma variável contínua.
f + geom_violin(aes(fill = class), scale = "area")
8.4.3.31 Duas Variáveis Contínuas
Quando precisamos analisar duas variáveis contínuas, as geometrias a seguir ajudam a fornecer um gráfico apropriado.
Novamente, iremos preparar nosso objeto básico para evitar repetição de código. Agora teremos um objeto “e” ao qual iremos adicionar novas camadas. Similar ao que fizemos anteriormente, só que agora usando a base de dados mpg. Utilizaremos as variáveis consumo na cidade (cty) e consumo na estrada (hwy).
e <- ggplot(mpg, aes(cty, hwy))8.4.3.32 geom_label
Use para adicionar uma camada de texto (labels) no gráfico. Ela pode ser utilizada sozinha como em gráficos de dispersão, mas é mais comum, usá-la em conjunto com outras geometrias. Por exemplo, colocar os valores acima de cada barra em um geom_bar(). Por padrão, o texto a ser adicionado, tem um retângulo atrás para facilitar a leitura.
O argumento nudge_* =, ajusta a posição casos textos estejam no mesmo ponto
e + geom_label(aes(label = cty), nudge_x = 1, nudge_y = 1)
No exemplo acima, temos um gráfico com um texto em cada ponto de cruzamento entre a variável no eixo x e a correspondente no eixo y.
Veja um uso do geom_label em conjunto com outra geom.
Exemplo 1:
Neste caso, iremos sumarizar os dados e obtermos um tabela contendo cada classe e a soma do consumo na estrada (hwy). Depois criaremos uma geometria de colunas e adicionaremos uma camada com o texto.
dados <- mpg |> group_by(class) |> summarise(hwy = sum(hwy))
dados |> ggplot(aes(class, hwy, fill = class)) +
geom_col() +
geom_label(aes(label = hwy))
dados
Dica
Podemos utilizar o argumento position = e através da função position_stacked centralizar o ajuste vertical (vjust) para colocar o texto no centro da coluna e remover a camada da legenda:
dados |>
ggplot(aes(class, hwy, fill = class)) +
geom_col() +
geom_label(aes(label = hwy),
position = position_stack(vjust = 0.5),
show.legend = FALSE)
Exemplo 3:
Neste exemplo, seguiremos uma outra abordagem. Vimos na seção da geom_bar que ela calcula automaticamente a contagem dos valores para o eixo y, ou seja, nós não tinhamos esta contagem em nossos dados e não queremos preparar um tabela resumida com fizemos no exemplo anterior. Neste caso, podemos utilzar esta estatística calculada usando o parametro stat.
Veremos mais detalhes sobre as estatisticas na seção Estatísticas (stats)
ggplot(mpg, aes(x = fl, fill = fl))+
geom_bar() +
geom_label(stat = "count",
aes(label = paste0("Total = ", after_stat(count))),
size = 2,
show.legend = FALSE)
Nota
Veja acima que podemos controlar o tamanho (size) e definirmos um string junto com a variável que colocamos no texto utilziando a função paste0().
8.4.3.33 geom_point
Use para gerar um gráfico de pontos ou dispersão. Este tipo de gráfico é muito úteil quando queremos mostrar relações entre as duas variáveis contínuas. Apesar dele também poder ser usado para comparar uma contínua com uma discreta, as opções de geometria como geom_jitter ou geom_count são mais apropriadas.
e + geom_point()
Dica
Um gráfico de bolhas (bubblechart) é um gráfico de pontos com uma terceira variável associada ao tamanho dos pontos.
e + geom_point(aes(size = displ), alpha = 0.3)
8.4.3.34 geom_quantile
Use para criar um gráfico de quantis. Seria o equivalente contínuo do boxplot.
e + geom_quantile()
Podemos definir quantis quantis queremos obter, por exemplo, se quisermos obter uma quebra de 5% , 50% e 95% podemos fazer:
e + geom_quantile(quantiles = c(0.05, .5, 0.95))
8.4.3.35 geom_rug
Use para criar um gráfico de tapete (rug chart) com pequenas linhas para complementar uma visão 2Ds com duas visões de uma dimensão.
O argumento sides é uma string que controla onde os tapetes irão aparecer no gráfico: “trbl” = top, right, bottom e left.
e + geom_rug(sides = "bl")
Fica interessante colocar uma camada adicional com geom_point para entender melhor o que acontece neste tipo de gráfico. Veja que as linhas do tapete ficam mais próximas quando temos mais concentração de pontos. Como este gráfico mostra todos os pontos, ele faz mais sentido com pequenos conjuntos de dados.
e + geom_rug(sides = "bl") +
geom_point()
8.4.3.36 geom_smooth
Use para ajudar a encontrar padrões na visualização quando há muitos dados sobrepostos.
e + geom_smooth(method = "lm")
Você pode usá-lo para traçar linhas de tendência também.
e + geom_point() +
geom_smooth(method = "lm", se= FALSE)
8.4.3.37 geom_text
Use para criar uma geometria com textos. É similar ao geom_label, porém não tem um quadrado envolta do texto por padrão:
e + geom_text(aes(label = cty), nudge_x = 1, nudge_y = 1)
Assim como aocntece no geom_label, podemos utilizar como camada adicional à outras geometrias. Veja:
dados |>
ggplot(aes(class, hwy, fill = class)) +
geom_col() +
geom_text(aes(label = hwy),
position = position_stack(vjust = 0.5),
show.legend = FALSE)
8.4.3.38 Mapas de Calor e Densidade
En alguns casos, precisamos mostrar como as duas variáveis contínuas se relacionam, dividindo o plano em retângulos e plotando os número de casos em cada retãngulo e preenchendo a cor de acordo com o número de casos. Para os exemplos a seguir, usaremos novamente a base “diamonds” em um objeto “h” .
h <- ggplot(diamonds, aes(carat, price))8.4.3.39 geom_bind2d
Use para gerar um mapa de calor com classe de contagem 2d. O gráfico é formado dividindo o plano em retângulos e plotando os número de casos em cada retangulo e preenchendo a cor de acordo com o número de casos.
h + geom_bin2d(binwidth = c(0.25, 500))
8.4.3.40 geom_density_2d
Use para gerar um gráfico de contorno. É um gráfico de densidade (ver geom_density) só que para duas variáveis.
h + geom_density_2d()
8.4.3.41 geom_hex
Use para gerar um mapa de calor hexagonal. O gráfico é formado dividindo o plano em hexagonos e plotando os número de casos em cada retangulo e preenchendo a cor de acordo com o número de casos.
h + geom_hex(bins = 40)
8.4.3.42 Duas Variáveis Discretas
Quando precisamos analisar duas variáveis contínuas, as geometrias a seguir ajudam a fornecer um gráfico apropriado.
Novamente, iremos preparar nosso objeto básico para evitar repetição de código. Agora teremos um objeto “g” e “e” ao qual iremos adicionar novas camadas. Similar ao que fizemos anteriormente, só que agora usando a base de dados mpg e diamonds. Utilizaremos as variáveis de mpg consumo na cidade (cty) e consumo na estrada (hwy) e de diamonds (cut e color).
g <- ggplot(diamonds, aes(cut, color))
e <- ggplot(mpg, aes(cty, hwy))8.4.3.43 geom_count
Esta geometria é uma variante da geom_point que conta o número de observações para cada localização do gráfico e então mapeia o número da contagem com cada ponto.
g + geom_count()
8.4.3.44 geom_jitter
Use para criar um gráfico de pontos com o uma dispersão aleatória em cada ponto sobreescrito. É similar a escrever geom_point(position = “jitter”).
e + geom_jitter(height = 1, width = 1)
Para entender como esta dispersão aleatória funciona, compare uma geometria de pontos onde temos vaŕios pontos no mesmo local (sem a dispersão em vermelho) e com a dispersão (jitter).
e +
geom_jitter(alpha = 0.4, height = 1, width = 1) +
geom_point(color = "red")
8.4.3.45 Mapas
O ggplot2 também pode gerar gráficos de mapas.
Para isso iremos criar um conjunto de dados à partir da base “USArrests”, contendo onúmero de assassinatos por estado americano. Depois iremos usar usar a função map_data() para criar um data frame com as iformações para o mapa (latitude e longitude). Depois usaremos este data frame para a geometria de mapas (geom_map).
data <- data.frame(murder = USArrests$Murder,
state = tolower(rownames(USArrests)))
map <- map_data("state")
k <- ggplot(data, aes(fill = murder))
k + geom_map(aes(map_id = state), map = map) +
expand_limits(x = map$long, y = map$lat)
datamapPara uma utilização mais moderna e e precisa de gráficos geográficos/mapas, recomenda-se o uso de uma geometria chamada geom_sf. Ela é capaz de mapear objetos do tipo “Simple Feature” do pacote”sf” diretamento no ggplot2. Este é um assunto bastante complexo, mas apenas como carater ilustrativo, veja como seria o plot do estado de São Paulo.
library (sf)
sp <- st_read(dsn = "shapefile_sp/estado_sp.shp")Reading layer `estado_sp' from data source
`/home/scopinho/github/Livro_Transform_Dados_R/Visualizacao/shapefile_sp/estado_sp.shp'
using driver `ESRI Shapefile'
Simple feature collection with 645 features and 2 fields
Geometry type: MULTIPOLYGON
Dimension: XY
Bounding box: xmin: -53.11011 ymin: -25.31232 xmax: -44.16137 ymax: -19.77966
Geodetic CRS: SIRGAS 2000ggplot (sp) +
geom_sf(color = "Blue")
8.4.3.46 Visualizando Erros
Quando precisamos analisar intervalos verticais, com linhas, barras e barras de erros, podemos usar as seguintes geometrias abaix. Porém, como nas demais seções, iremos preparar nosso objeto básico para evitar repetição de código.
Agora teremos um objeto “j” ao qual iremos adicionar novas camadas. Similar ao que fizemos anteriormente, só que agora usando a base “df” que criaremos a seguir.
df <- data.frame(grp = c("A", "B"), fit = 4:5, se = 1:2)
j <- ggplot(df, aes(grp, fit, ymin = fit - se, ymax = fit + se))Vamos entender como é a base de dados “df” criada.
df
Nota
A coluna “SE”, significa “standard error” ou erro padrão.
Já o objeto ggplot base que criamos tem a variável grp no eixo x, fit no eixo y. Também definimos o y-min como fit - se (erro padrão) e o ymax como fit + se.
j <- ggplot(df, aes(grp, fit, ymin = fit - se, ymax = fit + se))8.4.3.47 geom_crossbar
Use para criar uma barra no intervalo vertical. Esta função criará duas barras com um ponto central baseado em ymin, x e ymax. o argumento fatten = , é um fator multiplicador para o separador do meio.
j + geom_crossbar(fatten = 5)
Veja que a distância do ponto central de A até seu limite de baixo é definido por fit + se em nossa tabela de dados e nosso objeto “j”. O mesmo ocorre para o limite inferior.
8.4.3.48 geom_errorbar
Use para traçar barras de erro. Similar ao geom_crossbar, mas não mostra o ponto central ou as linhas laterais.
j + geom_errorbar()
8.4.3.49 geom_linerange
Similar a geom_errorbar, mas sem as linha superior ou inferior.
j + geom_linerange()
8.4.3.50 geom_pointrange
Similar à geom_linerange, porém monstrando o ponto central.
j + geom_pointrange()
8.4.3.51 Três Variáveis
O ggplot não consegue criar gráficos 3D verdadeiros, porém permite visualizar superfícies 3D em 2 duas dimensões. Quando precisamos criar tais gráficos, as geometrias a seguir ajudam a fornecer um gráfico apropriado.
Novamente, iremos preparar nossos objetos básicos para evitar repetição de código. Agora teremos um objeto “l” ao qual iremos adicionar novas camadas. Isto é similar ao que fizemos anteriormente, só que agora usando a base de dados seals. Faremos um ajuste, criando uma coluna “z”, que será a raiz quadrada das somas dos quadrados de delta_long e delta_lat. Mapearemos nosso objeto ggplot base com x = long e y = lat:
seals$z <- with(seals, sqrt(delta_long^2 + delta_lat^2))
l <- ggplot(seals, aes(long, lat))8.4.3.52 geom_contour
l + geom_contour(aes(z = z))
8.4.3.53 geom_contour_filled
l + geom_contour_filled(aes(z = z, color = z))
8.4.3.54 geom_raster
l + geom_raster(aes(fill = z), hjust = 0.5,
vjust = 0.5, interpolate = FALSE)
8.4.3.55 geom_tile
l + geom_tile(aes(fill = z))
8.4.4 Estatísticas
Podemos dizer que as estatísticas, ou mais precisamente, uma transformação estatística, é uma maneira diferente de construirmos uma camada.
Assim como cada camada de geometria possui uma transformação estatística padrão, cada estatística possui uma geometria padrão.
A transformação estatística cria novas variáveis que não estavam presentes em nossos dados originais (ex: count, pop)
Podemos visualizar uma transofrmação estatística mudando a estatística padrão de uma geometria (ex: geom_bar(stat=“count”) ou usando uma função stat() (ex: stat_count(geom=“bar”) que chama uma geometria padrão para criar uma camada.
Nota
Podemos usar a sintaxe ..nome.. para mapear uma estatística em uma estética (aes()).
Para ficar mais claro, vejamos o seguinte caso:
l + stat_density_2d(aes(fill = ..level..),
geom = "polygon")Explicando com mais detalhes o exemplo acima, vemos que estamos uma adicionando uma camada no gráfico representado pela letra “i”.
Depois estamos criando uma nova camada através da estatística “stat_density_2d”. Esta função cria diversas variáveis calculadas automaticamente que podem ser acessadas por ..level.., e neste caso estamos atribuindo uma variável calculada ao mapeamento de preenchimento fill =.
Ao final, estamos forçando uma geometria “polygon” ou invés da geometria padrão desta função que seria “density_2d”.
Veja o exemplo abaixo:
mpg |> ggplot(aes(x = class, fill = class))+
stat_count()
mpg |> ggplot(aes(x = class, color = class))+
stat_count( geom = "point")
Neste caso, estamos criando no gráfico da esquerda, uma camada usando a função stat_count (que tem com padrão a geom=“bar”) e no gráfico da direita, estamos forçando uma geometria de pontos.
O mesmo poderia ser feito, utilizando a geometria e alterando a estatística padrão. Veja como seria:
mpg |> ggplot(aes(x = class, fill = class))+
geom_bar()
mpg |> ggplot(aes(x = class, color = class))+
geom_point(stat = "count")
Veja que tivemos que alterar a estatística padrão apenas da geom_point. Isto porque a geom_bar, já possui a estatística “count” como padrão, já a geom_point, possui a estatística “identity” como padrão.
Importante
A transformação estatística “identity”, significa nenhuma transformação, ou seja, utiliza os dados que estão em nossa tabela original. É muito utilizada quando não queremos que alguma geometria faça o cálculo da transformação estatística para nós, mas sim, quando quisermos utilizar os dados já calculados em alguma coluna da tabela.
A seguir teremos uma sequência, demonstrando a criação de diversas camadas utilizando as transformações estatísticas e suas respectiva geometrias padrão.
Dica
Para maiores detalhes dos argumentos, variáveis computadas e geometrias padrão, digite ?<nome_função_estatística> (ex: ?stat_count)
8.4.4.1 stat_bin
8.4.4.2 stat_count
8.4.4.3 stat_density
c + stat_bin(binwidth = 1, boundary = 10)
c + stat_count(width = 1)
c + stat_density(adjust = 1, kernel = "gaussian")
8.4.4.4 stat_bin_2d
8.4.4.5 stat_hex
8.4.4.6 stat_density_2d
8.4.4.7 stat_ellipse
e + stat_bin_2d(bins = 30, drop = T)
e + stat_bin_hex(bins = 30)
e + stat_density_2d(contour = TRUE, n = 100)
e + stat_ellipse(level = 0.95, segments = 51, type = "t")
8.4.4.8 stat_contour
8.4.4.9 stat_summary_hex
8.4.4.10 stat_summary_2d
8.4.4.11 stat_boxplot
8.4.4.12 sta_ydensity
l + stat_contour(aes(z = z))
l + stat_summary_hex(aes(z = z), bins = 30, fun = max)
l + stat_summary_2d(aes(z = z), bins = 30, fun = mean)
f + stat_boxplot(coef = 1.5)
f + stat_ydensity(kernel = "gaussian", scale = "area")
8.4.4.13 stat_ecdf
8.4.4.14 stat_quantile
8.4.4.15 stat_smooth
e + stat_ecdf(n = 40)
e + stat_quantile(quantiles = c(0.1, 0.9),
formula = y ~ log(x), method = "rq")
e + stat_smooth(method = "lm", formula = y ~ x, se = T,
level = 0.95)
8.4.4.16 stat_function
8.4.4.17 stat_qq
8.4.4.18 stat_sum
8.4.4.19 stat_summary
8.4.4.20 stat_identity
8.4.4.21 stat_unique
ggplot() + xlim(-5, 5) +
stat_function(fun = dnorm, n = 20, geom = "point")
ggplot() + stat_qq(aes(sample = 1:100))
e + stat_sum()
e + stat_summary(fun.data = "mean_cl_boot")
h + stat_summary_bin(fun = "mean", geom = "bar")
e + stat_identity()
e + stat_unique()
8.4.5 Escalas
As escalas mapeiam os valores dos dados em um valor visual de uma estética. Quando criamos uma gráfico, o ggplot adiciona escala para cada mapeamento de forma automática. Mas é possível alterar as escalas padrão.
Vejamos o gráfico abaixo:
d + geom_bar()
Quando escrevemos o código acima, o ggplot identifica que a variável x é do tipo discreta (categórica) e cria uma escala para ela. Faz o mesmo o o count do eixo y. Portanto, se sobrescrevermos as configurações da escala do eixo x para uma escala discreta, não haverá mudanças.
d + geom_bar()+
scale_x_discrete()
No examplo a seguir, iremos sobrescrever a escala de preenchimento (fill) para um tipo manual, ou seja, onde iremos manualmente definir as cores de preenchimento, ou limites da escala (de onde até onde ela valerá) e os pontos de parada, seu nome e os títulos (labels). Veja como ficaria:
n <- d + geom_bar(aes(fill = fl))
n + scale_fill_manual(
values = c("skyblue", "royalblue", "blue", "navy"),
limits = c("d", "e", "p", "r"), breaks =c("d", "e", "p", "r"),
name = "fuel", labels = c("D", "E", "P", "R"))
Nota
Lembre-se que já existe uma configuração de escala par o eixo x criada por padrão. Quando estamos sobrescrevendo com novos valores, se estes valores não sobrepoem os antigos, os valore anteriores ficam valendo. Por isso, a cor não foi alterada para o combustível (fl = c), já que deinifmos os limites da nova escala apenas para (d, e, p , r).
8.4.5.1 Escalas de Propósito Geral
Estas escalas são usadas na maioria das estéticas para mapear valores para os eixos x e y, preenchimento, cores, tipos de linhas, etc.
8.4.5.2 scale_*_continuous
Use par mapear valores contínuos para os valores visuais.
Por exemplo, vamos , ver a diferença entre a escala padrão definida para a variável “count” e outra sobrescrevendo a escala e deixando-a de forma reversa.
#Com escala padrão contínua para hwy.
c + geom_line(stat = "count") +
scale_x_continuous()
#Alterando o argumento trans = para inverter a escala.
c + geom_line(stat = "count") +
scale_x_continuous(trans = "reverse")
8.4.5.3 scale_*_discrete
Similar a scale_*_continuous porém para variáveis discretas.
Por exemplo:
d + geom_bar() +
scale_y_discrete(name = "Número de observações")
8.4.5.4 scale_*_binned
Use para deixar discreta um variável contínua, separando em classes. Veja o exemplo com a variável de consumo (hwy). Estamos alterando a escala e agrupando em 30 classes esta variável contínua.
c + geom_bar() +
scale_x_binned(n.breaks = 30)
8.4.5.5 scale_*_identity
#Criando uma tabela com as cores como uma variável.
dfc <- data.frame(
x = 1:4,
y = 1:4,
cor = c("red", "green", "blue", "yellow"))
#Gráfico com o preenchimento como variável discreta (col)
ggplot(dfc, aes(x, y))+
geom_col(aes(fill = cor))
# + scale_fill_discrete() isso é o padrão, portanto opcional
#Gráfico com o preenchimento pegando o valor da variável col
ggplot(dfc, aes(x, y)) +
geom_col(aes(fill = cor)) +
scale_fill_identity()
Veja que quando usamos uma nova escala, você precisa definir se quer a legenda e outros elementos.
ggplot(dfc, aes(x, y)) +
geom_col(aes(fill = cor)) +
scale_fill_identity(guide = "legend")
8.4.5.6 scale_*_manual
Use para definir uma escala de forma manual. Neste exemplo, vamor criar uma variável “cores”, definindo manualmente uma cor para cada classe de veículo.
cores <- c(suv = "red",
compact = "blue",
"2seater" = "darkgreen",
minivan = "orange",
midsize = "lightblue",
pickup = "yellow",
subcompact = "orange3")
ggplot(mpg, aes(class, hwy)) +
geom_col(aes(fill = class)) +
scale_fill_manual(values = cores)
8.4.5.7 scale_*_date
Use para tratar uma escala como data. Neste exemplo, iremos utilizar o conjunto de dados “billboard” também modificar os labels da escala e quantas paradas ela terá.
billboard |>
ggplot(aes(x = date.entered)) +
geom_bar() +
scale_x_date(date_labels = "%m/%Y", date_breaks = "20 weeks")
8.4.5.8 scale_*_datetime
Similar a scale_*_date , porém ela lida com data e hora.
8.4.5.9 Escalas de Localização X & Y
Algumas escalas alteram a estética dos eixos x e/ou y. O
8.4.5.10 scale_*_log10
Use para plotar o eixo x em escala de log10.
c + geom_line(stat = "count")+
scale_y_log10()
8.4.5.11 scale_*_reverse
Use para inverter a ordem da escala.
c + geom_line(stat = "count")+
scale_x_reverse()
8.4.5.12 scale_*_sqrt
Use para plotar o eixo x em escala quadrática.
c + geom_area(stat = "count") +
scale_y_sqrt()
8.4.5.13 Escalas de Cor e Preenchimento
As escala de cor (color e fill) possuem características semelhas, tanto para variáveis discretas quanto contínuas. A seguir, usar a cor de preenchimento com funções scale_fill_*, porém as mesmas características estão disponíveis para as funções scale_color_* .
Variáveis Discretas
8.4.5.14 scale_fill_brewer
Use esta escala de cores para aplicar paletas qualitativas nas cores. As paletas são provenientes do pacote RColorBrewer. Este pacotes possui paletas para cores sequenciais, divergentes e qualitativas.
Para ver as paletas disponíveis use:
RColorBrewer::display.brewer.all(type = "qual")
RColorBrewer::display.brewer.all(type = "seq")
RColorBrewer::display.brewer.all(type = "div")
Dica
Para visualizar apenas as paletas amigáveis à pessoas com sensíveis à diferenciação de cores (colorblind), usa o parametro colorblindFriendly = TRUE
n + scale_fill_brewer(palette = "Blues")
8.4.5.15 scale_fill_grey
Use para gerar escalas de cores em diferentes níveis de cinza, com valores de 0 até 1.
n + scale_fill_grey (start = 0.2, end = 0.8)
Variáveis Contínuas
Para demonstrar algumas escalas de cores para variáveis contínuas, criaremos um objeto ggplot “o”, adicionando a estética de preenchimento para a mesma variável mapeada em na estética “x”.
o <- c + geom_dotplot(aes(fill = ..x..))8.4.5.16 scale_fill_distiller
Use para extender as escalas “brewer” das variáveis discretas para variáveis contínuas, adicionando 7 outras cores por interpolação.
o + scale_fill_distiller(palette = "Blues")
8.4.5.17 scale_fill_gradient
Use para criar escalas de cores contínuas com gradiente de duas cores.
o + scale_fill_gradient(low="red", high="yellow")
8.4.5.18 scale_fill_gradient2
Use para criar escalas de cores contínuas com gradiente de três cores (início, meio e fim).
o + scale_fill_gradient2(low = "red", high = "blue",
mid = "white", midpoint = 25)
8.4.5.19 scale_fill_gradientn
Use para criar escalas de cores contínuas com gradiente de múltiplas cores.
o + scale_fill_gradientn(colors = topo.colors(6))
Além da paleta topo.colors(), podemos ainda usar heat.colors(), terrain.colors, rainbow() e cm.colors() para criar um vetor de tamanho específico com cada elemento com uma cor seguindo o padrão de espaço de cores HSV.
Exemplo:
#|layout-ncol: 2
#|layout-nrow: 2
o + scale_fill_gradientn(colors = rainbow(6))
o + scale_fill_gradientn(colors = cm.colors(4))
o + scale_fill_gradientn(colors = heat.colors(3))
o + scale_fill_gradientn(colors = terrain.colors(4))
Dica
Para criar novas paletas de cor, podemos usar a função RColorBrewer::brewer.pal()
8.4.5.20 Escalas de Forma e Tamanho
Assim como nas demais escala vistas até aqui, temos como definir escalar para forma e tamanho. Vamos criar um objeto “p” com um gráfico de pontos para ver os exemplos:
p <- e + geom_point(aes(shape=fl, size = cyl))8.4.5.21 scale_shape
Use para controlar a escala da forma. Ela mapeia variáveis discretas em 6 formas facilmente identificáveis.
Importante
Se você tiver mais que 6 valores em sua variável discreta, uma mensagem de aviso iŕa aparecer e NÃO serão mostradas no gráfico. Use scale_shape_manual para fornecer seus próprios valores.
p + scale_shape()
8.4.5.22 scale_size
Use para alterar a escala de tamanho da área. Use scale_radius() para alterar o tamanho do raio. Veja no exemplo abaixo, que a variável “cyl” estava mapeada para a estética de tamanho (size) quando criamos o objeto “p”:
p <- e + geom_point(aes(shape=fl, size = cyl))Com isto, o ggplot entendeu que por ser uma variável numérica, deveria aplicar um distribuição contínua quando montou a distribuição de tamanho.
Já no gráfico da direito, alteramos a escala do tamanho e definimos o número de quebras em 4, 5, 6 e 8 cilindros.
p + scale_size()
p + scale_size(breaks = c(4,5,6,8) )
Aepsar de não ser recomendados, mas apenas para carater ilustrativo, vemos que cyl é uma variável discreta, e portanto poderíamos ajustá-la como tal para que o ggplot automaticamente definisse uma escala de tamanho discreta. Veja o que acontece quando utilizamos as função as_factor() na estética de tamnho para a variável cyl.
p2 <- e + geom_point(aes(shape=fl, size = as_factor(cyl)))8.4.6 Sistema de Coordenadas
Apesar do sistema de coordenadas cartesiano ser o mais comum no mundo dos gráficos, o ggplot aferece uma série de outros sistemas, como coordenadas polares, maps ou até mesmo uma coordenada cartesiana invertendo o eixo x com o y. A seguir verremos alguns exemplos seguindo o modelo padrão, onde criaremos um objeto “r” com uma geometria de barras para iniciar e evitar repetição do código.
r <- d + geom_bar()8.4.6.1 coord_cartesian
Use para definir e configurar um sistema de coordenadas cartesiano. Este é o sistema padrão do ggplot.
r + coord_cartesian(xlim = c(0,5))
8.4.6.2 coord_fixed
Use par criar um sistema de coordenada cartesiano com a proporção de aspecto entro os eixos x e y.
r + coord_fixed(ratio = 1/8)
8.4.6.3 coord_polar
Use para mudar o sistema de coordenadas para polar.
r + coord_polar(theta = "x", direction = 1)
8.4.6.4 coord_trans
Use para transformar as coordenadas cartesianas. Por exemplo, se quisermos alterar o eixo y, para que fique como raiz quadrada, faremos:
r + coord_trans(y = "sqrt")
Nota
Como vimos anteriormente, poreriamos transformar a escala do eixo y atraves das funçoes scale_y*. A diferença e que a alteraçao na escala acontece ANTES das transformaçoes estatisticas enquanto as coordenadas ocorrem DEPOIS. Mudanças de coordenadas também alterar a forma das geometrias.
8.4.7 Facetas
O ggplot usa o conceito de “facetas” para dividir um gráfico em sub-gráficos com base em uma variável discreta.
Vamos crir um objeto “t” base para exemplificar o uso de facetas:
t <- ggplot (mpg, aes(cty, hwy)) + geom_point()8.4.7.1 facet_grid
Use para criar um grid de facetas:
t + facet_grid(cols = vars(fl))
Neste exemplo, criamos um gráfico, com vários sub-gráficos em colunas, usando a variável “fl” como separador das facetas.
Podemos criar as facetas em linhas também:
t + facet_grid(rows = vars(year))
Ou em um grid de linhas e colunas?:
t + facet_grid(rows = vars(year), cols = vars(fl))
8.4.7.2 facet_wrap
Use para agrupar uma faixa de facetas em 2d.
t + facet_wrap (vars(fl))
Dica
Por padrão o ggplot irá usar a mesma escala do eixos para cada faceta. Podemos usar o argumento scales = pafra mudar este comportamento.
Veja um exemplo:
t + facet_grid(rows = vars(drv), cols = vars(fl), scales = "free")
Dica
Podemos usar os argumento “free_x” e “free_y” para ajustar os limites dos respectivos eixos.
Podemos também nomear cada faceta utilzando o argumento labeller =. Veja alguns exemplos:
t + facet_grid(cols = vars(fl), labeller = label_both)
t + facet_grid(rows = vars(fl),labeller = label_bquote(alpha ^ .(fl)))
8.4.8 Temas
A camada de temas, permite uma customização final ao gráfico, permitindo ajustes nas propriedades dos eixos, legendas, painéis e facetas.
O ggplot vem com alguns temas pré-definidos, mas você pode customizá-los de acordo com sua necessidade. A recomendação é que você parte de um tema que mais se aproxime da sua necessidade e mude os elementos faltantes. Veja alguns exemplo:
r + theme_bw()
r + theme_gray()
r + theme_dark()
r + theme_classic()
r + theme_light()
r + theme_linedraw()
r + theme_minimal()
r + theme_void()
Digamos que precisamos alinhar o título do gráfico com todo o gráfico. Neste caso, podemos usar o tema e ajusar o argumento plot.title.position =
r + ggtitle("Titulo")
r + ggtitle("Titulo") +
theme(plot.title.position = "plot")
Ou digamos que precisamos alterar a cor de fundo do gráfico:
r + theme(panel.background = element_rect(fill = "lightblue"))
São muitas as possibilidades de customização. Veja ?theme para todos os detalhes.
8.5 Ajuste de Posição
Em alguns casos, precisamos alterar a posição de algumas geometrias que ocupariam o mesmo local no gráfico.
Em geral, utilizamos o argumento “position =” nas geometrias para alterar a definição padrão.
Para entender melhor a diferença dos tipos de posições mais comuns, vamos criar um objeto ggplot chamado “s” e comparar estes tipos:
s <- ggplot(mpg, aes(fl, fill = drv))8.5.0.1 Position Stack
Use para colocar as geometrias empilhada uma sobre a outra.
s + geom_bar(position = "stack")
Para a geometria de barras (geom_bar), esta é a posição padrão.
8.5.0.2 Position Dodge
Use para colocar as geometrias lado a lado.
s + geom_bar(position = "dodge")
8.5.0.3 Position Fill
Use para colocar as geometrias empilhadas normalizando a altura.
s + geom_bar(position = "fill")
8.5.0.4 Position Jitter
Use para adicoinar um mudança aleatória em X e Y para evitar sobreposição do pontos.
e + geom_point(position = "jitter")
8.5.0.5 Position Nudge
Use para deslocar textos fora dos pontos.
e + geom_text(aes(label = cty), position = position_nudge(1,2)) +
geom_point() +
scale_x_continuous(limits = c(25,40))
Nota
Neste caso, ao invés de usarmos a string “nudge” , usamos a função position_nudge para passar os parametros de deslocamento. As funções “position_* funcoinam para ajuster de forma mais refinada o posicionamento. Em geral aceitam os argumento de altura (width) e largura (height).
s + geom_bar(position = position_dodge(width = 1))
8.6 Títulos e Legendas
8.6.0.1 labs
Por ser muito comum termos que alterar os títulos dos elementos de um gráficos, o ggplot oferece a função labs().
Podemos alterar o título do gráfico, o sub-título, o título de rodapé, o nome alternativo e uma estética (por exemplo, x ou y).
Veja o exemplo no objeto “t” criado previamente.
t + (aes (color = "fl")) +
labs(x = "Texto do eixo X", y = "Texto do eixo Y",
title ="Título geral do gráfico",
subtitle = "Sub-título do gráfico",
caption = "Texto de rodapé",
alt = "Texto alternativo do gráfico para representação em texto",
color = "Título da Legenda")
8.6.0.2 guides
Use para definir os texto das guias. Guias são parte do gráfico que ajudam em sua interpretação. Por exemplo, a legenda é uma guia. As próprias marcas nos eixos são outro tipo de guias. As barras de tamanho ou forma, são outra forma de guias.
Por exemplo, se quisermos alterar a posição das guias do eixo x a cada duas marcas, podemos fazer usando a função guide():
p + guides(x = guide_axis(n.dodge = 2))
Para alterar o título da legenda da estética de tamanho (size) e colocá-la à direita da legenda, podemos fazer:
p + guides(size = guide_legend(title = "Novo Título", title.position = "right"))
Dica
Podemos também remover um determinada guia fazendo = “none”.
n + guides(fill = "none")
8.6.0.3 annotate
Use para gerar alguma anotação no gráfico, criando uma camada adicional. Você pode criar uma anotação de qualquer geométria. No exemplo abaixo, usaremos a geometria de texto (text) e de reta (segment) para escrever o texto e a seta.
t + annotate(geom = "text",
x = 34, y = 30,
label = "Anotação",
color = "red") +
annotate(geom = "segment",
x = 31, xend = 29, y = 32-2, yend = 34-2,
arrow = arrow(type = "closed", length = unit(0.02, "npc")),
color = "red")
8.6.0.4 theme
Podemos também através do tema, definir a posição da legenda por exemplo:
n + theme(legend.position = "bottom")
Podemos definir também atraǘes da escala o título e os texto de cada item da estética. Por exemplo, para alterar a legenda do preenchimento atraveś da escala, podemos fazer:
n + scale_fill_discrete(name = "Title",
labels = c("A", "B", "C", "D", "E"))
8.7 Zoom
Use para dar um zoom no gráfico. Podemos fazer o zoom removendo os valores que não serão vistos no gráfico, ou mantendo-os (preferencial).
Zoom mantendo os pontos (preferencial):
t
t + coord_cartesian(xlim = c(0, 25), ylim = c(10, 20))
Zoom excluindo os pontos não visíveis:
Fazemos este zoom, definindo limites das escalas:
t + xlim(0, 25) + ylim(10, 20)
Ou fazendo o equilavente de forma mais explícita:
t + scale_x_continuous(limits = c(0, 25)) +
scale_y_continuous(limits = c(10, 20))
8.8 Bônus
8.8.1 Template
Como vimos, há uma infinidade de possibilidades para criação de gráficos com o pacote ggplot, porém seus códigos podem se tornam com muitas linhas dado ao grau de customização que você precisa. Nossa recomendação é criar um gráfico com os ajustes nas principais camadas e depois uma função mais simplificada para chamar este código de forma repetida.
A idéia não é esclarecer os detalhes de criação de funções no R, mas sim, dar um exemplo para otimizar o código criado para o ggplot.
Exemplo:
Vamos criar nosso gráfico inicial:
g_barras <-
mpg |>
ggplot(aes(x = manufacturer, fill = class)) +
geom_bar() +
geom_text(stat = "count",
aes(label = ..count..),
position = position_stack(vjust = 0.5),
size = 3) +
scale_fill_brewer(type = "qual",
palette = 2,
direction = -1) +
labs(y = "Quantidade" ) +
guides(fill = guide_legend(nrow = 3)) +
theme_grey() +
theme(legend.position = "bottom") +
theme(axis.text.x = element_text(angle = 90)) +
theme(panel.background = element_rect(fill = "#E5F3F7"))
maior_valor <- mpg |>
count(manufacturer, class, sort = TRUE) |>
slice_head(n = 1) #Identificamos o grupo com maior qtd
g_barras + labs(
title = "Exemplo de gráfico dinâmico com função",
subtitle = paste0(maior_valor[[1]], " / ", maior_valor[[2]], " tem a maior qtd com ", maior_valor$n, " unidades.")) # Criamos um subtitulo para o grpo com maior Qtd dinamicamente.
Após termos o gráfico com as customizações que desejamos, podemos criar uma função. Neste caso, ela irá receber apenas os dados, a variável do eixo x e de preenchimento.
# Função para gerar o gráfico
cria_grafico_barras <- function(dados, eixo_x, preenchimento) {
g_barras <-
{{dados}} |>
ggplot(aes(x = {{eixo_x}}, fill = {{preenchimento}})) +
geom_bar() +
geom_text(stat = "count",
aes(label = ..count..),
position = position_stack(vjust = 0.5), size = 3) +
scale_fill_brewer(type = "qual",
palette = 2,
direction = -1) +
labs(y = "Quantidade" ) +
guides(fill = guide_legend(nrow = 3)) +
theme_grey() +
theme(legend.position = "bottom") +
theme(axis.text.x = element_text(angle = 90)) +
theme(panel.background = element_rect(fill = "#E5F3F7"))
maior_valor <- {{dados}} |>
count({{eixo_x}}, {{preenchimento}} , sort = TRUE) |>
slice_head(n = 1)
g_barras <-
g_barras + labs(
title = "Exemplo de gráfico dinâmico com função",
subtitle = paste0(maior_valor[[1]], " / ", maior_valor[[2]], " tem a maior qtd com ", maior_valor$n, " unidades."))
return(g_barras)
}Agora podemos usar a função com as mesmas ou outras variáveis. Apenas devemos observer o tipo das variáveis. Se sua função cria gráfico com variáveis discretas, ela pode não funcionar devidamente se’ passar variável contínua. Talvez você possa criar outra função, ou deixá-la mais “inteligente”.
#Usando a função criada.
mpg |>
cria_grafico_barras(manufacturer, class)
#Usando a função criada om outros parametros.
mpg |>
mutate (year = as_factor(year)) |> #Alterando a variável year para factor antes para torná-la discreta.
cria_grafico_barras(class, year)
8.8.2 Gráficos Interativos
Apesar de não fazer parte da Folhe de Resumo do ggplot2, entendemos que em alguns casos, ter gráficos com certa interatividade ajuda na explicação e visualização. Para isto, iremos apresentar brevemente o pacote plotly.
Este pacote, recebe um objeto ggplot e adiciona interatividade, permitindo que as valores sejam mostrados, por exemplo, quando o mouse passa por determinada região do gráfico. Obviamente, este pacote, paz muito mais que isso, mas apresentamos com o intuito de mostrar as possibilidades adicionais em termos de visualização.
library (plotly)
ggplotly(g_barras)Com a função ggplotly() agora temos uma interatividade em nosso objeto gg_barras criado anteriormente.