Bokeh é uma biblioteca de visualização de dados interativa em Python que existe desde 2013. Ela pode ser usada para a plotagem de gráficos em diversos níveis de sofisticação, representando conjuntos simples ou complexos de dados. A biblioteca pode ser usada por usuários com pouca experiência em programação ou programadores experientes com acesso aos seus comandos mais intrincados. Os gráficos do Bokeh podem ser interativos e embutidos em páginas da web.
Algumas definições básicas na terminologia de Bokeh são necessárias:
Application
um aplicativo Bokeh é um documento renderizado e executado no navegador.
Glyphs
glifos são os blocos de construção do Bokeh como linhas, círculos, retângulos e outras formas,
Server
o servidor Bokeh é usado para compartilhar e publicar gráficos e aplicativos interativos para um público de sua escolha
Widgets
os widgets do Bokeh são controles tais como menus suspensos, controles deslizantes e outras ferramentas de interface gráfica com o usuário que permitem interatividade
Instalação
Para instalar o Bokeh, se você tem Anaconda ou Miniconda, basta usar o comando: conda install bokeh. Usando pip a biblioteca pode ser instalada com: pip install bokeh.
Comandos básicos
Dois tipos de saídas podem ser obtidas: o gráfico enviado para um arquivo output_file('arquivo.html') ou embutidos no Jupyter Notebook, output_notebook(). Bokeh possui uma interface similar à do matplotlib, que é denominada bokeh.plotting. A classe principal dessa interface é Figure que contém os métodos para a inclusão de glyphs em um gráfico.
» # importar as classes necessárias
» from bokeh.io import output_notebook, show
» from bokeh.plotting import figure
» output_notebook()
Figura 1
» # dados a plotar
» x = [0,1, 0,3]
» y = [0,10,90,10]
» # instanciar um objeto figure
» fig = figure(plot_width=450, plot_height=300)
» # desenhar uma linha ligando os pontos dados
» fig.line(x,y)
» # exibir a figura 1
» show(fig)
A variável fig contém um objeto da classe com largura e altura especificadas, e instrução relativas às ferramentas a serem apresentadas, do lado direito no caso. O comando fig.line(x,y) usa o glyph line (linha) para ligar os pontos dados nas duas listas.
Glyphs
Glyphs são todos os elementos gráficos como linhas, círculos e cruzes marcadores de pontos, etc. Diferentes glyphs podem ter parâmetros ajustáveis diferentes. No exemplo aplicamos uma cor de fundo à figura, largura e altura. fig.circle() recebe os parâmetros posição (x,y), tamanho, que no caso é variável, cada círculo com raio size=y, largura de linha (as circunferências) line_width=5, e cor color=['red', 'blue','green','yellow']. Cada um dos discos tem uma cor diferente.
» # define dados
» x = [1,2,3,4]
» y = [10,40,90,160]
Figura 2
» # instancia figura com cor de fundo e dimensões dadas
» fig = figure(background_fill_color='#aabbff',
» plot_width=450, plot_height=300)
» fig.circle(x,y, size=y, line_width=5,
color=['red', 'blue','green','yellow'], alpha=.5)
» # exibir figura 2
» show(fig)
Os seguintes glyphs estão disponíveis:
asterisk()
cross()
diamond()
diamond_cross()
circle()
circle_x()
circle_cross()
triangle()
inverted_triangle()
square()
square_x()
square_cross()
x()
Alguns exemplos de uso de glyphs line, circle, cross, asterisk, x estão abaixo. As ordenadas y foram calculadas para formarem uma sequência de parábolas empilhadas, exceto pela reta horizontal amarela larga de fundo.
As propriedades de cada glyph podem ser calculadas e dependentes em qualquer fonte de dados. Na caso abaixo usamos a própria ordenada x para calcular alguns desses parâmetros. A propriedade color=['yellow','blue']*5 garante que os 10 ‘diamantes’ plotados alternem entre as cores amarelo e azul.
» x = np.arange(10)
» plot = figure(plot_width=650, plot_height=300)
» plot.circle_cross(x, x, size = 5+x, color='#ffaaff', alpha=1, line_width=7+x)
» plot.circle_dot(x, x, size = 30-2*x, color='#66aaff', alpha=.5, line_width=2)
» plot.inverted_triangle(x, x+5, size = 30-2*x, color='red', alpha=.9, line_width=2)
» plot.diamond(x, x+5, size = 30-2*x, color=['yellow','blue']*5, alpha=.8, line_width=2)
» show(plot)
» # figura 4 é plotada
» # outro plot com tamnho e cor variáveis
» x = np.arange(10)
» plot = figure(plot_width=600, plot_height=300)
» for k in range(100):
» plot.circle(k, (k-50)**2, size = k*2, color=(255*k/100, 200, 255),
» fill_color=(2.5*k, 100, 255-2.5*k), alpha=.4, line_width=2)
» show(plot)
» # figura 5 é plotada
Gráficos de Barras (Bar Plots )
Para gráficos de barras a sintaxe é um pouco diferente. As coordenadas x são o ponto central da barra vertical, top é a altura. A largura width= 1 significa nenhum espaçamento entre barras. As cores podem ser uma só ou uma lista, de mesmo tamanho que o número de barras. Para as barras horizontais o comprimento das barras é dado por right e a largura da barra é height.
» x = [8,9,10]
» y = [1,4,2]
» # barras verticais
» plot = figure(plot_width=600, plot_height=300)
» # plot.vbar para traçar barras verticais
» plot.vbar(x,top = y, color = ['blue','red','green'], width= .8, alpha=.5)
» show(plot) # exibe gráfico 6
» # barras horizontais
» plot = figure(plot_width=600, plot_height=300)
» plot.hbar(x, right = y, color = ['#77aaff','#aa77ff','#ff77aa'], height= .9, alpha=.5)
» show(plot) # exibe gráfico 7
O desenho da regiões ou patches é feito com plot.patches. As regiões são descritas por meios das coordenadas de suas arestas, dois pares de listas para cada figura. As propriedades fill_color, line_color, line_width, alpha receberam listas de 3 elementos, um para cada figura. Se um valor único for passado ele será válido para todas as figuras.
Gráficos de dispersão podem ser feitos com qualquer um dos glyphs. No exemplo abaixo a mesma plotagem é feita com círculos e com cruzes de tamanhos diversos, para efeito estético.
» from bokeh.models import Range1d
» plot = figure(plot_width=400, plot_height=250,
» x_axis_label = 'Coordenada x (abcissa)',
» y_axis_label = 'Ordenada y', title='Gráfico de dispersão')
» plot.x_range = Range1d(0, 5)
» plot.y_range = Range1d(0, 8)
» fcor = ['red','green','blue','brown','violet']
» x = np.array([1,2,3,4,4])
» y = np.array([5,6,2,2,4])
» plot.circle(x,y, size =x*15, color = '#aa55ff', fill_color=fcor, fill_alpha=.3)
» plot.diamond(x,y, size = x*15, color = 'red', alpha=.5,
» fill_alpha=.4, fill_color=fcor[::-1])
» show(plot) # figura 9
Figura 9
Observe que as coordenadas x, y poderiam ser listas. Como são arrays (do numpy) as operações para o cálculo do tamanho são permitidas. As faixas de coordenadas e ordenadas plotadas são controladas por x_range, y_range e estabelecidas por meio da função Range1d(m, n) (importada de bokeh.models). Os parâmetros color e alpha se referem ao traçado do glyph, enquanto fill_color e fill_alpha ao seu preenchimento. Relembrando, fcor[::-1] retorna a lista em ordem reversa.
Dataframes e ColumnDataSource
Usamos, até aqui, listas e arrays como fonte de nossos dados e serem plotados. Também podemos usar dataframes como fontes e o processo não é muito diferente. Se um dataframe tem uma coluna x e outra y plotamos o gráfico x × y simplesmente passando as series como parâmetros para x e y: plot.line(x = df['x'], y = df['y']).
Para montar um gráfico um pouco mais elaborado vamos usar os dados já descritos na seção sobre matplotlib. São dados sobre o número de nascimentos em países do mundo de 1950 até 2020, e a estimativa à partir de 2021. Importamos o arquivo .csv para o dataframe dfBrasil e selecionamos apenas as linhas relativas ao Brasil, até o ano de 2020. Esse dataframe é usado para plotar o gráfico de linhas. Outro dataframe, dfDecada, contendo apenas linhas com anos múltiplos de 10, é usado para plotar círculos. O raio do círculo é proporcional ao número de nascimentos.
» import pandas as pd
» dfNasc = pd.read_csv('./dados/number-of-births-per-year.csv')
» # selecionamos apenas linhas sobre o Brasil, até 2020
» dfBrasil = dfNasc[(dfNasc['Entity']=='Brazil') & (dfNasc['Year'] < 2021)]
» dfBrasil = dfBrasil.rename(columns={'Year':'ano', dfBrasil.columns[3]:'nasc'})
» # mantemos apenas colunas 'ano', 'nasc'
» dfBrasil = dfBrasil[['ano', 'nasc']]
» dfBrasil.head(2)
↳ ano nasc
4050 1950 2439820.0
4051 1951 2467186.0
» # criamos outro df, apenas com anos multiplos de 10
» dfDecada = dfBrasil[dfBrasil['ano']%10==0]
» cor = ['salmon','gold','teal','plum','powderblue','coral','wheat','azure']
» plot = figure(plot_width=400, plot_height=250,
» x_axis_label = 'Ano',
» y_axis_label = 'Nascimentos (milhões)',
» title='Número de Nascimentos no Brasil')
» plot.line(x = dfBrasil['ano'], y = dfBrasil['nasc']/1e6, color='black')
» plot.circle(x = dfDecada['ano'], y = dfDecada['nasc']/1e6,
» size=dfDecada['nasc']/1e5, fill_color = cor,
» fill_alpha=.5)
» show(plot) # figura 10
Figura 10
Uma forma útil de fazer a conexão com os dados é o objeto ColumnDataSource. Ela é especialmente útil quando se usa a mesma fonte para diversas plotagens e para vários widgets. ColumnDataSource cria um dicionário onde as chaves podem ter nomes definidos pelo usuário e as valores correspondentes são os dados contidos em colunas do dataframe (ou outra fonte).
Vamos retornar aos dados relativos aos nascimentos nos países do mundo. Dessa vez vamos manter apenas dados sobre o Brasil e a Indonésia (escolhido porque é um país que tem população próxima à brasileira), apenas nos anos de 1950 até 2020. Nessa tabela os países recebem os códigos Code='BRA' e 'IDN', respectivamente.
» dfNasc = pd.read_csv('./dados/number-of-births-per-year.csv')
» # selecionamos as linhas sobre o Brasil e a Indonésia, até 2020
» dfBI = dfNasc[((dfNasc['Code']=='BRA') | (dfNasc['Code']=='IDN')) & (dfNasc['Year'] < 2021)]
» dfBI = dfBI.rename(columns={'Year':'ano', dfBI.columns[3]:'nasc'})
Desses dados criamos um dataframe apenas com dados brasileiros, outro com dados sobre a Indonésia. Para mesclar esses dataframes alteramos as colunas ‘nasc’ respectivamente para ‘BRA’ e ‘IDN’.
Para ler mais sobre a operação do pandas realizada, similar a um INNER JOIN do sql, consulte o artigo Pandas e SQL Comparados, nesse site.
Ambos os dataframes têm 71 linhas. Usamos pandas.merge() para juntar esses dataframes pelo campo ‘ano’, um processo similar ao INNER JOIN do sql. Depois criamos três novas colunas: (1) campo dif, com a diferença por ano entre os números brasileiros e indonésios, (2), difM, a média entre os dois e (3) raio, descrito no comentário † abaixo.
(†) A terceira coluna adicional, raio, é a diferença vezes um fator para que os discos em plot.circle() preencham o espaço entre os nascimentos nos dois países, centrados na média. Essa plotagem aqui tem apenas efeito visual e para demonstrar os parâmetros do plot.
» from bokeh.models import Range1d
» from bokeh.plotting import ColumnDataSource
» # cria o objeto ColumnDataSource
» data = ColumnDataSource(dfBI)
» plot = figure(width=900, height=250, x_axis_label = 'Ano', y_axis_label = 'Nascimentos e diferenças',
» background_fill_color='#cfefff', border_fill_color='#ddeeff',
» title='Nascimentos no Brasil e Indonésia')
» plot.x_range = Range1d(1950, 2035)
» plot.y_range = Range1d(0, 5.5E6)
» plot.line(x = 'ano', y = 'BRA', source = data, color = 'red', legend_label = "Brasil")
» plot.line(x = 'ano', y = 'IDN', source = data, color = 'green', legend_label = "Indonésia")
» plot.x(x = 'ano', y = 'dif', source = data, color = 'blue', legend_label = "diferença")
» plot.asterisk(x = 'ano', y = 'difM', source = data, color = 'black', legend_label = "média")
» plot.circle(x = 'ano', y = 'difM', source = data, fill_color = 'whitesmoke', alpha=.2, size = 'raio')
» show(plot) # figura 11
Figura 11
Nesse gráfico introduzimos as legendas para cada plot. O campo difM foi plotado duas vezes, uma com um asterisco, outro com círculos com tamanhos determinados pelo campo raio. As faixas de plotagem, ranges, foram determinados para incluir gráfico e legendas. Cor de fundo para o gráfico e bordas são definidas com background_fill_color e border_fill_color.
Para o próximo gráfico baixamos para a subpasta dados do atual projeto o arquivo owid-covid-data.csv, publicado por Our World in Data com dados diários sobre a vacinação mundial contra o covid, entre 01/01/2020 e 26/09/2021. Deste aproveitamos apenas algumas colunas para plotar gráficos para efeito de demonstração do bokeh.
» # importamos os dados para um dataframe
» dfVacina = pd.read_csv('./dados/owid-covid-data.csv')
» # o dataframe tem 64 colunas e 119454 linhas
» dfVacina.shape # (119454, 64)
» # podemos ver os nomes das colunas com
» dfVacina.columns # nomes omitidos aqui
» # usamos apenas as colunas no dicionário
» colunas = {'date':'data',
» 'iso_code':'code',
» 'total_cases':'total',
» 'gdp_per_capita':'pib',
» 'human_development_index':'idh',
» 'life_expectancy':'expVida',
» 'total_deaths_per_million':'mortes',
» 'people_vaccinated_per_hundred':'vacinados'
» }
» # renomeamos as colunas
» dfVacina = dfVacina.rename(columns=colunas)
» # uma lista dos novos nomes:
» lst = list(colunas.values())
» # geramos novo df apenas com essas colunas
» df = dfVacina[lst]
» # eliminamos os linhas com NaN
» df = df.fillna(method='bfill') # veja comentário ‡
» # as três primeiras linhas são
» df.head(3)
↳ dia code total pib idh expVida mortes vacinados
0 2020-02-24 AFG 5.0 1803.987 0.511 64.83 0.025 0.0
1 2020-02-25 AFG 5.0 1803.987 0.511 64.83 0.025 0.0
2 2020-02-26 AFG 5.0 1803.987 0.511 64.83 0.025 0.0
» # finalmente montamos um dataframe contendo apenas o último dia registrado
» dfUltimo = dfU[dfU['dia']=='2021-09-26']
Lembramos que code identifica o país, total é o número total de casos de infecção por covid, mortes é o número total de mortes, por milhão e vacinados é o número de pessoas vacinadas, por 100 mil.
Podemos, em alguns casos, desejar incluir no gráfico um valor calculado a partir de um ou mais campos da tabela. Por ex., considerando que o campo idh varia entre 0,4 até 0,95, podemos usar esse campo, multiplicado por um fator, como informação do tamanho dos círculos plotados. Para fazer isso poderíamos incluir uma coluna extra com esse valor, como já foi feito em exemplos anteriores. Mas quando usamos o ColumnDataSource temos uma forma mais direta de fazer o mesmo. Podemos passar valores calculados no dicionário de valores que alimenta o ColumnDataSource.
Os campos do dataframe foram passados como valores em um dicionário cujas chaves são usadas como nome de campos nas plotagens. Os campos 'tamanho': dfUltimo['idh']*20 e 'grande': dfUltimo['idh']*40 são calculados para servir como informação para o tamanho (size ) dos círculos. O segundo círculo plotado tem apenas efeito estético, com um tamanho maior que o primeiro. O campo calculado alfa (uma fração do idh) é usado para regular a transparência dos discos vermelhos maiores.
O uso de ColumnDataSource permite que mais de um dataframe forneça dados para o gráfico. No entanto todas as series envolvidas devem ter o mesmo tamanho. Para ver isso vamos separar os dados sobre o Brasil e os EUA em duas tabelas separadas.
» # separa os dados relativos ao Brasil e os EUA
» dfBU = df[(df['code']=='BRA') | (df['code']=='USA')].copy() # comentário §
» # para usar as datas no eixo x transformamos o campo 'dia' de string em datetime
» dfBU.loc[:,'dia'] = pd.to_datetime(df.loc[:,'dia'], format='%Y/%m/%d')
» # com essa transformação a coluna passa a conter um datetime (timestamp). Por ex.:
» dfBU.loc[15250][0]
Timestamp('2020-02-26 00:00:00')
» # criamos dataframes para os dois países # comentário ‡
» dfUS = dfBU[(dfBU['code']=='USA') & (dfBU['dia'] &ge '2020-02-26')]
» dfBR = dfBU[dfBU['code']=='BRA']
(§) O uso de df2 = df1.copy() realiza uma cópia e não apenas pega um slice de df1. Esse procedimento evita mensagens de erro na linha seguinte, quando um campo do dataframe será alterado.
(‡) No dataframe original existe um número maior de valores para os EUA. O corte na data especificada faz com que dfUS e dfBR tenham o mesmo tamanho.
Podemos agora plotar gráficos do número de mortes por COVID no Brasil e EUA, no mesma figura.
Introduzimos nesse gráfico o uso de x_axis_type = 'datetime' para informar que o eixo x receberá dados de uma series temporal. plot.legend.location = 'top_left' informa a posição para as legendas.
Layouts
Layouts permitem a organização de gráficos em linhas e colunas múltiplas. Neles é possível vincular escalas de eixos entre gráficos diferentes.
Para explorar os layouts vamos usar o dataframe já montado df, que contém os campos dia, code, total, pib, idh, expVida, mortes, vacinados, descritos acima. Com ele construiremos 4 gráficos e os exibiremos em linhas, colunas e matrizes. A tabela inclui dados dos países ao longo de vários anos e, portanto, não há uma interpretação muito clara de seu significado. O objetivo é apenas o aprendizado da técnica.
» # transformando a coluna dia para um datetime
» df.loc[:,'dia'] = pd.to_datetime(df.loc[:,'dia'], format='%Y/%m/%d')
» # a fonte de todos os gráficos é a mesma, nesse caso
» from bokeh.plotting import ColumnDataSource
» cds = ColumnDataSource(data = df)
» # gráfico 1
» plot1 = figure(width=300, height=200, x_axis_type = 'datetime',
» x_axis_label = 'Data', y_axis_label = 'Mortes',
» background_fill_color='#fafaff', title='Mortes no Mundo')
» plot1.dot(x = 'dia', y = 'mortes', source = cds, color='rosybrown' ,alpha=.5)
» # gráfico 2
» plot2 = figure(width=300, height=200,
» x_axis_label = 'Expectativa de vida', y_axis_label = 'mortes',
» background_fill_color='#fafffa', title='Expectativa de Vida x PIB')
» plot2.dot(x = 'expVida', y = 'pib', source = cds, color='red' ,alpha=.1)
» # gráfico 3
» plot3 = figure(width=300, height=200,
» x_axis_type = 'datetime', x_axis_label = 'data', y_axis_label = 'mortes',
» background_fill_color='#ffefff', title='PIB x Mortes')
» plot3.dot(x = 'pib', y = 'mortes', source = cds, color='blue' ,alpha=.05)
» # gráfico 4
» plot4 = figure(width=300, height=200, x_axis_label = 'PIB', y_axis_label = 'IDH',
» background_fill_color='#9f9fff', title='PIB x IDH no mundo')
» plot4.dot(x = 'pib', y = 'idh', source = cds, color='yellow')
No código acima construimos quatro gráficos. Abaixo exploramos as possibilidades de layouts em linha, em coluna e em matriz.
» from bokeh.layouts import row, column
» # agrupar 2 gráficos em uma linha
» linha_layout = row(plot1,plot2)
» show(linha_layout)
» coluna_layout = column(plot3,plot4)
» show(coluna_layout)
» matriz_layout = column(row(plot1,plot2), row(plot3,plot4))
» show(matriz_layout)
Uma solução também interessante consiste em apresentar todos os gráficos no mesmo espaço, usando as classes Tabs e Panel. No código abaixo criamos 3 painéis e passamos nos argumentos os gráficos já construídos. Cada painel pode conter linhas e colunas, vistas anteriormente e passados no argumento child, além de um título que será usado nas guias ou tabs. Os painéis são inseridos em um objeto Tabs e exibidos.
» # importamos as classes necessárias
» from bokeh.models.widgets import Tabs, Panel
» # criamos 3 paineis
» tab1 = Panel(child = plot1, title = 'Mortes')
» tab2 = Panel(child = row(plot2,plot3), title = 'Exp Vida, PIBxMortes')
» tab3 = Panel(child = plot4, title = 'PIB x IDH')
» # insere os paineis no objeto Tabs
» objeto_tabs = Tabs(tabs = [tab1, tab2, tab3])
» # exibe o objeto
» show(objeto_tabs)
Ao clicar em uma guia o painés correspondente é exibido. Na figura estão mostrados a 1ª guia (figura 17) e a 3ª (figura 18).
Um layout de rede (grid layout) pode reunir gráficos em uma matriz, gerando resultado similar ao mostrado na figura 16. Para isso podemos usar o seguinte código.
» from bokeh.layouts import gridplot
» # cria uma rede ou grid
» grid_layout = gridplot([plot1, plot2], [plot3, plot4])
» show(grid_layout)
» # uma figura como a figura 16 é plotada.
Ao montar o grid_layout um espaço em branco pode ser inserido com None no lugar da variável do gráfico.
Algumas vezes é importante que dois ou mais gráficos tenham a mesma escala em um ou ambos os eixos. Para isso usamos o código como o seguinte.
» # criamos plots com a mesma escala (aqui no eixo do x)
» plot2.x_range = plot1.x_range
» # criamos um layout (aqui em linha)
linha_layout = row(plot2, plot1)
show(linha_layout)
Anotações e Widgets
Para os próximos exemplos vamos usar o aqquivo population.csv, baixado do site Our World in Data, na página sobre população mundial.
O arquivo ./dados/population.csv foi baixado no link acima.
import pandas as pd
» # Importar dados para um dataframe
» df = pd.read_csv('./dados/population.csv')
» # as colunas têm os nomes
» df.head(0)
↳ Entity Code Year Total population (Gapminder, HYDE & UN)
» # 4 colunas e 53307 linhas
» df.shape # (53307, 4)
» # renomeamos as colunas
» colunas = {'Entity':'pais',
» 'Code':'codigo',
» 'Year':'ano',
» 'Total population (Gapminder, HYDE & UN)':'populacao'}
» df = df.rename(columns=colunas)
» # as colunas agora têm os nomes
» df.head(0)
↳ pais codigo ano populacao
Já vimos como colocar títulos e legendas nas gráficos. No exemplo abaixo o título e posição são ajustados como uma propriedade de plot, diferente do parâmetro usado antes. Além disso podemos marcar regiões do gráficos com cores diferentes e incluir texto explicativo para realçar algum aspecto dos dados. Para isso usamos as classes Label e LabelSet.
Para alimentar esse gráfico vamos criar 3 ColumnDataSouces diferentes: para população e ano geramos cdsUSA para os EUA, cdsBRA para o Brasil, ambos após 1750. cdsLabel é usado para inserir anotações sobre os anos de independência e abolição da escravidão para os dois países.
Agora estamos prontos para plotar esses dados. As únicas importações novas são das classes Label, LabelSet. Os dois gráficos de barra abaixo recebem os campos ano e pop, cada um relativo a um dos países.
» from bokeh.io import output_file, show, output_notebook
» from bokeh.plotting import figure
» from bokeh.plotting import ColumnDataSource
» from bokeh.models import Label, LabelSet
» output_notebook()
» grafico = figure(plot_width=600, plot_height=300, x_axis_label = 'ano',
y_axis_label = 'População (em milhões)')
» grafico.title.text = 'População do Brasil e do EUA de 1800 até o presente'
» grafico.title_location = 'above'
» grafico.vbar(x = 'ano', top = 'pop', source=cdsUSA,
color = 'red', width= .1, legend_label = 'EUA')
» grafico.vbar(x = 'ano', top = 'pop', source=cdsBRA,
color = 'green', width= 1, legend_label = 'Brasil')
» labels = LabelSet(x='x', y='y', text='nota', x_offset=0,
y_offset=0, source=cdsLabel, render_mode='canvas')
» texto = Label(x=1750, y=150, render_mode='css',
» text='Independência e Abolição', text_color='blue',
» border_line_color='#a0a0f0', border_line_alpha=1.0,
» background_fill_color='linen', background_fill_alpha=1.0)
» grafico.add_layout(labels)
» grafico.add_layout(texto)
» grafico.legend.location = 'top_left'
» show(grafico)
Os objetos Label, LabelSet são criados com seus respectivos atributos e depois inseridos no grafico.
Usando mapas de cor
Para atribuir cores para uma categoria de dados, separando visualmente a informação para cada categoria, podemos atribuir uma cor a cada uma delas usando CategoricalColorMapper. Nele associamos a uma lista de fatores (factors ou dados categóricos) com uma lista de cores (em palette).
No exemplo inicializamos a variável mapaDeCor como um CategoricalColorMapper atribuindo os parâmetros factors e palette aos nomes das categorias e uma lista de cores. A associação é feita através do parâmetro transform no scatter plot. Novamente dois plots são traçados para efeito estético.
Vários outros pacotes estão disponíveis para a geração de gráficos em R. Entre eles estão os pacotes grid, lattice e ggplot2 que visam expandir as habilidades do sistema gráfico básico. grid fornece acesso de baixo nível às capacidades gráficas, geralmente usada por programadores, enquanto lattice fornece uma abordagem intuitiva para a análise de dados multivariados. Ambos são utilizadas por outros pacotes de geração gráfica e são instaladas por padrão na instalação do de R. Focaremos aqui nossa atenção sobre ggplot2.
Gráficos com ggplot2
ggplot2 é um pacote de visualização de dados criado por Hadley Wickham em 2005. Ele amplia e extende as funções gráficas básicas de R e contém vários padrões para exibição na web e para a impressão. O pacote é baseado no conceito de gramática de gráficos onde se pode construir todos os gráficos necessários à partir de alguns poucos componentes: o conjuntos de dados, informações para a elaboração estética do gráfico, elementos geométricos (marcas visuais para representar pontos plotados) e um sistema de coordenadas (cartesiano, polar, mapa, etc.). Apresentaremos aqui um resumo das funções. Para referências mais completas consulte os links no final este capítulo.
ggplot2 deve ser instalado separadamente ou dentro de um pacote de utilitários mais amplo que o inclui, o tidyverse.
As partes ou componentes de um gráfico são desenhadas em camadas. Todos os gráficos plotados são iniciados com uma chamada à função ggplot(). Em seguida, ou na mesma chamada, se fornece a fonte de dados (que deve ser um data frame) e as informações sobre a estética, especificados por aes(). Depois são acrescentadas as camadas, escalas, coordenadas e ângulo de perspectiva, usando-se +. Gráficos são gravados em disco com a função ggsave(). Observe que, diferente das outras funções gráficas vistas, ggplot() não aceita vetores como argumentos mas apenas data frames.
Hadley Wickhan, em seu livro R for Data Science, propõe uma forma forma geral ou template para se compreender a estrutura de ggplot2. Ele resume o pacote da seguinte forma:
ggplot(data = <DATA>) +
<GEOM_FUNCTION> (
mapping = aes(<MAPPINGS>),
stat = <STAT>,
position = <POSITION> ) +
<COORDINATE_FUNCTION> +
<FACET_FUNCTION>
O princípio subjacente é o de que qualquer gráfico pode ser construído com esses elementos (embora nem todos sejam obrigatórios). As funções facet permitem dividir o gráfico em partes que são plotadas juntas. É possível que em novas camadas se insira outra fonte de dados, diferente daquela passada na primeira camada.
ggplot()
Cria um gráfico
+; %+%
operador para inserção de camadas
aes()
insere informações sobre eixos e estética do gráfico
ggsave()
grava um objeto ggplot
qplot() quickplot()
plotagem simplificada
Para ilustrar o conceito do gráfico construído por camadas considere o seguinte código:
> install.packages("tidyverse")
> library(ggplot2)
> data("mtcars")
> g <- ggplot(mtcars) # Inicializa o gráfico
> # Uma camada, contendo pontos, é inserida com geom_point.
> # Em aes() mapeamos as variáveis, definimos cores e tamanho dos pontos
> g <- g +
geom_point(aes(x = hp, y = mpg, color = factor(am)), size = 3)
> # Para alterar as cores
> g <- g +
scale_color_manual("Tipo",
values = c("darkred", "deepskyblue4"),
labels = c("Manuais", "Automáticos"))
> # Rótulos
> g <- g +
labs(title = 'Consumo comparado de potência de carros automáticos e manuais',
y = 'Consumo', x = 'Potência')
> print(g)
O gráfico é plotado:
> library(ggplot2)
> cidades <- data.frame(nome=c("SP", "Rio", "Bsb", "Salv", "BH"),
populacao=c(12.106, 6.520, 3.040, 2.953, 2.523))
> graf <-ggplot(cidades, aes(x=nome, y=populacao))
+ geom_bar(stat = "identity")
+ labs(title="População, em milhões")
> print(graf) # gráfico-1 é plotado
> # Usando mtcars$cyl como fator
> a <- ggplot(mtcars, aes(factor(cyl)))
> b <- a + geom_bar()
> c <- a + geom_bar(fill="red")
> d <- a + geom_bar(fill="red", colour = "black")
> e <- a + geom_bar(fill=rainbow(3), colour = "black")
> print(b) # gráfico (b) é plotado
> print(c) # gráfico (c) é plotado
> print(d) # gráfico (d) é plotado
> print(e) # gráfico (e) é plotado
> f <- ggplot(data=mtcars, aes(x=wt, y=mpg)) + geom_point() +
labs(title="Carros", x="Peso", y="Consumo: Miles/Galão")
> g <- ggplot(data=mtcars, aes(x=wt, y=mpg)) +
geom_point(pch=20, color="steelblue", size=2) +
geom_smooth(method="lm", color="red", linetype=2) +
labs(title="Automóveis", x="Peso", y="Consumo")
> mtcars$am <- factor(mtcars$am, levels=c(0,1), labels=c("Automatico", "Manual"))
> mtcars$vs <- factor(mtcars$vs, levels=c(0,1), labels=c("Motor-V", "Motor Comum"))
> mtcars$cyl <- factor(mtcars$cyl)
> h <-ggplot(data=mtcars, aes(x=hp, y=mpg, shape=cyl, color=cyl)) +
geom_point(size=3) + facet_grid(am~vs) +
labs(title="Carros: por tipo de motor", x="Potência", y="Consumo")
> print(f) # gráfico (f) é plotado
> print(g) # gráfico (g) é plotado
> print(h) # gráfico (h) é plotado
Nos códigos acima ggplot() inicializa o gráfico, informa que mtcars será o data frame a ser usado. aes() (que fornece a estética ou aparência do plot), mapeia o wt (peso) com o eixo x e mpg (milhas por galão, consumo) com o eixo y. Os objetos geométricos (geoms) são os responsáveis pelos elementos visíveis sobre os eixos coordenados, incluindo pontos, linhas, barras, caixas e áreas sombreadas. No gráfico (f) geom_point(), por padrão, marca pontos em (x, y) desenhando um gráfico de dispersão. A função labs() insere texto para os eixos.
No gráfico (g) geom_point() torna os pontos em esferas (pch=20), e define cor e tamanho. A função geom_smooth() insere uma linha vermelha tracejada (linetype=2) com ajuste linear definido pelo método (method=”lm”). A área sombreada representa intervalos de 95 % de confiança (default). Os gráficos plotados são mostrados abaixo:
Em (h) são traçados gráficos separados para os tipos de transmissão automática versus manual e tipo de motor. A cor e símbolo usado indicam o número de cilindros do carro (cyl) que também é a variável agrupadora.
No último gráfico (h) as cores para o parâmetro cyl foram escolhidas automaticamente. Para controlar manualmente este comportamento podemos usar scale_color_manual() como exibido abaixo:
> ggplot(iris,
aes(x = Petal.Length, y = Petal.Width, color = Species)) +
geom_point()
> ggplot(iris,
aes(x = Petal.Length, y = Petal.Width, color = Species)) +
geom_point() +
scale_color_manual(values = c("steelblue", "gold3", "darkorange"))
Os seguintes gráficos são gerados:
A função scale_color_manual() foi usada porque a variável Species é categórica. Outras funções são usadas para controlar escalas de cor usando diferentes tipos de variiáveis. Existem outras como scale_color__discrete(), scale_color_continuous(), scale_color_gradient(), etc. Igualmente se pode controlar outras propriedades usando-se scale_fill, scale_x etc.
As funções geom
Através da função ggplot() determinamos a fonte dos dados e as variáveis a serem plotadas. Já as diversas funções geom (algumas delas listadas abaixo) informa como elas devem ser representadas graficamente.
Função
Plota
Opções
geom_bar()
gráfico de barras
color, fill, alpha
geom_boxplot()
gráfico de caixas
color, fill, alpha, notch, width
geom_density()
gráfico de densidades
color, fill, alpha, linetype
geom_histogram()
histograma
color, fill, alpha, linetype, binwidth
geom_hline()
linhas horizontais
color, alpha, linetype, size
geom_jitter()
pontos espalhados
color, size, alpha, shape
geom_line()
gráfico de linhas
colorvalpha, linetype, size
geom_point()
gráfico de dispersão
color, alpha, shape, size
geom_rug()
gráfico “rug”
color, side
geom_smooth()
ajuste de linhas
method, formula, color, fill, linetype, size
geom_text()
anotações em texto
Many; see the help for this function
geom_violin()
gráfico violino
color, fill, alpha, linetype
geom_vline()
linhas verticiais
color, alpha, linetype, size
As opções mais comuns são:
Opção
Controla
color
Cor de pontos, linhas e bordas
fill
Cor de áreas preenchidas
alpha
transparência de cores, de 0 (transparent) até 1 (opaco)
Para os exemplos seguintes usaremos o data frame singer (incluído no pacote lattice) que contém alturas (em polegadas) e faixa vocal para cada cantor e cantora do “New York Choral Society”. As faixas são: Bass 2, Bass 1, Tenor 2, Tenor 1, Alto 2, Alto 1, Soprano 2 e Soprano 1.
> data(singer, package="lattice")
> ggplot(singer, aes(x=height))
+ geom_histogram(fill="red", colour = "black")
+ labs(title="Coral de New York", x="Altura", y="Contagem")
> # O gráfico (i) é plotado
> ggplot(singer, aes(x=voice.part, y=height))
+ geom_boxplot(fill="steelblue", colour = "black")
+ labs(title="Coral de New York", x="Faixa vocal", y="Altura")
> # O gráfico (j) é plotado
Note que no gráfico de histograma apenas a coordenada x foi especificada pois, nesse caso, o valor default de y é a contagem de observações incluídas dentro de cada retângulo. Como aes() está inserido dentro de ggplot() todos os parâmetros definidos ali serão globais, valendo para todas as camadas (se não for novamente informado dentro de outra função de camada).
Para o exemplo que se segue usaremos o data frame Salaries que contém salários de algumas categorias de professores do ensino superior dos EUA no período de 2008-2009 (apenas 9 meses). Ele contém observações sobre algumas variáveis, incluindo sex e salary.
> library(car)
> # Para listar o sexo em português inserimos um novo campo
> Salaries$sexo <- ifelse(Salaries$sex=="Male", "Homem", "Mulher")
> ggplot(Salaries, aes(x=sexo, y=salary)) +
geom_boxplot(fill="skyblue3", color="black", notch=TRUE) +
geom_point(color="yellow", alpha=.5) +
geom_rug(sides="r", color="darkgrey") +
geom_jitter(position = position_jitter(width = .1),
alpha = 0.5, color="darkred") +
labs(title="Salário de professores (EUA)", x="Sexo", y = "Salário")
O seguinte gráfico é plotado:
O gráfico inclui caixas chanfradas (notch) azuis com bordas pretas. Os pontos, correspondentes às observações, são plotados em amarelo, com transparência .5. Observe que todos os pontos amarelos se acumulam sobre a linha vertical correspondentes aos dois sexos, uma vez que todos possuem uma das duas coordenadas no eixo x. Uma nova camada foi inserida através de um espalhamento aleatório (jitter) sobre estes pontos, usando-se geom_jitter() que são plotados em vermelho escuro. Este espalhamento não tem significado estatístico e serve apenas para facilitar a visualização dos pontos. Os dois conjuntos foram mantidos aqui apenas para efeito didático. Poderíamos ter inserido o efeito usando geom_point(position="jitter") junto que os demais parâmetros e omitindo geom_jitter(). Nesse caso os pontos amarelos ficariam dispersos. geom_rug() insere marcas em cinza na lateral direita, correspondentes às posições (y) dos pontos. Os lados podem ser sides = "rltd", alguma das letras ou combinações delas: right, left, top, down.
Agrupamentos
Muitas vezes é útil observar no mesmo gráfico grupos de observações diferentes. Já vimos que podemos agrupar dados em R usando fatores (ou variáveis de categorias). No pacote ggplot2 os agrupamentos ficam definidos pela associação de variáveis com características visuais como forma, cor, preenchimento, tamanhos e tipo de linha, em geral definidas dentro da função aes().
O código resulta, respectivamente nos seguintes gráficos, onde o agrupamento se deu por meio do parâmetro fill:
Mais de uma propriedade podem ser usadas para um agrupamento, como se vê no gráfico plotado pelo código abaixo.
> ggplot(data=Salaries, aes(x=salary, fill=rank)) +
geom_density(alpha=.3) +
labs(title="Salários de Professores",
x="Salário", y="Número de Professores")
ggplot(data=Salaries, aes(x=salary, fill=rank, color=sexo)) +
geom_density(alpha=.3) +
labs(title="Salários Masc x Fem", x="Salário",
y="Número de Professores")
No segundo gráfico o agrupamento foi feito através dos parâmetros fill e color:
Apesar de estar pouco nítido e não muito útil para uma análise, o gráfico representa 6 distribuições diferentes para as combinações de sexo =”Masculino” e “Feminino” e rank = “Prof”, “AssistProf” e “AssocProf”. O rank está representado pelo preenchimento (fill) e o sexo pela cor da borda (color) em cada distrinuição.
Gráficos em subplos (facet)
O último gráfico plotado apreenta 6 distribuições sobrepostas, pouco úties para uma visualização dos dados. Pode ser mais interessante analisar grupos diferentes olhando gráficos separados, apresentados lado a lado. No ggplot2 estes gráficos são chamados de facetados (faceted graphs) e são criados com as funções facet_wrap() e facet_grid():
Função
Resultado
facet_wrap(~var, ncol=n)
gráficos separados para cada nível de var, dispostos em colunas
facet_wrap(~var, nrow=n)
gráficos separados para cada nível de var, disposto em linhas
facet_grid(rowvar~colvar)
gráficos separados para cada nível de rowvar e colvar
facet_grid(rowvar~.)
gráficos separados para cada nível de rowvar, dispostos em uma coluna
facet_grid(.~colvar)
gráficos separados para cada nível de colvar, dispostos em uma linha
Na tabela var, rowvar, colvar são fatores, rowvar representa linhas colvar representa colunas.
Nos exemplos abaixo usamos o mesmo gráfico congestionado do caso anterior, onde 6 distribuições estavam representadas. No primeiro caso desdobramos as plotagens em 2 linhas, separadas por sexo. No segundo 3 gráficos são dispostos em uma coluna, 3 linhas, separados por rank.
> ggplot(data=Salaries, aes(x=salary, fill=rank, color=sexo)) +
geom_density(alpha=.3) +
labs(title="Salários Masc x Fem",
x="Salário", y="Número de Professores") +
facet_wrap(~sexo, nrow=2)
> ggplot(data=Salaries, aes(x=salary, fill=rank, color=sexo)) +
geom_density(alpha=.3) +
labs(title="Salários Masc x Fem",
x="Salário", y="Número de Professores") +
facet_wrap(~rank, nrow=3)
Em uma ordenação de facetas dividida por um fator com 8 elementos, distribuídos em 4 linhas, ficam dois plots lada a lado em cada linha:
Além da construção de gráficos customizados, ggplot2 permite incluir nesses gráficos informações processadas por meio de funções estatísticas de análise. Estas funções permitem o agrupamento de dados, o cálculo de densidades, contornos e quantis. Usando a função geom_smooth() podemos adicionar aos gráficos de dispersão linhas suavizadas (linear, não linear e não paramétricas) e sombreamentos para intervalos de confiança.
Parâmetro
Descrição
method=
método de suavização: lm, glm, smooth, rlm, e gam (linear, linear generalizado, loess, linear robusto ou aditivo generalizado). smooth é o default.
formula=
fórmula para a função de suavização. Exemplos: y~x (default), y~log(x), y~poly(x,n) para ajuste a polinômio de n-ésimo grau e y~ns(x,n) para um ajuste de spline com n graus de liberdade.
se
booleano, default=TRUE. Plota intervalos de confiança.
level
nível para intervalos de confiança (default de 95%).
fullrange
booleano, default=FALSE. Se o ajuste deve incluir toda a faixa do plot (TRUE) ou apenas os dados.
LOESS suavização de dispersão estimada localmente (locally estimated scatterplot smoothing).
Para o gráfico carro1 nenhum parâmetro foi fornecido. geom_smooth() adotados os defaults method = 'loess', formula 'y ~ x', como é informado no console. Em carro2 uma reta de melhor ajuste é plotada. Em carro3 uma curva de segundo grau de melhor ajuste é plotada.
A mesma curva é repetida em carro4 sem a representação dos intervalos de confiança.
Observe que o data frame carros foi criado à partir de mtcars com a função mutate() da biblioteca dplyr. Ela permite a criação de uma nova variável para o data frame existente. Além usamos o pipe:
> mtcars %>% mutate(carro=rownames(mtcars))
> # que é o mesmo que:
> mutate(mtcars, carro=rownames(mtcars))
A biblioteca ggplot2 incluiu um grande número de funções estatísticas para facilitar a visualização de dados. Estas funções podem ser chamadas implicitamente, sem chamadas do usuário. geom_smooth(), por exemplo, faz uso de stat_smooth() para encontrar a curva de melhor ajuste aos dados e os intervalos de confiança. É sempre útil consultar as páginas de ajuda para estas funções, por exemplo através de ?stat_smooth().
Temas
ggplot2 traz em sua instalação alguns temas prontos que modificam a aparência de um gráfico e a possibilidade da modificação ou criação personalizada destes temas. As opções da função theme() permitem o ajuste de fonts, planos de fundo, cores, linhas de grade, tamanho da fonte do eixo x, posição da legenda, etc. Para cada elemento do tema existe um tipo de objeto que realiza as alterações. Por exemplo, o estilo do título do eixo x (axis.title.x) é alterado com a função element_text() que possui diversos parâmetros (família da fonte, tipo da fonte, cor, tamanho, alinhamento etc.). As principais funções para se alterar elementos de um tema são element_text(), element_line(), element_rect() e element_blank(). O útilmo é usado para que nada seja desenhado no elemento que recebe esta função.
Um exemplo simples de uso de temas é mostrado, através da aplicação do tema theme_dark():
> library(lattice) # Para usar o data frame singer
> ggplot(data=singer, aes(x=height, fill=voice.part)) +
geom_density() +
facet_grid(voice.part~.)
> ggplot(data=singer, aes(x=height, fill=voice.part)) +
geom_density() +
facet_grid(voice.part~.) + theme_dark()
Para quem usa o RStudio existe um add-in que permite a customização gráfico do ggplot2 através de uma interface com o usuário que usa atalhos de teclado e interação com o mouse chamada ggThemeAssist. Com ela o usuário pode alterar temas do forma WYSIWYG, usando tentativa e erro. O pacote deve ser instalado com install.packages("ggThemeAssist").
Para usar este add-in é necessário criar um objeto gráfico do ggplot2 e depois usá-lo como parâmetro em ggThemeAssistGadget. Uma janela é aberta com acesso à vários elementos da geometria do gráfico. Quando a janela é fechada a função retorna uma linha de comando contendo os parâmetros para que seja plotado o gráfico escolhido. O procedimento e resultado aparecem no código abaixo.
> library(ggThemeAssist)
> pp <- ggplot(data=singer, aes(x=height, fill=voice.part)) +
geom_density() + facet_grid(voice.part~.)
> ggThemeAssistGadget(pp)
> # Uma janela é aberta onde os parâmetros podem ser alterados interativamente.
> # A linha abaixo é retornada:
> pp + theme(plot.subtitle = element_text(colour = "bisque4",
vjust = 1), plot.caption = element_text(vjust = 1),
axis.title = element_text(family = "Bookman",
size = 14), plot.title = element_text(family = "Bookman"),
legend.title = element_text(family = "Bookman"),
panel.background = element_rect(fill = "cornsilk2"),
legend.key = element_rect(colour = "antiquewhite4"),
legend.background = element_rect(fill = "lavenderblush1")) +
labs(title = "Número de cantores x Altura", x = "Altura",
y = "Número de cantores",
subtitle = "Exemplo de Uso do ggThemeAssistGadget",
caption = "Gráfico demonstrativo")
> # O gráfico plotado aparece na imagem abaixo.
Múltiplos gráficos por página e salvando gráficos
Para os gráficos plotados pelo sistema base de R é possível combinar vários gráficos em um único com o uso da função layout() e o parâmetro mfrow. Com o pacote ggplot2 gráficos podem ser combinados em uma figura única com a função grid.arrange().
O código ilustra este procedimento.
Observe que neste caso estamos plotando gráficos independentes em uma simples figura, o que é diferente do que foi feito com a função facet onde se representava gráficos construídos sobre um mesmo data frame mas separados por variáveis categóricas.
A função ggsave() é usada para gravar os gráficos. A primeira chamada acima grava, na pasta ativa, uma imagem grafico-3.png com 5×4 polegadas. A segunda, onde se omitiu o parâmetro plot, grava um arquivo pdf com o último gráfico plotado, no caso o gráfico p1.
Uma parte importante da análise de dados esta na visualização destes dados em forma gráfica. A representação visual de dados permite, muitas vêzes, o reconhecimento de padrões que dificilmente seriam percebidos apenas com tabelas e números. R fornece várias funções para representar dados graficamente, tanto em gráficos bidimensionais quanto tridimensionais. Em particular dá-se ênfase aos gráficos estatísticos, tais como histogramas, curvas de distribuições, gráfico de barras e outros. Existem métodos gerais que se aplicam à diversas formas básicas de gráficos. Pode-se incluir títulos, nomes para os eixos, cores, representações por pontos linhas e sinais variados e anotações.
A função plot() é a mais básica na geração de um gráfico.
> x <- -10:10; y <- x^2; plot(x,y) # resultado na figura 1
> # Parâmetro para tornar a linha contínua
> plot(x,y, type="l") # resultado na figura 2
Alguns dos parâmetros são listados abaixo:
plot(x, y, ...)
x
coordenadas horizontais dos pontos. Pode ser um objeto numerado.
y
coordenadas verticais dos pontos. Omitido se x é um objeto numerado.
…
Argumentos adicionais (parâmetros gráficos).
Entre os argumentos adicionais:
type =
“p” (pontos), “l” (linhas), “b” (ambos),
“h” (histograma), “s” (degraus), “n” (em branco)
main =
título principal
sub =
subtítulo
xlab =
título para eixo x
ylab =
título para eixo y
asp =
aspecto (razão y/x).
Observe que, se u é um objeto ordenado, então plot usa como coordenada x a ordem dos elementos. Por exemplo:
> u <- rnorm(10)
> # Os dois gráficos seguintes são idênticos
> plot(u)
> plot(1:10, u)
Algumas funções sobreescrevem o gráfico já traçado. É o caso da função lines. É possível alterar características das linhas com os parâmetros lwd (largura da linha) e lty (tipo da linha), como se mostra no exemplo:
> a <- 1:20; b <- a^2
> plot(a, .1*b ,type="l") # linha 1
> lines(a, .2*b , lwd=4 ) # linha 2
> lines(a, .3*b , lwd=2) # linha 3
> lines(a, .4*b , lty=3) # linha 4
> points(a,.5*b, pch=3) # pontos 5
> text(10, 2, "Título do gráfico") # título na posição 10 , 2
As linhas acima resultam no gráfico:
Se vários gráficos devem ser analisados ao mesmo tempo, uma nova instância da janela de saída gráfica pode ser aberta com o comando dev.new() ou X11() (apenas para sistemas tipo Unix). Pode-se navegar entre “devices” gráficos abertos usando dev.new(), dev.next(), dev.prev(), dev.set() e dev.off().
> plot(rnorm(10)) # plota o primeiro gráfico
> dev.new() # abre nova janela
> plot(rnorm(20)) # plota o segundo gráfico
Os gráficos podem ser enviados diretamente para arquivos nos formatos JPEG, BMP, PDF, TIFF, PNG, entre outros. Como exemplo, direcionamos a saída gráfica para um arquivo JPEG:
> # grava arquivo hiperbole.jpg
> jpeg(file='hiperbole.jpg')
> # plota gráfico
> plot(x<- -100:100, 1/x, type='l', main="hipérbole")
> # fecha janela gráfica
> dev.off()
> # Grava arquivo jpeg com a imagem à direita.
Outras funções capazes de escrever por cima de um gráfico já plotado são locator(n) e identify(). A primeira serve para que o se selecione regiões do gráfico utilizando o botão esquerdo do mouse até que se tenha um número n de pontos selecionados (ou até pressionar o botão direito do mouse, para terminar). A cada clique dado com o botão esquerdo do mouse a função retorna no console as coordenadas do clique. Por exemplo:
> x <- 1:100; y <- sqrt(x)
> plot(x,y, type="l")
> text(locator(1), "x é aqui!")
> text(locator(1), "y é aqui!")
> text(locator(5), paste("<", 1:4, ">")
> # A linha acima marca 4 pontos
> # no gráfico, com o texto:
> # "<1>", "<2>", "<3>", "<4>"
> # respectivamente
Para os próximos passos usaremos o dataframe carregado por padrão no R de nome mtcars. Este é um conjunto de dados sobre automóveis com campos mpg, cyl, disp, hp, drat, wt, qsec, vs, am, gear, carb. Antes de prosseguir, observe que as quatro formas de notação abaixo são equivalentes:
Na quarta forma usamos y ~ x para representar x como variável independente, y como variável dependente.
Aproveitamos a oportunidade para conhecer uma sintaxe especial. O comando plot( cyl ~ ., data= mtcars ) realiza a plotagem de todos os gráficos de cyl como função de todos os demais campos de mtcars. O promptHit to see next plot: aparece entre as operações.
> attach(mtcars)
> plot(mpg ~ wt)
> abline(lm(mpg ~ wt))
> title("Regressão Linear de Consumo por Peso")
> detach(mtcars)
Para enviar este gráfico para um arquivo pdf basta cercar todas as linhas acima pelos comandos pdf("NomeArquivo.pdf") e dev.off().
A função abline(a,b) traça uma reta sobre o gráfico, recebendo os parâmetros a como a interseção da reta com o eixo y (x = 0) e b como a inclinação da reta. Ela recebe como argumento lm(y~x) que retorna diversos dados sobre a regressão linear da função y~x, entre eles os parâmetros a e b necessários para definar a reta.
A função abline possui outros parâmetros. Entre eles:
abline(a=NULL, b=NULL, h=NULL, v=NULL, col=, ...)
a = interseção com eixo y
b = inclinação da reta
h = y (traça reta horizontal por y)
v = x (traça reta vertical por x)
col = cor: "red", "blue", etc; ou rgb(x,y,z), onde x, y, z ∈ [0, 1]
ou hexadecimal #abcdef; a, ..., f ∈ [0, f], hexadecimal.
Alguns exemplos de uso de abline(). O código seguinte gera os gráficos abaixo:
> plot(x<- 0:10, x) # plotar uma reta
> title("Reta y = x")
> abline(v=4) # reta vertical por x = 4
> abline(v=6, col="blue") # reta vertical por x = 6, azul
> abline(h=8, col="#779900") # outra cor
> # Usando a tabela cars (embutida em R)
> dev.new()
> plot(cars)
> abline(v=c(15,20), col=c("blue", "red"), lty=c(1,2), lwd=c(1, 3), h=40)
Parâmetros Gráficos
O conjunto de parâmetros para construção de gráficos podem ser lidos e (alguns deles) alterados através da função par(). Podem ser características como fonts, cores, eixos e títulos.
par(..., no.readonly = FALSE)
Argumentos:
no.readonly = Booleano. Se TRUE apenas parâmetros que podem ser
alterados pelo usuário são exibidos.
... Outros parâmetros são passados na forma:
par1 = valor1, ..., parn = valorn
Se nenhum parâmetro for fornecido par() exibe uma lista dos parâmetros atuais, par(no.readonly = TRUE) exibe uma lista dos parâmetros que podem ser alterados. Valores alterados dessa forma permanecem válidos durante a sessão.
Para exemplificar suponha que pretendemos ter nossos gráficos plotados com quadrados sólidos ligados por retas. O seguinte código pode ser usado:
> # parâmetros default são armazenados
> oldPar <- par(no.readonly=TRUE)
> par(lty=1, pch=15)
> plot(cars$dist ~ cars$speed, type="b")
> title("Usando quadrados e retas")
> # parâmetros default são restaurados
> par(oldPar)
> # Claro que o mesmo efeito seria obtido com
> plot(cars$dist ~ cars$speed, type="b", lty=1, pch=15)
Alguns parâmetros são listados na tabela:
Parâmetro
Descrição
pch
símbolo usado para marcar pontos.
cex
tamanho do símbolo, relativo ao default. 1 = default, 1.5 is 50% maior, etc.
lty
tipo da linha.
lwd
largura da linha, relativa ao default. Ex.: lwd=2 dupla largura.
Valores de pch, lty
As cores que podem ser alteradas nos gráficos estão listas na tabela seguinte:
Parâmetro
Descrição
col
cor default do gráfico.
col.axis
cor para texto nos eixos.
col.lab
cor para labels nos eixos.
col.main
cor do título.
col.sub
cor do subtítulo.
fg
cor do primeiro plano.
bg
cor de fundo.
Para o parâmetro col algumas funções aceitam valores reciclados. Por ex., se col=c("blue", "green") e três curvas são exibidas então a primeira e a terceira serão azuis, a segunda verde. Cores podem ser especificadas por índice, nome, valores hexadecimais, RGB e HSV. A função colors() exibe uma lista de todas as cores disponíveis, por nome.
Algumas funções permitem a criação de palhetas, vetores com n cores contíguas:
rainbow(n, s = 1, v = 1, start = 0, end = max(1, n - 1)/n, alpha = 1,
heat.colors(n, alpha = 1),
terrain.colors(n, alpha = 1),
topo.colors(n, alpha = 1),
cm.colors(n, alpha = 1))
Parâmetros:
n
número (≥ 1) de cores no vetor.
s, v
“saturação” e “valor” no formato HSV.
start
[0,1] cor inicial para o arco-íris (rainbow).
end
[0,1] cor final para o arco-íris (rainbow).
alpha
[0,1], transparência.
Vamos explorar o uso destas palhetas de cores na próxima seção.
Para especificar o estilo, tamanho e família das fontes os seguintes parâmetros gráficos podem ser usados:
Parâmetro
Descrição
cex
magnificação do texto: 1 = default, 1.5 = 50% maior; 0.5 = 50% menor, etc.
cex.axis
magnificação dos eixos, relativo a cex.
cex.lab
magnificação do texto nos eixos, relativo a cex.
cex.main
magnificação do texto do título, relativo a cex.
cex.main
magnificação do texto do subtítulo, relativo a cex.
família da fonte. Os padrões são serif, sans e mono
Por exemplo, após a aplicação dos parâmetros: par(cex.main=3, cex.lab=1.5, font.lab=2, font.main=4, font.sub=3)
o texto nos gráficos serão representados com: títulos com fontes 3 vezes maior que o padrão definido em cex, eixos magnificados em 1.5, labels em negrito nos eixos, títulos em negrito itálico e subtítulos em itálico.
Para controle das dimensões do gráfico e margens usamos:
Parâmetro
Descrição
pin
largura e altura do gráfico, em polegadas.
mai
vetor com larguras das margens, c(inferior, esquerda, superior, direita) em polegadas.
mai
vetor com larguras das margens, c(inferior, esquerda, superior, direita) em linhas. [default = c(5, 4, 4, 2) + 0.1].
Função barplot()
A função barplot() permite a exibição de gráficos de barras. Um resumo de seus parâmetros está mostrado abaixo.
barplot(height, width = 1, space = NULL, names.arg = NULL,
horiz = FALSE, density = NULL, col = NULL, border = par("fg"),
main = NULL, sub = NULL, xlab = NULL, ylab = NULL, axes = TRUE)
Parâmetros:
height
vetor ou matriz contendo altura das barras.
width
vetor com largura das barras.
space
espaço deixado antes da barras (uma fração da largura).
A função bar plot pode receber uma matriz como argumento. Para ilustrar vamos usar a função table() para tabelar dados no data frame mtcars. Este data frame possui o campo mtcars$carbs que lista o número de carburadores de uma lista de automóveis. Em seguida criamos uma tabela com um teste clínico hipotético para o tratamento da gripe usando um antiviral, vitammina C e um “chazinho”.
> carburadores <- table(mtcars$carb)
> carburadores
1 2 3 4 6 8
7 10 3 10 1 1
> # A tabela mostra que existem 7 modelos com 1 carburador, 10 com 2, etc.
> barplot(carburadores, main="Modelos x carburadores", horiz=TRUE,
names.arg=c("1", "2", "3","4", "6", "8"), xlab="Quantos modelos",
ylab="Número de carburadores", col=rainbow(6))
> testeClinico <- matrix(c(45,9,12,4,31,31,1,10,7), ncol=3, byrow=TRUE)
> cores <-c("#5FC0A0", "#DE7A6B", "#6BA0DE")
> colnames(testeClinico) <- c("Antiviral","Vitamina C","Chazinho")
> rownames(testeClinico) <- c("Melhorou","Sem alteração","Piorou")
> testeClinico
Antiviral Vitamina C Chazinho
Melhorou 45 9 12
Sem alteração 4 31 31
Piorou 1 10 7
> resultado <- as.table(testeClinico)
> barplot(resultado, main="Gripe: teste clínico", xlab="Medicamento",
ylab="Eficácia", col=cores, legend=rownames(resultado))
O código acima gera os gráficos:
O mesmo gráfico, com os dados agrupados por tipo de medicamento testado pode ser obtido ao se acrescentar o parâmetro beside=TRUE que força a exibição de dados lado à lado para uma mesma coluna:
Usando funções de agregamento e passando o resultado para barplot() pode-se representar médias, medianas, desvios padrões e outros em gráficos de barras.
Para experimentar com esta funcionalidade usaremos o dataset embutido com o R denomidado states (US State Facts and Figures). Ele contém dados antigos sobre os 50 estados americanos. Em particular usaremos state.region, um fator contendo as regiões de cada estado (Northeast, South, North Central, West) e state.x77, uma matriz com 50 linhas e 8 colunas com informações sobre os estados. O campo state.x77$Illiteracy contém taxas de analfabetismo nos estados americanos em 1970, como porcentagem da população.
> # Carregamos uma palheta de 4 cores
> cor <- c("#F3E16E", "#6EC6F3", "#6FF36E", "#F36E84")
> reg <- state.region
> levels(reg) # as regiões estão em inglês
[1] "Northeast" "South" "North Central" "West"
# Para traduzir para o português alteramos os levels:
> levels(reg) <- c("Nordeste","Sul","Central Norte","Oeste")
> levels(reg)
[1] "Nordeste" "Sul" "Central Norte" "Oeste"
> # Usamos apenas a 3a. coluna de state.x77 (analfabetismo %)
> analfabetismo <- state.x77[,3]
> # Criamos um dataframe com informações: regiões x analfabetismo
> estados <- data.frame(reg, analfabetismo)
> # Agregamos a informação sobre analfabetismo por região,
> # usando a função mean (média)
> media <- aggregate(estados$analfabetismo, by=list(estados$reg), FUN=mean)
> # para alterar os nomes das colunas
> names(media) <- c("regiao", "taxa")
> # Ordenamos o resultado por taxa de analfabetismo
> media <- media[order(media$taxa),]
> View(media) # resulta na tabela 1
> # plotando o gráfico de barras
> barplot(media$taxa, names.arg=media$regiao, col=cor)
> title("Analfabetismo nos EUA / por região"
> # resultado no gráfico abaixo
O código acima gera o gráfico:
Função pie()
Gráficos de setores ou gráficos de pizza (pie charts) também são úteis para a representação de dados.
vetor de valores, exibidos como áreas dos setores no gráfico.
labels
nomes para legendas dos setores. NA ou “” = sem legenda.
edges
borda externa é um polígono com este número de lados.
clockwise
booleano. Sentido horário ou não das fatias.
init.angle
ângulo inicial (da primeira fatia).
col
vetor de cores de preenchimento das fatias.
main
título do gráfico.
> z <- (-10:10)^2 - 50
> barplot(z, col=rainbow(25), main="Gráfico de barras", ylab="y=x^2-50")
> dev.new()
> legenda <- paste("fatia ",1:16) # gera vetor fatia 1, ..., fatia 16
> cores <- c("#F3E16E", "#6EC6F3", "#6FF36E", "#F36E84")
> pie(rep(1,16), col=cores, labels=legenda, main="Setores")
O seguinte gráfico é gerado: Gráfico de Setores
O código abaixo gera três gráficos de setores (pie charts). As populações listadas para os cinco países mais populosos são dadas em milhões. No gráfico-2 os percentuais (apenas entre estes 5 países) são exibidas. No terceiro gráfico a packageplotrix é usada para desenhar um gráfico em 3 dimensões.
> populacao <- c(1420, 1368, 329, 269, 212)
> pais <- c("China", "India", "EUA", "Indonesia" , "Brasil")
> pie(populacao, labels=pais, main = "população em milhões")
> # Gera Gráfico-1
> pc <- round(populacao/sum(populacao)*100)
> pc # porcentagem de população (entre estes 5 países)
[1] 39 38 9 7 6
> label <- paste(pais, "-", pc, "%", sep="")
> label
[1] "China-39%" "India-38%" "EUA-9%" "Indonesia-7%" "Brasil-6%"
> pie(populacao, labels=label, col=rainbow(length(labels)), main = "população em milhões (%)")
> # Observe que length(labels)=5 e temos 5 cores geradas
> # Gera Gráfico-2
> library(plotrix) # deve ser instalado com install.packages("plotrix")
> pie3D(populacao, labels=label,explode=0.1, main="3D Gráfico setores")
> # Gera Gráfico-3
Os gráficos de setores são podem ser úteis para uma visualização rápida de uma relação entre valores. No entanto podem dificultar a análise mais minuciosa destes dados. Por exemplo, se dois setores tem aproximadamente o mesma área pode ser difícil perceber qual é maior. Em geral o uso de barras é mais recomendado.
Uma alternativa atraente é o fan.plot, carregado junto com a library plotrix. Neste tipo de gráfico os setores são sobrepostos e seus raios variados para que todos apareçam na representação.
> library(plotrix)
> populacao <- c(1420, 1368, 329, 269, 212)
> pais <- c("China", "India", "EUA",
"Indonesia" , "Brasil")
> fan.plot(populacao, labels=pais,
main = "Usando o fan.plot",
col=rainbow(5))
> # O gráfico à direita é gerado.
Histogramas com a função hist()
Histogramas (ou distribuições de frequências) são uma forma de exibir a distribuição de uma variável contínua. A faixa de valores a serem analisados é dividida em classes (que podem ser ou não uniformes). A base de cada retângulo na representação é dada pela extensão da classe e a altura pela quantidade de dados (frequências) dentro de cada classe. Histogramas são criados com a função hist(v) onde v é um vetor numérico.
O parâmetro freq=FALSE gera um gráfico baseado em densidades de probabilidade e não em frequências. O parâmetro break informa em quantos classes os dados devem ser divididos. Por default as classes são divididas uniformemente.
> distUniforme <- runif(1000, 0, 10)
> # gera 1000 valores distribuídos uniformemente, com média 0 e desvio padrão 1
> hist(distUniforme, col=rainbow(10))
> # plota o histograma dessa distribuição
> distNormal <- rnorm(100000, 0, sd=2)
> # gera 10^5 valores distribuídos aleatóriamente com distribuição normal,
> # com média 0 e desvio padrão 2
> hist(distNormal, col=rainbow(12))
> # plota o histograma dessa distribuição
Para os exemplos que se seguem usaremos o data frame faithful, embutido na instalação do R. Este é um data frame contendo 272 observações, registradas em 2 variáveis numéricas: eruptions, tempo de erupção, e waiting intervalo entre erupções ambas em minutos.
> attach(faithful)
> hist(eruptions)
> # Gera o primeiro histograma abaixo
> hist(faithful$eruptions, seq(1.6, 5.2, 0.2), prob=TRUE, col=rainbow(18))
> lines(density(faithful$eruptions, bw=0.1))
> rug(faithful$eruptions)
> # Gera o segundo histograma abaixo
> # Os efeitos de lines() e rug() estão marcados no gráfico
> detach(faithful)
Gráficos de densidade kernel
Dada uma variável aleatória discreta, a estimativa de densidade kernel (EDK) é uma técnica para se estimar a função de densidade de probabilidade que melhor se ajusta à esta variável. Ela busca suavizar dados discretos fazendo inferências sobre uma amostra finita de dados. Desta forma é possível extrapolar dados discretos, fazendo previsões para valores não diretamente medidos. O kernel (ou núcleo) é uma função simétrica, suave. Tipicamente se usa a gaussiana, embora outras funções podem ser escolhidas. No R um gráfico de densidade kernel para o vetor x pode ser obtido com plot(density(x, )).
> attach(mtcars)
> # Construimos uma densidade usando
> # mtcars$mpg (milhas por galão)
> d <- density(mpg)
> plot(d,
main="Milhas/galão (densidade kernel)")
> # Para colorir a área sob a curva
> polygon(d, col="lightblue", border="black")
> # Para inserir marcas nos valores
> # discretos que geraram a densidade
> rug(mpg, col="red")
> detach(mtcars)
A função polygon() desenha um polígono com vértices x, y, neste caso os pares fornecidos pela densidade. rug() marca os valores presentes no vetor mtcars$mpg.
Gráficos de densidade kernel podem ser usados para comparar dados em grupos distintos. Para isso usaremos o pacote sm. Nesse pacote usamos
a função sm.density.compare() para sobrepor gráficos nos grupos dentro de fatores cyl.f, que são, no caso, 4, 6 e 8. O formato é sm.density.compare(x, factor) onde x é um vetor numérico e o fator fornece a variável de agrupamento.
> install.package("sm")
> library(sm)
> attach(mtcars)
> cyl.f <- factor(cyl, levels= c(4,6,8),
labels = c("4 cilindros", "6 cilindros", "8 cilindros"))
> sm.density.compare(mpg, cyl, xlab="Milhas por galão")
> title(main="Consumo x Cilindros")
> cores<-c(2:(1+length(levels(cyl.f))))
> legend(locator(1), levels(cyl.f), fill=cores)
> # locator(1) faz com que o quadro de legendas
> # fique ancorado no ponto clicado pelo usuário.
> detach(mtcars)
O código acima gera o gráfico:
Gráficos de caixas boxplot()
Um gráficos de caixas (boxplot()) é uma ferramenta muita usada para analisar e comparar a variação de uma variável entre diferentes grupos de dados. Ela representa uma variável traçando as mesmas informações obtidas em sumário de cinco números:
o mínimo, o quartil inferior (percentil 25), a mediana (percentil 50), o quartil superior (percentil 75) e o máximo. Ele também pode ser usado para mostrar outliers (ou discrepantes, que são valores fora do intervalo de ± 1,5 * IQR, onde IQR é o intervalo interquartil definido como o quartil superior menos o menor quartil).
Aproveitamos, nas linhas de código abaixo, para rever algumas funções estatísticas básicas, como median(), quantil() e summary().
Boxplots podem ser usados para comparar grupos de variáveis dentro de um dataframe ou lista. O formato para isto é: boxplot(formula, data=dataframe) onde formula é uma relação entre campos do dataframe. Um exemplo de fórmula é y ~ A, onde A é uma variável categórica. Neste caso um plot separado de y é traçado para cada valor de A. A fórmula y ~ A*B resultaria em plots separados de y para cada combinação dos níveis nas variáveis categóricas A e B.
O opção varwidth=TRUE faz com que as caixas tenham larguras proportionais à raiz quadrada do tamanho das amostras. O parâmetro horizontal=TRUE (não usado no gráfico acima) produz a reversão da orientação dos eixos.
Visualizações interativas
O R fornece muitas formas de exibir gráficos que podem ser modificados por interações com o usuário. Vamos exibir aqui apenas alguns exemplos.
O leaflet é uma biblioteca javascript voltada para a visualização interativa de mapas. O código abaixo carrega uma sessão com o leaflet. A função addTiles() insere uma camada com um mapa ao leaflet inicializado.
> library(dplyr)
> library(leaflet)
> leaflet() %>% addTiles()
> # O gráfico 1 é desenhado.
> # Inserindo a latitude e a longitude da
> # Praça da Liberdade, em Belo Horizonte, MG.
> # (que foi encontrada no Google Maps)
> pcaLiberdade <- data.frame(longitude = -43.938023, latitude= -19.931743)
> pcaLiberdade$titulo <- "Praça da Liberdade, BH!"
> # pcaLiberdade é um data frame com campos:
> pcaLiberdade
longitude latitude titulo
1 -43.93802 -19.93174 Praça da Liberdade, BH!
> leaflet(pcaLiberdade)
%>% addTiles()
%>% addMarkers(lat = ~latitude, lng = ~longitude, popup = ~titulo)
> # O gráfico 2 é desenhado
Lembrando: as bibliotecas dplyr e leaflet devem ser instaladas. Observe as linhas de retorno na instalação para verificar sucesso ou erro. A biblioteca iplots, por exemplo, depende de Java.
A url mostrada (no caso “http://127.0.0.1:6260”) deve ser visualizada no Browser. A cada clique de mouse as coordenadas do cursor são exibidas na caixa abaixo, como mostra a figura.
Biblioteca plotly
O código abaixo utiliza o data frame diamonds que contém informações sobre cor, clareza, medidas, carat, preço de diamantes. O ponto clicado abre um pop-up com dados sobre a posição no gráfico e a clareza do diamante.
> library(plotly)
> set.seed(100)
> d <- diamonds[sample(nrow(diamonds), 1000), ]
> plot_ly(d, x = carat, y = price, text = paste("Clareza: ", clarity),
mode = "markers", color = carat, size = carat)
Sobre operadores em R
Em R o programador pode criar aperadores ou alterar o significado de operadores nativos usando o sinal “`” (backtick ou acento grave).
Por exemplo: `+` <- function(a, b) paste(a, b, sep="") "a"+"v" # retorna "av"
O sinal "+" se transformou no operador de concatenação.
Em geral se pode programar %X% (qualquer X) para qualquer funcionalidade. `%@%` <- function(a, b) a^b `%*%` <- function(x, y) x/y 2 %@% 3 # retorna 8 15 %*% 3 # retorna 5
As bibliotecas magrittr e dplyr definem o operador %>% com o seguinte significado: `%>%` <- function(x, FUN) FUN(x)
Isso quer dizer que x %>% hist
é o mesmo que hist(x)
Por exemplo: iris$Sepal.Length %>% hist # traça o histograma do vetor mtcars$mpg %>% hist(col=rainbow(5)) # histograma de mtcars$mpg usando 5 cores.
Gráficos tridimensionais
Existem muitas bibliotecas em R para a geração de gráficos 3D. Entre eles estão: RGL, car, lattice e scatterplot3d (e muitos outras).
Gráfico de dispersão em 3D com scatterplot3d
scatterplot3d é uma biblioteca de uso simples, com formato básico:
scatterplot3d(x, y=NULL, z=NULL)
onde x, y, z são as coordenadas dos pontos a serem plotados. Os argumentos y e z são opcionais, dependendo da estrutura de x.
Se x é uma fórmula (como em zvar ~ xvar + yvar) então xvar, yvar e zvar são usados como valores para x, y e z.
Se x é uma matriz com pelo menos 3 colunas então as variáveis x, y e z são lidas diretamente da matriz.
> library("scatterplot3d")
> data(iris)
> flor <- iris[1:50,1:3] # 50 linhas, 3 primeiras colunas
> names(flor) <- c("comprimentoSepala", "larguraSepala", "comprimentoPepala")
> # A forma mais simples de uso:
> scatterplot3d(flor)
> scatterplot3d(flor, pch = 20,
main="Gráfico dispersão 3D",
xlab = "Comprimento sétala (cm)",
ylab = "Largura sétala (cm)",
zlab = "Comprimento pétala (cm)", color="steelblue")
> # O gráfico 1 é gerado. (pch=20 usa símbolo bola cheia)
> scatterplot3d(flor, pch = 8, main="pch = 8 -> estrela",
color="#E8582D", angle=55, grid=TRUE, box=FALSE)
> # O gráfico 2 é gerado. pch=8 usa símbolo estrela,
> # o gráfico é girado de 55º, com grid e sem a caixa envelope.
> z <- seq(-10, 10, 0.01)
> x <- cos(z)
> y <- sin(z)
> scatterplot3d(x, y, z, highlight.3d = T, col.axis = "blue",
col.grid = "lightblue", main = "Hélice", pch = 20)
O gráfico ao lado é gerado.
Mais informações sobre scatterplot3d no site STHDA.
Mais informações sobre 3d scatterplots no site STHDA.
Outras visualizações em 3D com scatter3d
O formato básico para scatter3d, com alguns de seus parâmetros, é o seguinte:
» coluna_layout = column(plot3,plot4) » show(coluna_layout)
» matriz_layout = column(row(plot1,plot2), row(plot3,plot4)) » show(matriz_layout)
Aquisição de Dados
> # grava arquivo hiperbole.jpg
> jpeg(file='hiperbole.jpg')
> # plota gráfico
> plot(x<- -100:100, 1/x, type='l', main="hipérbole")
> # fecha janela gráfica
> dev.off()
> # Grava arquivo jpeg com a imagem à direita.
> x <- 1:100; y <- sqrt(x)
> plot(x,y, type="l")
> text(locator(1), "x é aqui!")
> text(locator(1), "y é aqui!")
> text(locator(5), paste("<", 1:4, ">")
> # A linha acima marca 4 pontos
> # no gráfico, com o texto:
> # "<1>", "<2>", "<3>", "<4>"
> # respectivamente
> attach(mtcars)
> plot(mpg ~ wt)
> abline(lm(mpg ~ wt))
> title("Regressão Linear de Consumo por Peso")
> detach(mtcars)
cores <-c("#5FC0A0", "#DE7A6B", "#6BA0DE")
> barplot(resultado,
main="Gripe: teste clínico",
xlab="Medicamento",
ylab="Eficácia",
col=cores, beside=TRUE)
> # Ordenamos o resultado por taxa de analfabetismo
> media <- media[order(media$taxa),]
> View(media) # resulta na tabela 1
> # plotando o gráfico de barras
> barplot(media$taxa, names.arg=media$regiao, col=cor)
> title("Analfabetismo nos EUA / por região"
> # resultado no gráfico abaixo
> library(plotrix)
> populacao <- c(1420, 1368, 329, 269, 212)
> pais <- c("China", "India", "EUA",
"Indonesia" , "Brasil")
> fan.plot(populacao, labels=pais,
main = "Usando o fan.plot",
col=rainbow(5))
> # O gráfico à direita é gerado.
> attach(mtcars)
> # Construimos uma densidade usando
> # mtcars$mpg (milhas por galão)
> d <- density(mpg)
> plot(d,
main="Milhas/galão (densidade kernel)")
> # Para colorir a área sob a curva
> polygon(d, col="lightblue", border="black")
> # Para inserir marcas nos valores
> # discretos que geraram a densidade
> rug(mpg, col="red")
> detach(mtcars)
