<WRAP tabs>
  * [[02_tutoriais:tutorial5:start|Tutorial]]
  * [[01_curso_atual:exercicios5| Exercícios]]
  * [[03_apostila:05a-graficos| Apostila]] 
</WRAP>
====== 5a. Criação e Edição de Gráficos no R======


<WRAP center round box 60%>
===== Refletindo sobre a representação dos dados =====

{{ youtube>Wy4S0_mvHno }}

</WRAP>


Nesse tutorial iremos apresentar os conceitos para a produção de gráficos no R, baseados nos pacotes da distribuição base do R: ''grDevices'' e ''graphics''.

===== Gráficos na Tela =====

Existem vários dispositivos gráficos no R que estão relacionados a dois grupos principais: os dispositivos de tela e os de arquivos. Nos dispositivos base do ''grDevices'' temos os dispositivos de tela ''windows'', ''X11'' e ''quartz'' que produzem janelas gráficas, funções que dependem um pouco dos sistemas operacionais que estão sendo usados (i.e. Windows, Linux ou MacOS). Assim, para abrir um dispositivo de tela temos as funções:

<code rsplus>
X11()
windows()
quartz()

</code>

O ''X11'' ou ''x11'' é uma função mais geral e funciona na maioria dos sistemas operacionais. Os outros são mais específicos e deve retornar uma mensagem de erro quando usada em outros sistemas operacionais. Para informações sobre o ''quartz'' no macOSX veja a documentação oficial [[https://cran.r-project.org/bin/macosx/RMacOSX-FAQ.html#Quartz-device|aqui]].


<WRAP center round box 60%>
**__O sistema do pacote__** <wrap hi>graphics</wrap> 

{{ youtube>pQYhAc6KtG4 }}
</WRAP>


===== Funções de Alto Nível =====

As funções gráficas de alto nível são aquelas que iniciam um dispositivo gráfico de tela e arranjam os elementos essenciais do gráfico no dispositivo. A principal função é a ''plot'', mas já usamos outras no tutorial anterior, como o ''hist'', ''boxplot'' e ''barplot''. 
 
/*
===== Orientações Gerais =====

Aqui são apenas dados os códigos e funções, para você executar e entender como funcionam. Para entender as funções, leia antes o capítulo correspondente na [[03_apostila:05a-graficos|apostila]]. Experimente também mudar mais argumentos e funções além das apresentadas nos exercícios. 
*/
<WRAP center round box 100%>

==== Criando Dados ====

Vamos criar um conjunto de dados fictícios para apresentar em gráficos e conhecer as principais funções e conceitos associados a elaboração deles pelo ''graphics''. Para tornar o exemplo mais conectado a uma situação real vamos relacioná-los a um trabalho de ecologia de paisagem onde o objetivo é entender a influência do tamanho e conectividade dos fragmentos florestais com a riqueza de espécies de aves:

  * ''riqueza'': variável resposta, número de espécies de aves
  * ''capturas'': número de indivíduos capturados com o mesmo esforço amostral 
  * ''area'': variável preditora relacionada à área do fragmento florestal em hectares
  * ''conectada'': variável preditora relacionada ao grau de conectividade do fragmento florestal
 

<code rsplus>
riqueza <- c(15, 18, 22, 24, 25, 30, 31, 34, 37, 39, 41, 45)
capturas <- c(33, 62, 75, 100, 150, 155, 167, 170, 171, 177, 178, 179)
area <- c(2, 4.5, 6, 10, 30, 34, 50, 56, 60, 77.5, 80, 85)
conectada <- factor(c("L", "M", "M", "L", "L", "H", "L", "H", "M", "M", "H", "H"), levels = c("L", "M", "H"))

</code>

Podemos usar esses vetores diretamente para fazer os gráficos. Entretanto, não é o que usualmente acontece. Quando fazemos a leitura de dados externos, os vetores das variáveis, normalmente, estão em um ''dataframe''. Vamos criá-lo para tornar o exemplo ainda mais próximo da realidade:

<code rsplus>
frags <- data.frame(riq = riqueza, cap = capturas, ha = area, con = conectada) 
str(frags)
</code>
 

</WRAP>


==== Criando Gráficos ====

No pacote ''graphics'' há duas maneiras de se especificar as variáveis em gráficos, como vimos anteriormente também no [[http://ecor.ib.usp.br/doku.php?id=02_tutoriais:tutorial4:start#graficos_bivariados|tutorial de análise exploratória de dados]]:

  * Nome ou posição dos argumentos: ''fungraph(x = a , y = b)''

  * Fórmula estatística: ''fungraph(b ~ a, data = dados)''

Abaixo podemos ver os gráficos associados a cada uma das variáveis preditoras com a saída padrão das funções ''plot'' e ''boxplot'':

<code rsplus>
plot(x = area, y = riqueza)
</code>

<WRAP center round box 50%>

{{:02_tutoriais:tutorial5:grafrag01.png?400|}}

</WRAP>

<code rsplus>
boxplot(riq ~ con, data = frags) 
</code>

<WRAP center round box 50%>

{{:02_tutoriais:tutorial5:grafrag02.png?400|}}

</WRAP>

<WRAP center round tip 60%>

Note que a primeira linha de código acima utilizou os objetos de vetores (''area'' e ''riqueza''), enquanto a segunda utiliza as variáveis que estavam no objeto ''frags'', usando os nomes das colunas deste objeto. Além disso, a segunda linha de código utiliza a fórmula estatística, com o símbolo ''~''. Vamos usar esse último formato a partir de agora.

</WRAP>
===== Editando Gráficos =====


==== Parâmetros Locais e Globais ====


A lógica dos gráficos no R é ajustá-los através de parâmetros que são estabelecidos antes ou durante a produção do gráfico. Os parâmetros globais devem ser modificados antes do gráfico ser iniciado pela função de alto nível. Os parâmetros locais são aqueles que podem ser modificados como argumentos dentro da função que produz o gráfico. Os parâmetros locais, muitas vezes, também podem ser modificados antes de iniciar o gráfico. Vamos ver como isso funciona! Primeiro vamos modificar localmente os parâmetros do tipo de símbolo grafado ''pch'' e seu tamanho ''cex'':


<code rsplus>
plot(riq ~ ha, pch = 19, cex = 1.5, data = frags)
plot(riq ~ ha, data = frags)
</code>

Essa modificação é local e não fica registrada no dispositivo. Por outro lado, as modificações globais ficam armazenadas no dispositivo ativo e são modificadas antes da produção do gráfico, utilizando-se a função ''par'':


<code rsplus>
par(pch = 19, cex = 1.5)
plot(riq ~ ha, data = frags)
plot(riq ~ ha, data = frags)
</code>

O ''par'' é uma das funções mais utilizadas, ao lado de ''plot'' para a produção de gráficos. Não tenho receio em afirmar que é a função que eu, pessoalmente (--- //[[aleadalardo@gmail.com|Alexandre Adalardo de Oliveira]] 2020/09/15 18:04//), mais consultei a documentação durante minha trajetória no R!

Vamos abrir a documentação e fazer a leitura para nos familiarizarmos com tudo que está disponível para modificação no dispositivo gráfico. Ao final, irá entender porque tive que consultar o ''par'' **"um par de vezes!"**

<code rsplus>
help(par)
</code>

Podemos acessar os valores dos parâmetros do dispositivo ativo, chamando a função ''par'' sem nenhum argumento:

<code rsplus>
par( )
par( )$pch
par( )$cex
</code>


Note que o ''pch'' e o ''cex'' permanecem com os valores que foram modificados. 
Neste caso, para voltar ao padrão é necessário retornar o parâmetro para o valor inicial ou fechar o dispositivo, e abrir um novo.  

<code rsplus>
par(pch = 1, cex = 1)
plot(riq ~ ha, data = frags)
</code>


São muitos parâmetros e lembrar todos os que foram modificados e seus valores padrão é uma tarefa complicada. Por essa razão, existe um procedimento particular à função ''par'' que é atribuir os valores padrão a um objeto, no momento em que os parâmetros são modificados. É possível, então, usar este objeto para retornar os valores ao padrão:

<code rsplus>
oldpar <- par(pch = 19, cex = 1.5)
oldpar
plot(riq ~ ha, data = frags)
par(oldpar)
plot(riq ~ ha, data = frags)
</code>

 
Não são todos os parâmetros gráficos que podem ser modificados ou que se comportam da mesma maneira tanto localmente quanto globalmente. Por exemplo, o parâmetro ''mfrow'' é um parâmetro exclusivamente global que divide o dispositivo em painéis que podem ter diferentes gráficos. O ''mfrow'' recebe um vetor com dois valores inteiros, representando as divisões das linhas e colunas do dispositivo, respectivamente:


<code rsplus>
oldpar <- par(pch = 19, mfrow = c(1,2))
oldpar
plot(riq ~ ha, data = frags)
plot(riq ~ ha, data = frags, cex = 1.5)
par(oldpar)
</code>

Por outro lado, o parâmetro ''cex'' tem um comportamento diferente quando aplicado no ''par'' ou em ''plot'':

<code rsplus>
plot(riq ~ ha, data = frags, cex = 2.5, pch = 16)
x11()
oldpar <- par(cex = 2.5)
plot(riq ~ ha, data = frags, pch = 16)
par(oldpar)
</code>

No código acima o ''cex'' no ''par'' utiliza o fator de incremento para todos os elementos do gráfico, enquanto que localmente o mesmo parâmetro no ''plot'' usa esse fator apenas para incrementar os símbolos associados às observações. Note também que abrimos uma nova janela com a função ''x11''((caso esteja usando um Mac, pode ter problemas para abrir a janela, nesse caso use ''quartz()'')) para compararmos os dois gráficos. Por padrão, o R sempre sobrescreve o gráfico na janela ativa e torna ativa a janela recém aberta. 


==== Parâmetros Vetorizados ====

Os parâmetros associados à representação dos dados no gráfico, em geral, são vetorizados. Isso significa que podem ser individualizados, tendo um valor para cada observação (linhas do ''data.frame''). Vamos ver como isso acontece, utilizando o parâmetro ''col'' que define a coloração do símbolo associado a cada observação. 

<WRAP center round box 90%>
**__coRes__**

O R tem vários métodos para atribuição de cores. Os mais comuns são valores inteiros e o nome, veja alguns exemplos:

{{:02_tutoriais:tutorial5:coloRs.png?900|}}

Use o comando ''colors()'' para ver todos os nomes de cores.

</WRAP>


Vamos usar então a representação de valores inteiros do quadro acima para definir cores para cada observação dos nossos dados:

<code rsplus>
plot(riq ~ ha, data = frags, cex = 1.5, pch = 19, col = 1:nrow(frags))
</code>


/*
=====Gráficos Múltiplos e Margens=====

O parâmetro ''mfrow'' permite que o dispositivo gráfico seja repartido em painéis que recebem diferentes gráficos. Esse é um exemplo de parâmetro que só pode ser modificado pela função ''par()''. Por exemplo, para colocar dois gráficos em um mesmo dispositivo de tela, usamos:
 

<code rsplus>

par(mfrow=c(2,1))
plot(riqueza~area)
boxplot(riqueza~conectada)


par(mfrow=c(1,2))
plot(riqueza~area)
boxplot(riqueza~conectada)

</code>

Que pode ser combinado com ''mar'' para mudar o tamanho das margens também:

<code rsplus>

par(mfrow=c(2,1), mar=c(4,14,2,6))
plot(riqueza~area)
boxplot(riqueza~conectada)


par(mfrow=c(1,2))
par(mar=c(14,4,8,2))
plot(riqueza~area)
boxplot(riqueza~conectada)

par(mfrow=c(1,2))
par(mar=c(8,4,8,1))
plot(riqueza~area)
par(mar=c(14,2,4,0.5))
boxplot(riqueza~conectada)
</code>

*/

=====Inserindo mais Informações em Gráficos=====

Uma outra lógica dos gráficos no R é que os elementos grafados não são apagados, mas podemos inserir novos elementos que serão sobrepostos aos que já existem. Para inserirmos elementos utilizamos as funções subordinadas às funções de alto nível que só operam se houver um dispositivo ativo e com um gráfico iniciado.

A seguir apresentamos alguns exemplos de funções para se inserir informações em gráficos.


==== lines() ====

Função para inserir linhas retas ou curvas não-paramétricas utilizando alguma estimativa como ''lowess'', ''loess'' e ''gam''.
<code rsplus>
plot(cap ~ ha , data = frags)
lines(lowess(x = frags$ha, y = frags$cap))  
</code>

/*
Um exemplo já conhecido: sobrepondo uma curva de densidade probabilística empírica a um histograma:

<code rsplus>
##Duracao em minutos das erupções do Faithful Geiser, Yellowstone
## Objeto faithful do pacote datasets

hist(faithful$eruptions,prob=TRUE)
lines(density(faithful$eruptions),col="blue")
</code>
==== abline() ====

Insira uma linha com intercepto e inclinação dados por números com
<code rsplus>
##100 numeros de uma distribuicao uniforme entre 1 e 10
x <- runif(100, 1, 10)
## Os mesmos numeros somados a um ruído normal de media zero
## e desvio-padrao um:
y <- x+rnorm(100)
##Scatterplot e linha teorica esperada
plot(y~x)
abline(0,1, col="blue")
</code>

Agora veja o que acontece se o argumento da função ''abline'' é o objeto resultante do ajuste de uma regressão linear simples, obtido com a função ''lm''((detalhes na unidade sobre [[03_apostila:06-modelos|modelos lineares]])):
<code rsplus>
modelo <-  lm(riqueza~area)
plot(riqueza~area)
abline(modelo)
</code>

E há ainda os argumentos ''h'' e ''v'' para linhas horizontais e verticais. Aqui traçamos as linhas que passam pelas médias de cada variável em um gráfico de dispersão.

<code rsplus>
plot(riqueza~area)
abline(v=mean(area))
abline(h=mean(riqueza))
</code>

**Você sabia?** A reta da regressão linear simples sempre passa pelo ponto que é a interseção destas duas linhas. 
*/
==== points() ====

Para inserir novos pontos no gráfico:

<code resplus>
plot(riq ~ ha, data = frags, pch = 19, col = 1:nrow(frags))
points(riq ~ ha, data = frags, cex = 1.8)
</code>

==== text() ====

Função utilizada para inserir caracteres dentro do gráfico. O texto pode ser letras, símbolos, palavras ou até mesmo uma frase. Lembre-se sempre que essas funções, em geral, são vetorizadas e podem inserir vários elementos de uma única vez, por exemplo, identificando cada observação:

<code rsplus>
text(x = 70, y = 31, labels = "<- olha esse dados!")
text(x = frags$ha, y = frags$riq + 1.1, labels = LETTERS[1: nrow(frags)], cex = 0.7)
</code>

/*
Você pode usar esta função para identificar pontos em seu gráfico, ou plotar rótulos ao invés de pontos:

<code rsplus>
require(MASS)# para objeto Animals
head(Animals)# consulte o help para entender
plot(brain~body, data=Animals, log="xy", type="n")
text(y=Animals$brain,x=Animals$body,labels=rownames(Animals))
</code>

==== mtext() ====
Esta função acrescenta texto nas margens do gráfico ou da janela gráfica. Consulte a página de ajuda para entender seus argumentos 
<code rsplus>
plot(riqueza~area)
mtext("legenda no lado errado", side=4, line=0.9, at=20,cex=2, family="serif")
</code>

==== par(new=TRUE) ====
Comando para sobrepor um novo gráfico a um gráfico já existente. Execute-o e compare com o obtido com o comando ''par(mfrow=c(2,2))''

<code rsplus>
plot(riqueza~area)
par(new=TRUE)
plot(abundancia~area)
</code>

==== axis() ====
Para se inserir um eixo novo. Esta função é bastante usada nos casos em que se deseja ter dois gráfico dentro de uma mesma figura (ver ''par(new=TRUE)''), 
ou então se deseja controlar muitos dos parâmetros dos eixos (como em ''mtext()'').
<code rsplus>
plot(riqueza~area)
par(new=TRUE)
plot(abundancia~area, axes=FALSE, ann=FALSE) ## começa com gráfico sem eixos
axis(4) ## adiciona eixo
</code>

*/

==== arrows(), rect(), polygon(), segments() ... ====

São muitas funções acessórias que inserem novos elementos nos gráficos, não faz sentido passar por todas aqui, vamos usar mais uma para apresentar uma outra forma de usar cores no R:

<code rsplus>

rect(xleft = 25, ybottom = 22, xright = 41, ytop = 32, col = rgb(red = 1,green= 0, blue = 0, alpha = 0.1)) 

</code>


<WRAP center round box 90%>
__**coRes**__

Um outro método para indicar cores no R é o [[https://pt.wikipedia.org/wiki/RGB|RGB]], o sistema de combinação de vermelho, verde e azul. Uma das vantagem desse sistema, além de possibilitar uma infinidade de cores e tonalidades, é que ele permite a inclusão da transparência da cor através do argumento ''alpha'' da função ''rgb''.  

{{  :02_tutoriais:tutorial5:rgb-color-model.jpg?400  |}}

</WRAP>


===== Ajustando o Gráfico =====

<WRAP center round box 60%>

==== Um exemplo ====

{{ youtube>ObHgPlVADRw }}

</WRAP>

Agora que conhecemos os princípios da construção de gráficos utilizando o ''graphics'', vamos ajustar nosso gráfico base, primeiro fechando todos os dispositivos abertos e iniciando um novo com tamanho determinado e em seguida fazendo os gráficos base lado a lado:

<code rsplus>
graphics.off()
X11(width = 14, height = 7)
par(mfrow = c(1, 2))
plot(riq ~ ha, data = frags)
boxplot(riq ~ con, data = frags, col = "white")
</code> 


<WRAP center round box 90%>

{{ :02_tutoriais:tutorial5:grafrag03.png | }}

</WRAP>


Vamos seguir ajustando os elementos dos gráficos. Primeiro, ajustando alguns parâmetros globais com o ''par'':

^ argumento ^ elemento ^ valor padrão ^ representação ^
| ''mar'' |  tamanho das margens | ''c(5, 4, 4, 2)''| numero de linhas ((a ordem dos lados de um gráfico sempre obedece o sentido horário partindo do eixo x))|
| ''las'' | legenda dos eixos |  ''0''  | paralela ao eixo |
| ''mgp'' | elementos dos eixos | ''c(3, 1, 0)''| distância em linhas ((entre o título, legenda e linha do eixo))| 
| ''family''| família de fonte |  '' "" ''  | fonte padrão do dispositivo|


<code rsplus>
graphics.off()
X11(width = 14, height = 7)
par(mfrow = c(1, 2), mar = c(4, 4, 1, 1), family = "serif", las = 1, mgp = c(2.5, 0.8, 0), cex = 1.2 )
plot(riq ~ ha, data = frags)
boxplot(riq ~ con, data = frags, col = "white")
</code> 


Agora vamos ajustar o primeiro gráfico utilizando algumas dos parâmetros locais na própria função ''plot'':
  * ''xlab'' : título do eixo x
  * ''ylab'' : título do eixo y
  * ''cex.lab'': aumento dos caracteres no título dos eixos
  * ''cex.axis'': aumento dos caracteres na escala dos eixos
  * ''bty'': tipo de caixa ao redor do gráfico
  * ''ylim'': limites da escala do eixo y


<code rsplus>
graphics.off()
X11(width = 14, height = 7)
par(mfrow = c(1, 2), mar = c(4, 4, 1, 1), family = "serif", 
                  las = 1, mgp = c(2.5, 0.8, 0), cex = 1.2 )
plot(riq ~ ha, data = frags, xlab = "Área (ha)", ylab = "Riqueza", cex = 1.5, 
                  cex.lab = 1.5, cex.axis = 1.2, bty = "l", ylim = c(12, 45), 
                  pch = c(15, 16, 17)[frags$con], 
                  col = c("red", "cornflowerblue", "aquamarine4")[frags$con])
boxplot(riq ~ con, data = frags)
</code> 

Note a indexação que foi feita no ''pch'' e no ''col''. Para fornecer o mesmo número de símbolo e nome de cor para as observação de um mesmo nível de fator, fizemos a indexação desses parâmetros gráficos pelo fator ''conectada''.  Para entender, primeiro vamos investigar o que foi produzido nas indexações:

<code rsplus>
c(15, 16, 17)[frags$con]
c("red", "cornflowerblue", "aquamarine4")[frags$con]
</code>

Como ''factor'' é armazenado na forma de números inteiros relativos à ordem dos níveis, podemos muito facilmente substituir os valores dos níveis, mantendo a ordem que aparecem nos dados, simplesmente indexando os novos valores pelo fator.

Agora vamos inserir uma legenda para as cores e símbolos:


<code rsplus>
graphics.off()
X11(width = 14, height = 7)
par(mfrow = c(1, 2), mar = c(4, 4, 1, 1), family = "serif", 
    las = 1, mgp = c(2.5, 0.8, 0), cex = 1.2 )
plot(riq ~ ha, data = frags, xlab = "Área (ha)", ylab = "Riqueza", cex = 1.5, 
     cex.lab = 1.5, cex.axis = 1.2, bty = "l", ylim = c(12, 45), 
     pch = c(15, 16, 17)[frags$con], 
     col = c("red", "cornflowerblue", "aquamarine4")[frags$con])
legend(x = 60, y = 20, legend = c("baixa", "média", "alta"), title = "Conectividade", 
       col = c("red", "cornflowerblue", "aquamarine4"), pch = c(15, 16, 17), bty = "n")

boxplot(riq ~ con, data = frags, col = "white")
</code> 

<WRAP center round box 90%>
{{ :02_tutoriais:tutorial5:grafrag04.png |}}
</WRAP>


O procedimento normalmente é esse. Vamos ajustando os parâmetros e avaliando o resultado até conseguir o resultado almejado. Satisfeito com o primeiro painel, podemos passar para o segundo. Da mesma forma que o primeiro painel, os parâmetros gráficos globais que não podem ser modificados localmente, devem ser modificados antes de executar a função de alto nível.


<code rsplus>
graphics.off()
X11(width = 14, height = 7)
par(mfrow = c(1, 2), mar = c(4, 4, 1, 1), family = "serif", las = 1, mgp = c(2.5, 0.8, 0), cex = 1.2 )
plot(riq ~ ha, data = frags, xlab = "Área (ha)", ylab = "Riqueza", cex = 1.5, cex.lab = 1.5, cex.axis = 1.2, bty = "l", ylim = c(12, 45), pch = c(15, 16, 17)[frags$con], col = c("red", "cornflowerblue", "aquamarine4")[frags$con])
legend(x = 60, y = 20, legend = c("baixa", "média", "alta"), title = "Conectividade", col = c("red", "cornflowerblue", "aquamarine4"), pch = c(15, 16, 17), bty = "n")
par(bty = "n", mar = c(4, 1, 1,1))
boxplot(riq ~ con, data = frags, ylim = c(12, 45), ann = FALSE, xaxt = "n", yaxt = "n", col = "gray90")
</code> 

No código do diagrama de caixas acima, para ter mais controle sobre título e legendas dos eixos, solicitamos na função que estes não fossem grafados. Agora podemos incluir esses elementos utilizando a função ''mtext'' que inclui caracteres nas bordas do gráfico:
 

<code rsplus>
graphics.off()
X11(width = 14, height = 7)
par(mfrow = c(1, 2), mar = c(4, 4, 1, 1), family = "serif", las = 1, mgp = c(2.5, 0.8, 0), cex = 1.2 )
plot(riq ~ ha, data = frags, xlab = "Área (ha)", ylab = "Riqueza", cex = 1.5, cex.lab = 1.5, cex.axis = 1.2, bty = "l", ylim = c(12, 45), pch = c(15, 16, 17)[frags$con], col = c("red", "cornflowerblue", "aquamarine4")[frags$con])
legend(x = 60, y = 20, legend = c("baixa", "média", "alta"), title = "Conectividade", col = c("red", "cornflowerblue", "aquamarine4"), pch = c(15, 16, 17), bty = "n")
par(bty = "n", mar = c(4, 1, 1,1))
boxplot(riq ~ con, data = frags, ylim = c(12, 45), ann = FALSE, xaxt = "n", yaxt = "n", col = "gray90")
mtext(text = c("baixa", "média", "alta"), side = 1, line = 0.5, at = c(1, 2, 3), cex = 1.5)
mtext("Conectividade", side = 1, line = 2.5, cex = 1.7)
</code> 

<WRAP center round box 90%>

{{ :02_tutoriais:tutorial5:grafrag05.png | }}
 
</WRAP>


Estando satisfeito com o resultado, podemos salvar o gráfico que está no dispositivo de tela ativo em nosso diretório, utilizando a função ''savePlot'':

<code resplus>
savePlot(filename = "graficoFrags.png", type = "png")
</code>


===== Dispositivos de Arquivos =====

A função ''savePlot'' não permite a manipulação da qualidade e definição da imagem no arquivo que é construído. Para maior controle na produção do arquivo é preciso utilizar os dispositivos específicos para cada formato de arquivo. Os mais comuns são: ''jpeg'', ''pdf'', ''png'' e ''tiff''.
Para utilizá-los é preciso abrir o dispositivo, chamando a respectiva função com os parâmetros que serão utilizados na construção do arquivo. A partir desse momento podemos construir o gráfico da mesma forma que fazemos no dispositivo de tela. Para finalizar e criar o arquivo é necessário fechar o dispositivo com a função ''dev.off''. Vamos salvar nosso gráfico com o dispositivo ''jpeg'' de alta qualidade e com 960 pixels de largura no arquivo ''graficoFrags.jpeg''.

<code rsplus>
graphics.off()
jpeg(filename = "graficoFrags.jpg", width = 960, height = 480, units = "px", pointsize = 12, quality = 100, bg = "white", res = NA)
par(mfrow = c(1, 2), mar = c(4, 4, 1, 1), family = "serif", las = 1, mgp = c(2.5, 0.8, 0), cex = 1.2 )
plot(riq ~ ha, data = frags, xlab = "Área (ha)", ylab = "Riqueza", cex = 1.5, cex.lab = 1.5, cex.axis = 1.2, bty = "l", ylim = c(12, 45), pch = c(15, 16, 17)[frags$con], col = c("red", "cornflowerblue", "aquamarine4")[frags$con])
legend(x = 60, y = 20, legend = c("baixa", "média", "alta"), title = "Conectividade", col = c("red", "cornflowerblue", "aquamarine4"), pch = c(15, 16, 17), bty = "n")
par(bty = "n", mar = c(4, 1, 1,1))
boxplot(riq ~ con, data = frags, ylim = c(12, 45), ann = FALSE, xaxt = "n", yaxt = "n", col = "gray90")
mtext(text = c("baixa", "média", "alta"), side = 1, line = 0.5, at = c(1, 2, 3), cex = 1.5)
mtext("Conectividade", side = 1, line = 2.5, cex = 1.7)
dev.off()

</code>

/*
Verifique em seu diretório de trabalho se há agora uma figura //jpg// com o nome "graficoFrags.jpg".
Agora abra um dispositivo gráfico cria arquivos com numeração sequencial, envie para ele dois gráficos e feche o dispositivo:
<code rsplus>
png("meugrafico%02d.png")
plot(riqueza~area)
boxplot(riqueza~conectada)
dev.off()
</code>
*/
<WRAP center round tip 70%>

**__Gerenciando dispositivos__**


Os dispositivos abertos são definidos por uma numeração sequencial e o seu tipo. Para gerenciar os dispositivos abertos utilizamos as funções da família ''dev.''. Além do ''dev.off'', as mais importantes são: ''dev.list'', ''dev.cur'' e ''dev.set''. O primeiro retorna o tipo e o número do dispositivo ativo, o segundo lista os dispositivos abertos enquanto o último define o dispositivo ativo. Caso necessite transitar entre dispositivos enquanto está editando é possível.
</WRAP>
 
 
/*

===== Manipulação de dispositivos gráficos=====

Feche toda as janelas de gráficos do R e execute um comando ''plot'', o que irá abrir um [[03_apostila:05a-graficos#dispositivos_graficos|dispositivo gráfico de tela]]:
<code rsplus>
plot(riqueza~area)
</code>

Agora abra um novo dispositivo gráfico de tela:

<code rsplus>
> x11()
</code>

Uma nova janela gráfica em branco se abrirá, na margem superior da qual você verá a indicação de que agora este é o dispositivo ativo, //e.g.//:

{{:03_apostila:janelas_graficas_ruindous.png?500|Duas janelas gráficas abertas no R em Windows}}

Verifique que agora o dispositivo ativo é o de número 3, e ative o dispositivo 2:
<code rsplus>
dev.cur()
dev.set(which=2)
</code>

Agora um dispositivo gráfico png e outro pdf:
<code rsplus>
png("figura%02d.png")
pdf("figura%02d.pdf")
</code>

Quantos dispositivos estão abertos? Obtenha a lista com
<code rsplus>
dev.list()
</code>

Mas apenas um está ativo, isto é, recebe a saída dos comandos gráficos. Descubra qual é com
<code rsplus>
dev.cur()
</code>

E altere para o dispositivo 3 com
<code rsplus>
dev.set(3)
dev.cur() #verificando
</code>

Agora experimente fechar dispositivos com o comando ''dev.off'':

<code rsplus>
dev.list()
dev.cur()
dev.off() # quem foi fechado?
dev.list() # verificando
dev.cur() # e quem é o ativo agora?
</code>
*/
===== Próximos passos =====

Para mais informações sobre a edição de gráficos siga para o capítulo da apostila [[03_apostila:05a-graficos|]]. 
Além disso, o tutorial [[02_tutoriais:tutorial5b:start|]] apresenta um técnica poderosa para a construção de gráficos não usuais.  

/* Nesse wiki focamos no uso das ferramentas básicas do R e nesse tutorial no pacote ''graphics'' carregado por padrão na sessão do R. O pacote para elaboração de gráficos chamado ''ggplot2'' vem se tornando muito popular nos últimos anos, mas apresenta uma sintaxe muito diferente da usual no R, o que nos parece não ser muito efetivo para o aprendizado da linguagem. Por essa razão, preferimos deixá-lo de fora do nosso material. 

Existem muitos bons tutoriais sobre o ''ggplot2'', inclusive um ótimo feito pelo colaborador da disciplina Gustavo Burin Ferreira, caso tenha interesse acesse:
  

  * [[https://blog.gburin.com/tutorial-de-ggplot2|]]
*/