Confira todos os textos da série Programação em R:
As
funções gráficas são um componente importante e extremamente
versátil do ambiente R. É possível usar as funções para
exibir uma grande variedade de gráficos estatísticos e também para
criar tipos de gráficos totalmente novos.
As funções gráficas podem ser usadas em modos interativos e em
lotes, mas, na maioria dos casos, o uso interativo é mais produtivo.
O uso interativo também é fácil porque, no momento da
inicialização, R inicia um driver de dispositivo gráfico que abre
uma janela gráfica especial para a exibição de gráficos
interativos. Embora isso seja feito automaticamente, pode ser útil
saber que o comando usado é X11() em UNIX, Windows() no Windows e
quartz() no MacOS. Um novo dispositivo sempre pode ser aberto por
dev.new().
Uma
vez que o driver do dispositivo está em execução, os comandos de
traçado de R podem ser usados para produzir uma variedade de
exibições gráficas e para criar tipos de exibição totalmente
novos.
Os
comandos são divididos em três grupos básicos:
-
As funções de traçado de alto nível criam um novo gráfico
no dispositivo gráfico, possivelmente com eixos, rótulos, títulos
e assim por diante.
-
As funções de traçado de baixo nível adicionam mais
informações a um gráfico existente, como pontos extras, linhas e
rótulos.
-
As funções de gráficos interativos permitem que você
adicione informações de forma interativa a um gráfico existente, ou
extraia informações, usando um dispositivo apontador, como um
mouse.
Além
disso, R mantém uma lista de parâmetros gráficos que podem ser
manipulados para personalizar suas parcelas.
Este
manual apenas descreve o que são conhecidos como gráficos “base”.
Um sub-sistema de gráficos separado na grade do pacote coexiste com
base – é mais poderoso, mas é mais difícil de usar.
Comandos de de alto nível
As
funções de traçado de alto nível são projetadas para gerar um
gráfico completo dos dados passados como argumentos para a função.
Quando apropriado, os eixos, rótulos e títulos são gerados
automaticamente (a menos que você solicite o contrário). Os
comandos de traçado de alto nível sempre iniciam um novo plot,
apagando o gráfico atual, se necessário.
A função plot ()
Uma
das funções de traçado mais utilizadas em R é a função plot().
Esta é uma função genérica: o tipo de gráfico produzido depende do
tipo ou classe do primeiro argumento.
plot(x, y)
plot(xy)
Se x
e y são vetores, plot(x, y) produz um diagrama de dispersão
de y contra x. O mesmo efeito pode ser produzido fornecendo um
argumento (segunda forma) como uma lista contendo dois
elementos x e y ou uma matriz de duas colunas.
plot(x)
Se x
for uma série temporal, isso produz um gráfico de séries
temporais. Se x é um vetor numérico, ele produz um gráfico dos
valores no vetor contra seu índice no vetor. Se x é um vetor
complexo, ele produz um gráfico de partes imaginárias versus partes
reais dos elementos vetoriais.
plot(f)
plot(f, y)
f é
um objeto fator, y é um vetor numérico. A primeira forma gera um
gráfico de barras de f; a segunda forma produz boxplots de y para
cada nível de f.
plot(df)
plot(~ expr)
plot(y ~ expr)
df é
um quadro de dados, y é qualquer objeto, expr é uma lista de nomes
de objetos separados por ‘+’ (por exemplo, a + b + c). As duas
primeiras formas produzem gráficos distributivos das variáveis em
um quadro de dados (primeira forma) ou de vários objetos nomeados
(segunda forma). A terceira forma traça y contra cada objeto chamado
em expr.
Exibição de dados multivariados
R
fornece duas funções muito úteis para representar dados
multivariados. Se X for uma matriz numérica ou quadro de dados, o
comando
pairs(X)
produz
uma matriz de diagrama de dispersão em pares das variáveis
definidas pelas colunas de X, ou seja, cada coluna de X é
plotada em relação a qualquer outra coluna de X e as parcelas n
(n-1) resultantes são dispostas em uma matriz com escalas de
plotagem constantes em as linhas e as colunas da matriz.
Quando
três ou quatro variáveis estão envolvidas, um coplot pode
ser mais esclarecedor. Se a e b são vetores numéricos e c é um
vetor numérico ou um objeto de fator (todo o mesmo comprimento),
então o comando
coplot(a ~ b | c)
produz
uma série de diagramas de dispersão de a contra b para valores
dados de c. Se c é um fator, isso simplesmente significa que a é
plotado contra b para cada nível de c. Quando c é numérico, é
dividido em uma série de intervalos de condicionamento e para cada
intervalo a é plotado contra b para valores de c dentro do
intervalo. O número e a posição dos intervalos podem ser
controlados com given.values = argumento para coplot () – a
função co.intervals () é útil para selecionar intervalos. Você
também pode usar duas variáveis fornecidas com um comando
como
coplot(a ~ b | c + d)
que
produz pontos de dispersão de a contra b para cada intervalo de
condicionamento conjunto de c e d.
A
função coplot () e pares () utilizam um painel de argumento = que
pode ser usado para personalizar o tipo de plot que aparece em cada
painel. O padrão é pontos () para produzir um diagrama de
dispersão, mas fornecendo algumas outras funções de gráficos de
baixo nível de dois vetores x e y como o valor do painel = você
pode produzir qualquer tipo de plot desejado. Uma função de painel
de exemplo útil para coplots é panel.smooth ().
Exibir gráficos
Outras
funções gráficas de alto nível produzem diferentes tipos de
gráficos. Alguns exemplos são:
qqnorm
(x)
qqline
(x)
qqplot
(x, y)
Parcelas
de comparação de distribuição. A primeira forma traça o vetor
numérico x contra as pontuações de ordem normal esperadas (um
gráfico de pontuação normal) e o segundo acrescenta uma linha reta
a tal traçado desenhando uma linha através da distribuição e
quartis dos dados. A terceira forma traça os quantiles de x contra
os de y para comparar suas respectivas distribuições.
hist
(x)
hist
(x, nclass = n)
hist
(x, breaks = b, …)
Produz
um histograma do vetor numérico x. Um número razoável de aulas é
geralmente escolhido, mas uma recomendação pode ser dada com o
argumento nclass =. Alternativamente, os pontos de interrupção
podem ser especificados exatamente com o break = argumento. Se a
probabilidade = argumento TRUE for dada, as barras representam
freqüências relativas divididas pela largura do compartimento em
vez das contagens.
dotchart
(x, …)
Constrói
um pontochart dos dados em x. Em um pontochart, o eixo y dá uma
rotulagem dos dados em x e o eixo x dá seu valor. Por exemplo,
permite uma seleção visual fácil de todas as entradas de dados com
valores que estão em intervalos especificados.
image (x, y, z, …)
contour (x, y, z, …)
persp
(x, y, z, …)
Parcelas
de três variáveis. O gráfico de imagem desenha uma grade de
retângulos usando cores diferentes para representar o valor de z, o
traçado de contorno desenha linhas de contorno para representar o
valor de z e o gráfico de perseguição desenha uma superfície 3D.
Argumentos para funções de alto nível
Há
uma série de argumentos que podem ser passados para funções
de gráficos de alto nível, da seguinte maneira:
add
= TRUE
Força
a função a atuar como uma função de gráficos de baixo nível,
superpondo o gráfico no gráfico atual (algumas funções somente).
axes = FALSE
Suprime
a geração de eixos – útil para adicionar seus próprios eixos
personalizados com a função axis (). O padrão, axes = TRUE,
significa incluir eixos.
log
= “x”
log
= “y”
log
= “xy”
Faz
com que os eixos x, y ou ambos sejam logarítmicos. Isso funcionará
para muitos tipos de plots, mas não todos.
type =
O argumento controla o tipo de plot produzida, da seguinte
forma:
type
= “p”
Traçar
pontos individuais (o padrão)
type
= “l”
Linhas
de traçado
tipo
= “b”
Pontos
de listagem conectados por linhas (ambos)
type
= “o”
Coloque
pontos sobrepostos por linhas
tipo
= “h”
Traçar
linhas verticais de pontos para o eixo zero (alta densidade)
tipo
= “s”
tipo
= “S”
Parcelas
de função passo a passo. Na primeira forma, o topo da vertical
define o ponto; no segundo, no fundo.
tipo
= “n”
Não
traça nada. No entanto, os eixos ainda são desenhados (por padrão)
e o sistema de coordenadas é configurado de acordo com os dados.
Ideal para criar gráficos com funções gráficas de baixo nível
subseqüentes.
xlab
= string
ylab
= corda
Etiquetas
de eixos para os eixos x e y. Use esses argumentos para alterar os
rótulos padrão, geralmente os nomes dos objetos usados na
chamada para a função de traçado de alto nível.
main
= string
Título
da figura, colocado na parte superior do plot em uma fonte grande.
sub
= string
Subtítulo,
colocado logo abaixo do eixo dos x em uma fonte menor.
Comandos de baixo nível
Às
vezes, as funções de traçado de alto nível não produzem
exatamente o tipo de plot que você deseja. Nesse caso, comandos de
traçado de baixo nível podem ser usados para adicionar
informações extras (como pontos, linhas ou texto) ao gráfico
atual.
Algumas
das funções de traçabilidade de baixo nível mais úteis são:
points
(x, y)
lines (x, y)
Adiciona
pontos ou linhas conectadas ao gráfico atual. O argumento type = do
argumento () também pode ser passado para essas funções (e padrão
para “p” para pontos () e “l” para linhas ().)
text (x, y, labels, …)
Adicione
texto a um gráfico em pontos dados por x, y. Normalmente, os rótulos
são um vetor de número inteiro ou de caracteres, em cujo caso os
rótulos [i] são plotados no ponto (x [i], y [i]). O padrão é 1:
comprimento (x).
Nota:
Esta função é freqüentemente usada na seqüência
plot (x, y, type = “n”); texto (x, y, nomes)
O
parâmetro gráfico type = “n” suprime os pontos, mas
configura os eixos, e a função text () fornece caracteres
especiais, conforme especificado pelo nome do vetor de caracteres
para os pontos.
abline
(a, b)
abline
(h = y)
abline
(v = x)
abline
(lm.obj)
Adiciona
uma linha de inclinação b e intercepta a para o gráfico atual. h =
y pode ser usado para especificar coordenadas y para as alturas de
linhas horizontais para atravessar um gráfico e v = x de forma
semelhante para as coordenadas x para linhas verticais. Também
lm.obj pode ser listado com um componente de coeficientes do
comprimento 2 (como o resultado das funções de montagem do modelo),
que são tomadas como uma interceptação e inclinação, nessa
ordem.
polígono
(x, y, …)
Desenha
um polígono definido pelos vértices ordenados em (x, y) e
(opcionalmente) faça sombra em linhas de hachura ou preencha se o
dispositivo gráfico permite o preenchimento de figuras.
legenda
(x, y, legenda, …)
Adiciona
uma legenda ao gráfico atual na posição especificada. Traçar
caracteres, estilos de linha, cores etc., são identificados com os
rótulos na legenda do vetor de caracteres. Pelo menos um outro
argumento v (um vetor com o mesmo comprimento que legenda) com os
valores correspondentes da unidade de traçado também deve ser dado,
da seguinte forma:
legenda
(, fill = v)
Cores
para caixas preenchidas
lenda
(col = v)
Cores
nas quais os pontos ou linhas serão desenhados
lenda
(lty = v)
Estilos
de linha
legenda
(, lwd = v)
Largura
de linha
lenda
(pch = v)
Traçando
caracteres (vetor de caracteres)
título
(principal, sub)
Adiciona
um título principal ao topo do gráfico atual em uma fonte grande e
(opcionalmente) um sub-título sub na parte inferior em uma fonte
menor.
eixo
(lado, …)
Adiciona
um eixo ao gráfico atual do lado dado pelo primeiro argumento (1 a
4, contando no sentido dos ponteiros do relógio da parte inferior).
Outros argumentos controlam o posicionamento do eixo dentro ou ao
lado da plot e marcam as posições e os rótulos. Útil para
adicionar eixos personalizados depois de chamar plot () com o
argumento = FALSE argumento.
As
funções de traçado de baixo nível geralmente requerem algumas
informações de posicionamento (por exemplo, coordenadas x e y) para
determinar onde colocar os novos elementos do plot. As coordenadas
são dadas em termos de coordenadas de usuário que são definidas
pelo comando anterior de gráficos de alto nível e são escolhidas
com base nos dados fornecidos.
Onde
os argumentos x e y são necessários, também é suficiente fornecer
um único argumento sendo uma lista com elementos chamados x e y. Da
mesma forma, uma matriz com duas colunas também é uma entrada
válida. Desta forma, funções como locator () (veja abaixo) podem
ser usadas para especificar posições em um gráfico de forma
interativa.
Anotações matemáticas
Em
alguns casos, é útil adicionar símbolos matemáticos e fórmulas a
um gráfico. Isso pode ser alcançado em R, especificando uma
expressão em vez de uma seqüência de caracteres em qualquer texto,
mtext, eixo ou título. Por exemplo, o código a seguir desenha a
fórmula para a função de probabilidade Binomial:
text (x, y, expressão (colar (bgroup (“(“, atop (n,
x), “)”), p ^ x, q ^ {n-x})))
Mais
informações, incluindo uma lista completa dos recursos disponíveis,
podem ser obtidas a partir de R usando os comandos:
help (plotmath)
example (plotmath)
demo (plotmath)
Fontes de vetor Hershey
É
possível especificar fontes de vetor Hershey para renderizar texto
ao usar as funções de texto e contorno. Existem três razões para
usar as fontes Hershey:
-
As fontes Hershey podem produzir uma melhor saída, especialmente na
tela do computador, para texto girado e / ou pequeno.
-
As fontes Hershey fornecem certos símbolos que podem não estar
disponíveis nas fontes padrão. Em particular, há signos do
zodíaco, símbolos cartográficos e símbolos astronômicos.
-
As fontes de Hershey fornecem caracteres cítricos e japoneses (Kana
e Kanji).
Mais
informações, incluindo tabelas de caracteres Hershey, podem ser
obtidas a partir de R usando os comandos:
help (Hershey)
demo (Hershey)
help (japanese)
demo (japanese)
Interagindo com gráficos
R
também fornece funções que permitem aos usuários extrair ou
adicionar informações a um gráfico usando um mouse. O mais simples
é a função localizador ():
localizador
(n, tipo)
Espera
que o usuário selecione locais no gráfico atual usando o botão
esquerdo do mouse. Isso continua até que n (pontos 512) sejam
selecionados ou outro botão do mouse esteja pressionado. O argumento
de tipo permite plotar nos pontos selecionados e tem o mesmo efeito
que para comandos de gráficos de alto nível; O padrão não é um
gráfico. locator () retorna as posições dos pontos selecionados
como uma lista com dois componentes x e y.
localizador
() geralmente é chamado sem argumentos. É particularmente útil
para selecionar interativamente posições para elementos gráficos,
como legendas ou rótulos quando é difícil calcular antecipadamente
onde o gráfico deve ser colocado. Por exemplo, para colocar um texto
informativo próximo a um ponto periférico, o comando
text (localizador (1), “Outlier”, adj = 0)
pode
ser útil. (o localizador () será ignorado se o dispositivo atual,
como postscript, não suporta apontar interativo.)
identify (x, y, labels)
Permita
que o usuário destaque qualquer um dos pontos definidos por x e y
(usando o botão esquerdo do mouse) traçando o componente
correspondente dos rótulos próximos (ou o número de índice do
ponto se os rótulos estiverem ausentes). Retorna os índices dos
pontos selecionados quando outro botão é pressionado.
Às
vezes, queremos identificar pontos particulares em um plot, ao
invés de suas posições. Por exemplo, talvez desejemos que o
usuário selecione alguma observação de interesse de uma exibição
gráfica e, em seguida, manipule essa observação de alguma forma.
Dado um número de coordenadas (x, y) em dois vetores numéricos x e
y, poderíamos usar a função identificador () da seguinte maneira:
plot(x, y)
identify (x, y)
As
funções identificador () não executam nenhum gráfico, mas
simplesmente permite ao usuário mover o ponteiro do mouse e clicar o
botão esquerdo do mouse perto de um ponto. Se houver um ponto
próximo ao ponteiro do mouse, ele será marcado com seu número de
índice (ou seja, sua posição nos vetores x / y) traçados nas
proximidades. Alternativamente, você pode usar uma string
informativa (como um nome de caso) como um destaque, usando o
argumento de rótulos para identificar (), ou desativar a marcação
completamente com o argumento plot = FALSE. Quando o processo é
encerrado (veja acima), identifique () retorna os índices dos pontos
selecionados; você pode usar esses índices para extrair os pontos
selecionados dos vetores originais x e y.
Usando parâmetros gráficos
Ao
criar gráficos, particularmente para fins de apresentação ou
publicação, os padrões de R nem sempre produzem exatamente o que é
necessário. No entanto, você pode personalizar quase todos os
aspectos da tela usando parâmetros gráficos. R mantém uma lista de
um grande número de parâmetros gráficos que controlam coisas como
estilo de linha, cores, arranjo de figuras e justificação de texto
entre muitos outros. Cada parâmetro gráfico tem um nome (como
‘col’, que controla as cores,) e um valor (um número de cores, por
exemplo).
Uma
lista separada de parâmetros gráficos é mantida para cada
dispositivo ativo, e cada dispositivo possui um conjunto de
parâmetros padrão quando inicializado. Os parâmetros gráficos
podem ser definidos de duas maneiras: permanentemente, afetando todas
as funções gráficas que acessam o dispositivo atual; ou
temporariamente, afetando apenas uma única chamada de função
gráfica.
•
A função par ():
•
Argumentos para funções gráficas:
Mudanças permanentes: a função par ()
A
função par () é usada para acessar e modificar a lista de
parâmetros gráficos para o dispositivo gráfico atual.
par()
Sem
argumentos, retorna uma lista de todos os parâmetros gráficos e
seus valores para o dispositivo atual.
par
(c (“col”, “lty”))
Com
um argumento de vetor de caracteres, retorna apenas os parâmetros de
gráficos nomeados (novamente, como uma lista).
par
(col = 4, lty = 2)
Com
argumentos nomeados (ou um único argumento de lista), define os
valores dos parâmetros de gráficos nomeados e retorna os valores
originais dos parâmetros como uma lista.
Definir
parâmetros gráficos com a função par () altera permanentemente o
valor dos parâmetros, no sentido de que todas as futuras chamadas
para funções gráficas (no dispositivo atual) serão afetadas pelo
novo valor. Você pode pensar em definir os parâmetros gráficos
dessa maneira, definindo valores “padrão” para os
parâmetros, que serão utilizados por todas as funções de
gráficos, a menos que seja dado um valor alternativo.
Observe
que as chamadas para par () sempre afetam os valores globais dos
parâmetros gráficos, mesmo quando o par () é chamado de dentro de
uma função. Isso geralmente é um comportamento indesejável –
geralmente queremos definir alguns parâmetros gráficos, fazer algum
planejamento e restaurar os valores originais para não afetar a
sessão R do usuário. Você pode restaurar os valores iniciais
salvando o resultado do par () ao fazer alterações e restaurar os
valores iniciais quando o plot estiver completo.
oldpar
… traçando comandos …
par (oldpar)
Para
salvar e restaurar todos os parâmetros gráficos settable25 usar
oldpar
… traçando comandos …
par (oldpar)
Alterações temporárias: Argumentos para funções gráficas
Parâmetros
gráficos também podem ser passados para (quase) qualquer
função gráfica como argumentos nomeados. Isso tem o mesmo efeito
que passar os argumentos para a função par (), exceto que as
mudanças apenas duram a duração da chamada de função. Por
exemplo:
plot (x, y, pch = “+”)
produz
um diagrama de dispersão usando um sinal de mais como o personagem
de traçado, sem alterar o caractere de traçado padrão para futuros
plots.
Infelizmente,
isso não é implementado de forma consistente e às vezes é
necessário definir e redefinir parâmetros gráficos usando par ().
Lista de parâmetros gráficos
As
seções a seguir detalham muitos dos parâmetros gráficos comumente
usados. A documentação de ajuda R para a função par () fornece um
resumo mais conciso; Isso é fornecido como uma alternativa um pouco
mais detalhada.
Os
parâmetros gráficos serão apresentados da seguinte forma:
nome
= valor
Uma
descrição do efeito do parâmetro. nome é o nome do parâmetro, ou
seja, o nome do argumento para usar em chamadas para par () ou uma
função gráfica. O valor é um valor típico que você pode usar ao
configurar o parâmetro.
Observe
que os eixos não são um parâmetro gráfico, mas um argumento para
alguns métodos de plot: veja xaxt e yaxt.
Elementos gráficos
As
parcelas R são constituídas por pontos, linhas, textos e polígonos
(regiões preenchidas). Existem parâmetros gráficos que controlam
como esses elementos gráficos são desenhados, da seguinte forma:
pch
= “+”
Caráter
a ser usado para traçar pontos. O padrão varia com os drivers de
gráficos, mas geralmente é um círculo. Os pontos tracejados tendem
a aparecer um pouco acima ou abaixo da posição apropriada, a menos
que você use “.” como o personagem de traçado, que produz
pontos centrados.
pch
= 4
Quando
pch é dado como um número inteiro entre 0 e 25 inclusive, um
símbolo de traçado especializado é produzido. Para ver quais são
os símbolos, use o comando
legend (locator (1), as.character (0:25), pch = 0:25)
Os
de 21 a 25 podem parecer duplicar símbolos anteriores, mas podem ser
coloridos de diferentes maneiras: veja a ajuda sobre pontos e seus
exemplos.
Além
disso, pch pode ser um caractere ou um número no intervalo 32: 255
representando um caractere na fonte atual.
lty
= 2
Tipos
de linha. Os estilos de linha alternativos não são suportados em
todos os dispositivos gráficos (e variam nos que o fazem), mas o
tipo de linha 1 é sempre uma linha contínua, o tipo de linha 0
sempre é invisível e os tipos de linha 2 e a seguir são linhas
pontilhadas ou tracejadas ou alguma combinação de ambos.
lwd
= 2
Largura
de linha. Largura desejada de linhas, em múltiplos da largura da
linha “padrão”. Afecta linhas de eixos, bem como linhas
desenhadas com linhas (), etc. Nem todos os dispositivos suportam
isso, e alguns têm restrições nas larguras que podem ser usadas.
col
= 2
Cores
a serem usadas para pontos, linhas, texto, regiões preenchidas e
imagens. Um número da paleta atual (veja? Paleta) ou uma cor com
nome.
col.axis
col.lab
col.main
col.sub
A
cor a ser utilizada para anotações de eixo, etiquetas x e y,
principais e subtítulos, respectivamente.
font
= 2
Um
número inteiro que especifica qual fonte usar para texto. Se
possível, os drivers do dispositivo providenciam para que 1
corresponda ao texto simples, 2 ao rosto em negrito, 3 ao itálico, 4
ao itálico em negrito e 5 à fonte do símbolo (que inclui letras
gregas).
font.axis
font.lab
font.main
font.sub
A
fonte a ser utilizada para anotações de eixo, etiquetas x e y,
principais e subtítulos, respectivamente.
adj
= -0,1
Justificação
do texto em relação à posição de traçado. 0 significa esquerda
justificativa, 1 significa justificação correta e 0,5 significa
centralizar horizontalmente sobre a posição de traçado. O valor
real é a proporção de texto que aparece à esquerda da posição
de traçado, portanto, um valor de -0,1 deixa um intervalo de 10% da
largura do texto entre o texto e a posição de traçado.
cex
= 1,5
Expansão
do caráter. O valor é o tamanho desejado de caracteres de texto
(incluindo caracteres de traçado) em relação ao tamanho de texto
padrão.
cex.axis
cex.lab
cex.main
cex.sub
A
expansão do caractere a ser usada para anotações de eixo,
etiquetas x e y, principais e subtítulos, respectivamente.
Eixos e marcações
Muitas
das parcelas de alto nível de R têm eixos, e você pode construir
os eixos com a função de gráficos de eixo de baixo nível (). Os
eixos possuem três componentes principais: a linha de eixo (estilo
de linha controlada pelo parâmetro de gráficos de lty), as marcas
de marcação (que marcam as divisões da unidade ao longo da linha
de eixo) e as marcas de marca (que marcam as unidades). Esses
componentes podem ser personalizados com os seguintes parâmetros
gráficos.
lab
= c (5, 7, 12)
Os
dois primeiros números são o número desejado de intervalos de
tiques nos eixos x e y, respectivamente. O terceiro número é o
comprimento desejado de rótulos de eixos, em caracteres (incluindo o
ponto decimal). Escolher um valor muito pequeno para este parâmetro
pode resultar em todos os rótulos sendo arredondados para o mesmo
número!
las
= 1
Orientação
dos rótulos dos eixos. 0 significa sempre paralelo ao eixo, 1
significa sempre horizontal e 2 significa sempre perpendicular ao
eixo.
mgp
= c (3, 1, 0)
Posições
dos componentes do eixo. O primeiro componente é a distância da
etiqueta do eixo para a posição do eixo, nas linhas de texto. O
segundo componente é a distância para as marcas de tiques e o
componente final é a distância da posição do eixo para a linha do
eixo (geralmente zero). Os números positivos medem fora da região
do plot, números negativos dentro.
tck
= 0,01
Comprimento
das marcações, como uma fração do tamanho da região de traçado.
Quando tck é pequeno (menos de 0,5), as marcas de marcação nos
eixos x e y são forçadas a ter o mesmo tamanho. Um valor de 1
fornece linhas de grade. Os valores negativos dão marcações fora
da região de traçado. Use tck = 0,01 e mgp = c (1, -1,5,0) para
marcações internas.
xaxs
= “r”
yaxs
= “i”
Estilos
de eixos para os eixos x e y, respectivamente. Com os estilos “i”
(interno) e “r” (o padrão), as marcas sempre ficam dentro
do alcance dos dados, no entanto, o estilo “r” deixa uma
pequena quantidade de espaço nas bordas. (S tem outros estilos não
implementados na R.)
Figura margens
Um
único gráfico em R é conhecido como uma figura e compreende uma
região de plot cercada por margens (possivelmente contendo rótulos
de eixos, títulos, etc.) e (geralmente) delimitada pelos próprios
eixos.
Uma
figura típica é
Os
parâmetros gráficos que controlam o layout da figura incluem:
mai
= c (1, 0,5, 0,5, 0)
Largura
das margens inferior, esquerda, superior e direita, respectivamente,
medida em polegadas.
mar
= c (4, 2, 2, 1)
Semelhante
ao mai, exceto que a unidade de medição é linhas de texto.
mar
e mai são equivalentes no sentido de que definir um altera o valor
do outro. Os valores padrão escolhidos para este parâmetro
geralmente são muito grandes; a margem direita raramente é
necessária e nem a margem superior se não é usado o título. As
margens inferior e esquerda devem ser grandes o suficiente para
acomodar o eixo e marcar marcas. Além disso, o padrão é escolhido,
independentemente do tamanho da superfície do dispositivo: por
exemplo, usando o driver postscript () com o argumento altura = 4
resultará em um gráfico que é cerca de 50% de margem a menos que
mar ou mai sejam definidos explicitamente. Quando várias figuras
estão em uso (veja abaixo), as margens são reduzidas, porém isso
pode não ser suficiente quando muitas figuras compartilham a mesma
página.
Ambiente figurativo múltiplo
R
permite que você crie uma série de figuras n em uma única página.
Cada figura tem suas próprias margens, e a matriz de figuras é
opcionalmente cercada por uma margem externa, conforme mostrado na
figura a seguir.
Os
parâmetros gráficos relativos a múltiplas figuras são os
seguintes:
mfcol
= c (3, 2)
mfrow
= c (2, 4)
Defina
o tamanho de uma matriz de múltiplas figuras. O primeiro valor é o
número de linhas; O segundo é o número de colunas. A única
diferença entre esses dois parâmetros é que a configuração de
mfcol faz com que as figuras sejam preenchidas por coluna; Mfrow é
preenchido por linhas.
O
layout na Figura poderia ter sido criado definindo mfrow = c (3,2); A
figura mostra a página depois que quatro parcelas foram desenhadas.
Definir
qualquer destes pode reduzir o tamanho da base de símbolos e texto
(controlado por par (“cex”) e o ponto do dispositivo). Em
um layout com exatamente duas linhas e colunas, o tamanho da base é
reduzido por um fator de 0.83: se houver três ou mais linhas ou
colunas, o fator de redução é 0.66.
mfg
= c (2, 2, 3, 2)
Posição
da figura atual em um ambiente de figura múltipla. Os dois primeiros
números são a linha e a coluna da figura atual; os dois últimos
são o número de linhas e colunas na matriz de figuras múltiplas.
Defina este parâmetro para saltar entre figuras na matriz. Você
pode usar valores diferentes para os últimos dois números do que os
valores reais para figuras de tamanho desigual na mesma página.
fig
= c (4, 9, 1, 4) / 10
Posição
da figura atual na página. Os valores são as posições das margens
esquerda, direita, inferior e superior, respectivamente, como uma
porcentagem da página medida a partir do canto inferior esquerdo. O
valor do exemplo seria para uma figura no canto inferior direito da
página. Defina este parâmetro para posicionamento arbitrário de
figuras dentro de uma página. Se você quiser adicionar uma figura a
uma página atual, use novo = VERDADEIRO também (diferente de S).
oma
= c (2, 0, 3, 0)
omi
= c (0, 0, 0,8, 0)
Tamanho
das margens exteriores. Como mar e mai, as primeiras medidas em
linhas de texto e a segunda em polegadas, começando com a margem
inferior e trabalhando no sentido horário.
As
margens externas são particularmente úteis para títulos em página,
etc. O texto pode ser adicionado às margens externas com a função
mtext () com o argumento externo = VERDADEIRO. Não há margens
externas por padrão, no entanto, você deve criá-las explicitamente
usando oma ou omi.
Arranjos
mais complicados de figuras múltiplas podem ser produzidos pelas
funções split.screen () e layout (), bem como pelos pacotes de
grade e rede.
Controladores de dispositivo
R
pode gerar gráficos (de diferentes níveis de qualidade) em quase
qualquer tipo de dispositivo de exibição ou impressão. Antes que
isso possa começar, no entanto, R precisa ser informado sobre o tipo
de dispositivo com o qual ele está lidando. Isso é feito iniciando
um driver de dispositivo. O propósito de um driver de dispositivo é
converter instruções gráficas de R (“desenhar uma linha”,
por exemplo) em uma forma que o dispositivo particular possa
entender.
Os
drivers do dispositivo são iniciados chamando uma função de driver
de dispositivo. Há uma dessas funções para cada driver de
dispositivo: digite help (Dispositivos) para uma lista de todos eles.
Por exemplo, emitir o comando
postscript ()
faz
com que toda a saída gráfica futura seja enviada para a impressora
no formato PostScript. Alguns drivers de dispositivos comumente
usados são:
X11
()
Para
usar com o sistema windows X11 no Unix-alikes
Windows()
Para
uso no Windows
quartz()
Para
uso no MacOS
postscript
()
Para
imprimir em impressoras PostScript ou criar arquivos de gráficos
PostScript.
pdf
()
Produz
um arquivo PDF, que também pode ser incluído em arquivos PDF.
png
()
Produz
um arquivo PNG bitmap. (Não está sempre disponível: veja a página
de ajuda.)
jpeg
()
Produz
um arquivo bitmap JPEG, melhor usado para gráficos de imagens. (Não
está sempre disponível: veja a página de ajuda.)
Quando
você terminar com um dispositivo, certifique-se de encerrar o driver
do dispositivo, emitindo o comando
dev.off ()
Isso
garante que o dispositivo finalize de forma limpa; Por exemplo, no
caso de dispositivos impressos, isso garante que todas as páginas
sejam preenchidas e enviadas para a impressora. (Isso acontecerá
automaticamente no final normal de uma sessão.)
Diagramas PostScript para documentos de composição
Ao
passar o argumento do arquivo para a função de driver do
dispositivo postscript (), você pode armazenar os gráficos no
formato PostScript em um arquivo de sua escolha. O gráfico será na
orientação horizontal, a menos que o argumento horizontal = FALSO
seja dado, e você pode controlar o tamanho do gráfico com os
argumentos de largura e altura (o gráfico será dimensionado
conforme apropriado para ajustar essas dimensões). Por exemplo, o
comando
postscript (“file.ps”, horizontal = FALSE, height =
5, pointize = 10)
irá
produzir um arquivo contendo código PostScript para uma figura de
cinco centímetros de altura, talvez para inclusão em um documento.
É importante notar que, se o arquivo nomeado no comando já existir,
ele será substituído. Este é o caso mesmo se o arquivo só foi
criado anteriormente na mesma sessão R.
Muitos
usos da saída PostScript serão para incorporar a figura em outro
documento. Isso funciona melhor quando o PostScript encapsulado é
produzido: R sempre produz saída compatível, mas apenas marca a
saída como tal quando o argumento onefile = FALSE é fornecido. Esta
notação incomum decorre da compatibilidade com S: isso realmente
significa que a saída será uma única página (que faz parte da
especificação EPSF). Assim, para produzir um plot para inclusão
use algo como
postscript (“plot1.eps”, horizontal = FALSE, onefile =
FALSE,
altura = 8, largura = 6, ponto = 10)
Múltiplos dispositivos gráficos
No
uso avançado de R, muitas vezes é útil ter vários dispositivos
gráficos em uso ao mesmo tempo. É claro que apenas um dispositivo
gráfico pode aceitar comandos gráficos em qualquer momento e isso é
conhecido como o dispositivo atual. Quando vários dispositivos estão
abertos, eles formam uma seqüência numerada com nomes que dão o
tipo de dispositivo em qualquer posição.
Os
comandos principais usados para operar com vários dispositivos
e seus significados são os seguintes:
X11
()
[UNIX]
Windows()
win.printer
()
win.metafile
()
[Windows]
quartz()
[Mac
OS]
postscript
()
pdf
()
png
()
jpeg
()
tiff
()
bitmap
()
…
Cada
nova chamada para uma função de driver de dispositivo abre um novo
dispositivo gráfico, estendendo-se por um a lista de dispositivos.
Este dispositivo torna-se o dispositivo atual, ao qual a saída
gráfica será enviada.
dev.list
()
Retorna
o número eo nome de todos os dispositivos ativos. O dispositivo na
posição 1 na lista é sempre o dispositivo nulo que não aceita
comandos gráficos.
dev.next
()
dev.prev
()
Retorna
o número e o nome do dispositivo gráfico próximo ou anterior ao
dispositivo atual, respectivamente.
dev.set
(which = k)
Pode
ser usado para alterar o dispositivo de gráficos atual para aquele
na posição k da lista de dispositivos. Retorna o número eo rótulo
do dispositivo.
dev.off
(k)
Terminar
o dispositivo gráfico no ponto k da lista de dispositivos. Para
alguns dispositivos, como os dispositivos postscript, isso imprime o
arquivo imediatamente ou complete corretamente o arquivo para
posterior impressão, dependendo de como o dispositivo foi iniciado.
dev.copy
(dispositivo, …, que = k)
dev.print
(dispositivo, …, que = k)
Faça
uma cópia do dispositivo k. Aqui o dispositivo é uma função de
dispositivo, como postscript, com argumentos extras, se necessário,
especificado por ‘…’. o dev.print é semelhante, mas o dispositivo
copiado é imediatamente fechado, de modo que as ações finais, como
a impressão de cópias impressas, são executadas imediatamente.
graphics.off
()
Terminar
todos os dispositivos gráficos na lista, exceto o dispositivo nulo.
Gráficos dinâmicos
R
não possui recursos internos para gráficos dinâmicos ou
interativos, p. nuvens de ponto rotativo ou pontos de “escovação”
(destacando interativamente). No entanto, extensas funções gráficas dinâmicas estão disponíveis no sistema GGobi da Swayne,
Cook e Buja disponíveis a partir de
e
estes podem ser acessados a partir de R através do pacote
rggobi, descrito em http://www.ggobi.org/rggobi.
Além
disso, o pacote rgl fornece formas de interagir com gráficos 3D, por
exemplo, de superfícies.
Além disso, ferramentas como o
Vengage permitem criar vários tipos de (info)gráficos.
Conclusão
Chegamos ao final desta série, e espero sinceramente que tenha aproveitado bastante os conhecimentos compartilhados aqui.
Ficou com alguma dúvida?
Tem interesse em treinamentos em R?
