-
Notifications
You must be signed in to change notification settings - Fork 2
/
Copy path05-funcoes_graficas.Rmd
1461 lines (1094 loc) · 52.2 KB
/
05-funcoes_graficas.Rmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# Funções gráficas {#func-graf}
## Dispositivos Gráficos
Existem dois principais tipos de **dispositivos (Devices) gráficos** no R que basicamente significam onde você imprimirá um gráfico ou figura.
Isso pode ocorrer:
* Na tela do computador (monitor), ou seja, em janelas do R ou do RStudio onde você visualiza gráficos;
* Em um arquivo em formato `.pdf`, `.jpeg`, `.tiff`, `.png`, `.eps` etc.
### Função `plot()`
A função `plot()` (ou `plot.default()`) é a principal função genérica para gerar gráficos no R.
Veremos isso com mais detalhes na seção [Funções gráficas de alto nível](#graf-alto-nivel).
Aqui demonstraremos o uso da função simplificadamente para facilitar as demais explicações.
Entenda que geramos gráficos com essa função.
Vamos a um exemplo muito simples:
```{r, cache = TRUE}
# o objeto R do iris como exemplo
str(iris)
# plotando comprimento de sépala vs. comprimento de pétalas e colorindo os pontos de acordo com as espécies
vcl <- c("yellow", "green", "blue")[as.numeric(iris$Species)] # cria um vetor de cores para cada linha em Iris segundo especie
# plota a figura
plot(iris$Sepal.Length, iris$Petal.Length, type = "p", pch = 21, bg = vcl, cex = 0.8)
```
Muitos argumentos da função `plot()` são parâmetros gráficos (Seções \@ref(par-graficos-p1) e \@ref(par-graficos-p2)).
### Dispositivos de Tela
Quando você usa funções para gerar um gráfico, o R ou RStudio usa automaticamente um dispositivo de tela.
No entanto, você pode abrir novas janelas com as seguintes funções:
* `X11()` ou `x11()` funcionam no Mac, Linux e Windows;
* `quartz()` funciona apenas no Mac;
* `windows()` funciona apenas no Windows.
```{r, opts.label='evalF'}
?device # veja o help da função e as opções de devices
X11() # irá abrir uma janela nova
# vamos plotar o mesmo gráfico do exercício anterior
vcl <- c("yellow", "green", "blue")[as.numeric(iris$Species)] # cria um vetor de cores para cada linha em Iris segundo especie
# plota a figura
plot(iris$Sepal.Length, iris$Petal.Length, type = "p", pch = 21, bg = vcl, cex = 0.8)
# irá fechar essa nova janela
dev.off()
quartz() # num mac abre uma janela sem dar nenhum aviso (funciona melhor que X11() no Mac)
vcl <- c("yellow", "green", "blue")[as.numeric(iris$Species)] # cria um vetor de cores para cada linha em Iris segundo especie
# plota a figura
plot(iris$Sepal.Length, iris$Petal.Length, type = "p", pch = 21, bg = vcl, cex = 0.8)
dev.off() # fecha
```
### Listar e controlar dispositivos
Existem funções que permitem trabalhar com vários dispositivos ao mesmo tempo, controlando o uso dos dispositivos abertos.
Pode haver, por exemplo, várias janelas diferentes mostrando gráficos diferentes durante um trabalho.
As principais funções para trabalhar com dispositivos são:
* A função `dev.list()`lista todos os dispositivos abertos no momento (geralmente o dispositivo padrão, que é sempre o número 1, é ignorado na lista), retornando o número (ordem de abertura) e o nome de cada um;
* `dev.cur()` mostra qual o dispositivo que está ativo (em inglês, *current*). Se há vários abertos, haverá sempre um que estará ativo naquele momento e se você enviar uma figura, ela sairá neste dispositivo;
* `dev.set()` torna ativo um determinado dispositivo;
* `dev.off()` fecha o dispositivo atual ou vários. Esta é a função dessa lista que é a mais usada na prática.
```{r, opts.label='evalF'}
# vamos primeiro fechar todos os dispositivos
dev.off(which = dev.list())
dev.list() # vai retornar NULL por não há dispositivos abertos
# vamos abrir vários dispositivos
X11() # primeira janela extra
X11() # segunda janela e mesma figura com cores diferentes
X11() # terceira janela e mesma figura com cores diferentes
# coloque e redimensione as janelas para ter as tres visiveis na tua tela e volte aqui.
# veja os dispositivos abertos
dev.list()
# qual o atual
dev.cur() # o ultimo que abrimos, né
dev.set(2)
# vamos mudar para o segundo e plotar algo
plot(iris$Sepal.Length, iris$Petal.Length, type = "p", cex = 0.8)
# vamos mudar para o terceiro e plotar outra coisa
dev.set(3)
dev.cur() # deve responder 3
vcl <- c("yellow", "green", "blue")[as.numeric(iris$Species)]
plot(iris$Sepal.Length, iris$Petal.Length, type = "p", pch = 21, bg = vcl, cex = 0.8)
# vamos mudar para o quarto e plotar a mesma coisa com outras cores
dev.set(4)
dev.cur() # deve responder 4
vcl <- c("red", "blue", "white")[as.numeric(iris$Species)]
plot(iris$Sepal.Length, iris$Petal.Length, type = "p", pch = 21, bg = vcl, cex = 0.8)
# vamos fechar o dispositivo atual
dev.cur()
dev.off()
dev.cur() # mudou automaticamente porque voce fechou o 4
dev.off() # mesma coisa fechou o ativo
dev.cur() # sobrou o 3
# fechar este também
dev.off()
dev.list() # nao tem mais nenhum aberto
```
### Dispositivos de arquivos
Há vários dispositivos para gerar arquivos com imagens.
As funções em geral têm o nome do tipo de arquivo gerado.
Vamos ver dois exemplos apenas, mas a mesma lógica se aplica a qualquer um dos dispositivos listados no `?` dos dispositivos (execute o comando `help('device')` e veja a explicação sobre os dispositivos (*devices*)).
Essas funções são ótimas ferramentas para incluir nos seus scripts visando a produção de figuras para uma publicação.
Procure na revista em que você deseja publicar seu artigo as especificações técnicas das figuras.
Em seguida, cheque os parâmetros das funções gráficas (Seções \@ref(par-graficos-p1) e \@ref(par-graficos-p2)) para você ser capaz de gerar figuras na especificação exata da revista selecionada.
### Figuras vetoriais em `pdf` ou `postscript`
Em nossa opinião, as funções `pdf()` e `postscript()` são as mais importantes para a geração de figuras, porque elas geram arquivos de excelente qualidade por serem vetoriais.
Não há a necessidade de se definir a resolução, porque nesse tipo de imagem isso não existe.
```{r, cache = TRUE}
# plotando a figura na tela é o que fazemos normalmente
vcl <- c("yellow", "green", "blue")[as.numeric(iris$Species)]
plot(iris$Sepal.Length, iris$Petal.Length, type = "p", pch = 21, bg = vcl, cex = 0.8)
```
```{r, opts.label='evalF'}
# salvando a figura num PDF
?pdf # veja o help dessa função e seus argumentos, especialmente width e height
# abre o dispositivo para pdf
pdf(file = "meupdf.pdf", width = lcm(15), height = lcm(10))
# lcm() apenas pega valores em cm e converte em polegadas que é a especificação padrão da funcao pdf. Portanto largura e altura de cada página do PDF é definida por esses argumentos
# plota a figura
plot(iris$Sepal.Length, iris$Petal.Length, type = "p", pch = 21, bg = vcl, cex = 0.8)
dev.off() # fecha o pdf
# só será possível ver o pdf se tiver fechado ele.
getwd() # o pdf foi gerado nessa pasta
# se voce incluir vários gráficos. O pdf irá gerar várias páginas ao mesmo tempo.
# abre o dispositivo para pdf
pdf(file = "meupdf2.pdf", paper = "a4")
# tamanho papel A4
# plota a figura 10 vezes
for (i in 1:10) {
plot(iris$Sepal.Length, iris$Petal.Length, type = "p", pch = 21, bg = vcl, cex = 0.8)
}
dev.off() # fecha o pdf
# veja que o arquivo 2 tem várias páginas
```
### Figuras raster
As funções `jpeg()`, `png()` e `tiff()` geram imagens em pixels, cuja qualidade depende muito da definição da resolução.
```{r, opts.label='evalF'}
# formato jpeg sem controlar a resolucao (usando units='px' ou pixel)
# abre o dispositivo no formato desejado
jpeg(filename = "meujpeg.jpg", width = 600, height = 400, units = "px")
# plota alguma coisa
vcl <- c("yellow", "green", "blue")[as.numeric(iris$Species)]
plot(iris$Sepal.Length, iris$Petal.Length, type = "p", pch = 21, bg = vcl, cex = 0.8)
# fecha o jpeg
dev.off()
# ABRA O ARQUIVO E FAÇA UM ZOOM GRANDE
# note que os pixels são super visíveis
# AGORA MELHORANDO A RESOLUCAO
# formato jpeg com 300dpi
# abre o dispositivo no formato desejado
jpeg(filename = "meujpeg2.jpg", width = 15, height = 10, units = "cm", res = 300)
# plota alguma coisa
vcl <- c("yellow", "green", "blue")[as.numeric(iris$Species)]
plot(iris$Sepal.Length, iris$Petal.Length, type = "p", pch = 21, bg = vcl, cex = 0.8)
# fecha o jpeg
dev.off()
```
```{block, type = "rmdidea"}
DICA: Abra os três arquivos e compare a resolução deles, ampliando a imagem até visualizar o pixel.
Note que em um `pdf` você nunca verá o pixel.
Por isso, recomendamos que vocÊ trabalhe sempre com a função `pdf()`.
```
## Parâmetros gráficos, parte I - Margem, fonte, proporções {#par-graficos-p1}
Para fazer boas figuras no R, você precisa muitas vezes controlar **parâmetros gráficos dos dispositivos**, como margem da figura, tamanho de fonte, tipo da fonte, distância das legendas dos eixos x e y, se essas legendas são horizontais ou verticais, o tipo símbolos dos pontos, as cores dos simbolos etc.
Você pode definir esses parâmetros diretamente nas funções gráficas de alto-nível `highlevel plot> (..., <tag> = <value>)`, onde um valor (value) de um parâmetro (tag) pode ser adicionado diretamente como argumento de uma função de alto-nível.
Alguns desses parâmetros, no entanto, só podem ser definidos através da função `par()`, que também define **parâmetros gráficos globais**, isto é, se você alterar os parâmetros através dessa função, isso será alterado para todos os gráficos que forem abertos posteriormente durante a mesma sessão do R.
Esta mesma função também permite visualizar os parâmetros gráficos.
Leia atentamente o `?` da função [`par()`](http://stat.ethz.ch/R-manual/R-devel/library/graphics/html/par.html).
Você pode salvar os parâmetros globais antes de alterá-los.
```{r, opts.label='evalF'}
?par # veja o help dessa função
```
```{r, cache = TRUE}
# você pode ver os parâmetros padrão:
par() # vejo todos os parâmetros
op <- par() # pego todos os parâmetros
class(op) # isso é uma lista
names(op) # esses são os nomes dos parâmetros
# a função par permite ver os valores atualmente definidos
par("family") # tipo de fonte nao tem
par("mar") # margens da figura em número de linhas
# a função para tem apenas 1 argumento além dos parâmetros gráficos
op2 <- par(no.readonly = TRUE)
class(op2)
# a diferença entre especificar no.readonly como verdadeiro (na primeria opção não especificada acima, o padrão é FALSE)
# é que a lista gerada pode ser usada para refazer alterações, ou seja, para resgatar os parâmetros gráficos padrão.
# ou seja, posso fazer:
par(op2) # para resgatar valores originais
```
```{r, opts.label='evalF'}
# mas não posso fazer o mesmo com a primeira opção
par(op) # porque op é uma lista diferente
```
```{r}
length(op) == length(op2) # tem comprimentos diferentes
identical(op, op2) # nao são identicas
```
### Margem da figura
```{r, cache = TRUE}
# Usando novamente o exemplo de iris
Sepalas <- iris$Sepal.Length
Petalas <- iris$Petal.Length
# especies como números
spp <- as.numeric(as.factor(iris$Species))
# uma cor para cada espécie
vcl <- c("yellow", "green", "blue")[spp]
# um simbolo para cada espécie
sbs <- c(21, 22, 23)[spp]
# plota a figura no dispositivo padrão
plot(Sepalas,
Petalas,
pch = sbs,
bg = vcl,
cex = 0.8
)
# ALTERANDO A MARGEM em NUMEROS DE LINHAS
# salva o valor padrao para resgatar ao final
op <- par(no.readonly = TRUE)
op$mar # esses são os valor atuais para Margem Inferior, Esquerda, Superior e Direita, respectivamente. #quando se referir a margem todos os parâmetros seguem a ordem ANTI-HORÁRIA iniciando na margem inferior
# reduzindo as margem direita e superior em número de linhas
par(mar = c(5, 4, 1, 0.5))
plot(Sepalas,
Petalas,
pch = sbs,
bg = vcl,
cex = 0.8
)
# voltando ao original
par(mar = op$mar)
```
### Aspecto dos eixos
```{r, opts.label='evalF'}
op <- par(no.readonly = TRUE)
# POSICAO DAS LEGENDAS DOS EIXOS
par("mgp") # três valores que correspondem ao número de linhas para: (1) Titulo dos Eixos; (2) valores dos eixos; (3) linha dos eixos
# TAMANHO DE FONTE DOS EIXOS É RELATIVO AO VALOR DE FONTE PADRÃO
par("cex") # tamanho padrão
par("cex.lab") # número que multiplicado por op$cex indica o valor da fonte dos títulos dos eixos
par("cex.axis") # dos valores
# TAMANHO DAS BARRAS DE CADA VALOR
par("tck") # geralmente não tem padrão definido pois é extraído de outros valores automaticamente, mas você pode controlar isso
# DIMINUINDO A FONTE DISSO
par(cex.lab = 0.8, cex.axis = 0.7)
plot(Sepalas, Petalas, pch = sbs, bg = vcl, cex = 0.8)
# note que isso muda se eu alterar o tamanho de fonte padrão par(cex)
par(cex = 2, cex.lab = 0.8, cex.axis = 0.7)
plot(Sepalas, Petalas, pch = sbs, bg = vcl, cex = 0.8)
# APROXIMANDO
par(mgp = c(1.5, 0.5, 0))
plot(Sepalas, Petalas, pch = sbs, bg = vcl, cex = 0.8)
# e agora
par(tck = -0.01) # note o valor negativo
plot(Sepalas, Petalas, pch = sbs, bg = vcl, cex = 0.8)
par(tck = 0.01) # se colocar positivo
plot(Sepalas, Petalas, pch = sbs, bg = vcl, cex = 0.8)
par(op) # restaurando valores originais
plot(Sepalas, Petalas, pch = sbs, bg = vcl, cex = 0.8)
```
### Proporção dos eixos
```{r, cache = TRUE}
op <- par(no.readonly = TRUE)
par("pty") # valor "m" maximiza a area disponível
plot(Sepalas, Petalas, pch = sbs, bg = vcl, cex = 0.8)
# agora mantendo a proporção dos eixos (sem esticar nenhum dos dois)
par(pty = "s")
plot(Sepalas, Petalas, pch = sbs, bg = vcl, cex = 0.8)
# se não notou diferença, expandir o dispositivo onde está desenhando a figura
```
### Múltiplas figuras na mesma tela ou página com `mfrow()` e `mfcol()`
Você pode colocar diferentes gráficos na mesma tela ou na mesma página de um pdf, por exemplo. Temos duas formas de fazer isso.
Os parâmetros `mfrow` e `mfcol` dividem os dispositivo em células de tamanhos idênticos.
Todas as figuras terão o mesmo tamanho.
A diferença entre os dois parâmetros é que `mfrow()` preenche o espaço por linhas, enquanto `mfcol()` preenche o espaço pelas colunas.
```{r, cache = TRUE}
par(op)
par("mfrow") # o dispositivo não está divido: tem 1 linha e 1 coluna
plot(Sepalas, Petalas, pch = sbs, bg = vcl, cex = 0.8)
# EXEMPLO 1
# duas figuras no mesmo dispositivo
par(mfrow = c(1, 2)) # dividir o dispositivo em 1 linha e duas colunas
# plota a primeira figura
plot(Sepalas, Petalas, pch = sbs, bg = vcl, cex = 0.8)
# plota a segunda sem cores
plot(Sepalas, Petalas, pch = sbs, bg = NULL, cex = 0.8)
# EXEMPLO 2
par(mar = c(5.1, 4.1, 2.1, 2.1))
par(mfrow = c(2, 2)) # dividir o dispositivo em 2 linha e duas colunas
# plota quatro figuras identificas
for (f in 1:4) {
plot(Sepalas, Petalas, pch = sbs, bg = NULL, cex = 0.8)
# adiciona uma letra para você ver a ordem e comparar com o exemplo 3
mtext(LETTERS[f], side = 3, line = 0, adj = 0, font = 2, col = "red") # esta é uma função de baixo nível que falaremos depois
}
# EXEMPLO 3
par(mfcol = c(2, 2)) # mesma coisa mas preenchendo por colunas (compare com a figura acima)
for (f in 1:4) {
plot(Sepalas, Petalas, pch = sbs, bg = NULL, cex = 0.8)
mtext(LETTERS[f], side = 3, line = 0, adj = 0, font = 2, col = "red")
}
```
```{r, opts.label='evalF'}
# colocando exemplo 2 e 3 num pdf
pdf(file = "meuPDFmfrow.pdf", paper = "a4")
# EXEMPLO 2 expandido
par(mfrow = c(3, 2)) # tres linhas e duas colunas
for (f in 1:6) {
plot(Sepalas, Petalas, pch = sbs, bg = NULL, cex = 0.8)
mtext(LETTERS[f], side = 3, line = 0, adj = 0, font = 2, col = "red")
}
# EXEMPLO 3 expandido
par(mfcol = c(3, 2))
for (f in 1:6) {
plot(Sepalas, Petalas, pch = sbs, bg = NULL, cex = 0.8)
mtext(LETTERS[f], side = 3, line = 0, adj = 0, font = 2, col = "red")
}
dev.off()
```
### Múltiplas figuras na mesma image usando a função `layout()`
A função `layout()` também permite dividir um dispositivo para múltiplas figuras, mas de uma forma muito mais complexa.
```{r, opts.label='evalF'}
?layout # veja o help dessa função
# voce precisa definir uma matriz que indica:
# 1) o numero de figuras (valores da matriz)
# 2) a posição das figuras (numero de linhas e colunas)
# por exemplo, suponha que queremos plotar 3 figuras:
# 1 preenchendo a largura da página e metade da altura
# 2 outras figuras preenchendo a outra metada da altura
```
```{r, opts.label='evalF'}
# neste caso a figura 1 ira ocupar dois espacos
mm <- matrix(c(1, 1, 2, 3), nrow = 2, ncol = 2, byrow = T)
mm # a figura 1 irá ocupar a posicao do numero 1 na matriz
# a figura 2 irá ocupar a posicao do numero 2 nessa matriz
# a figura 3 irá ocupar a posicao do numero 3 dessa matriz
# a largura de cada coluna e linha é especificada pelos argumentos widths e heights e usaremos a função lcm() para especificar isso em centímetros
# divide o dispositivo
ml <- layout(mm, widths = rep(lcm(5), ncol(mm)), heights = rep(lcm(5), nrow(mm)))
# mostra a divisao feita
layout.show(ml)
# plota a primeira figura
plot(Sepalas, Petalas, pch = sbs, bg = vcl, cex = 0.8)
# a segunda
plot(Sepalas, Petalas, pch = sbs, bg = vcl, cex = 0.8)
# a terceira
plot(Sepalas, Petalas, pch = sbs, bg = vcl, cex = 0.8)
```
Podemos salvar essas figuras em um `pdf`:
```{r, opts.label='evalF'}
pdf(file = "meuPDFlayout.pdf", paper = "letter")
layout(mm, widths = rep(lcm(8), ncol(mm)), heights = rep(lcm(8), nrow(mm)))
# plota as tres figuras fazendo uma iteracao
for (f in 1:3) {
plot(Sepalas, Petalas, pch = sbs, bg = NULL, cex = 0.8)
mtext(LETTERS[f], side = 3, line = 0, adj = 0, font = 2, col = "red")
}
dev.off() # fecha o pdf
```
## Parâmetros gráficos, parte II - Símbolos e cores {#par-graficos-p2}
Você pode fazer o que quiser na produção de um gráfico no R.
Isso requer conhecer bem os parâmetros gráficos que já apresentamos de forma geral anteriormente (ver seção \@ref(par-graficos-p1)).
Aqui apresentamos alguns parâmetros de uso comum pelas funções gráficas de alto (Seção \@ref(graf-alto-nivel)) e baixo nível (seção \@ref(graf-baixo-nivel)), que definem símbolos e cores.
Você viu isso se leu o `?` da função `par()` e entendeu o que ela faz.
Em gráficos de dispersão e/ou na necessidade de colocar qualquer símbolo em um gráfico qualquer, precisamos saber como definir símbolos, suas cores e seus tamanhos.
Os parâmetros gráficos que fazem isso são principalmente os seguintes:
* `pch` - define o tipo de símbolo para pontos;
* `lty` - define o tipo de símbolo para linhas;
* `col` e `bg` - respectivamente definem a cor de linhas e o "recheio" do ponto de símbolos, gráficos, polígonos etc;
* `cex` - define o tamanho de símbolos e texto;
* `lwd` - espessura das linhas.
### Tipo de símbolo - `pch`
Nós queremos símbolos, em geral, para adicionar em um gráfico os pontos referentes às nossas unidades amostrais.
Portanto, esse tipo de símbolo no R é chamado de `points`, e já vimos a função de baixo-nível `points()`, que depende desse argumento ou parâmetro.
O argumento `pch` pode ser um número^[Valores do argumento `pch` variam de 0 a 25; veja o `?` da função `points()` para saber quais são esses símbolos], que especifica um símbolo, ou símbolos de um único caractere [e.g. `c("A", "*","&", "?")`].
```{r, opts.label='evalF'}
# veja o definido como parâmetro global
par("pch")
# o que isso quer dizer?
# vamos usar a função example()
?example # se quiser saber o que isso faz
# quando digitar o comando abaixo,
# vai precisar RESPONDER NO CONSOLE para prosseguir.
example("points")
# pare na terceira figura que esse exemplo gera.
par("pch") # este valor corresponde ao símbolo nessa figura.
# note que os símbolos de 21:25 permitem definir cor de linha e de recheiro, os demais apenas uma única cor
```
```{r, cache = TRUE}
# vamos gerar alguns exemplos com os dados de iris
class(iris)
dim(iris)
colnames(iris)
# com a definicao padrão de pch
par("pch")
Sepalas <- iris$Sepal.Length
Petalas <- iris$Petal.Length
plot(Sepalas, Petalas)
# colocando todas com um único símbolo diferente
plot(Sepalas, Petalas, pch = 25)
# colocando cada espécie com um único símbolo
# neste caso o argumento pch deve ter um vetor do número de linhas em iris, se for menor, pela regra da reciclagem, ele irá repetir os símbolo sem estar relacionado à coluna Species, que define qual linha é de qual espécie.
# então se eu definir apenas três simbolos, um para cada espécie:
plot(Sepalas, Petalas, pch = c("A", "&", "+"))
# eles vao aparecer misturados, isso não está de acordo com as espécies
# uma forma rápida de fazer isso, tendo em vista que o pch pode ser um valor numérico,
# é transformar o nome das minhas especies em números.
# Eu posso fazer isso se convertendo um fator para número, pois nele as categorias estão explicitamente definidas
spp <- iris$Species
class(spp) # já é um fator
# note que isso gera muitos NAs, já vimos isso antes
as.numeric(as.vector(spp))
# mas isso gera números por spp é um fator
as.numeric(spp)
# então se eu quero os símbolos 22,23,25 para representar minhas espécies, eu uso esses números para pegar esses valores pelos índices de um vetor:
pch.das.spp <- c(21, 23, 25)[as.numeric(spp)]
pch.das.spp
# posso usar isso como argumento em plot:
plot(Sepalas, Petalas, pch = pch.das.spp)
# pronto cada espécie é um símbolo diferente
```
### Tamanho dos pontos - `cex`
O argumento genérico `cex` especifica o tamanho dos pontos relativo ao padrão do dispositivo.
Aceita um valor numérico que é multiplicado pelo valor do seu dispositivo.
O padrão geral é 1, isto é, 100% do tamanho.
Se colocar 0.5 teremos 50%; se 1.5, teremos 150% do tamanho padrão.
```{r, cache = TRUE}
# da etapa anterior
pch.das.spp <- c(21, 23, 25)[as.numeric(spp)]
# temos nosso gráfico com símbolos
plot(Sepalas, Petalas, pch = pch.das.spp)
# mudando o tamanho de todos os simbolos
plot(Sepalas, Petalas, pch = pch.das.spp, cex = 0.5)
# para maior
plot(Sepalas, Petalas, pch = pch.das.spp, cex = 1.5)
# um tamanho diferente por ponto (especie)
tm <- c(0.5, 1, 1.5)[as.numeric(spp)]
tm
plot(Sepalas, Petalas, pch = pch.das.spp, cex = tm)
```
### Linhas
Os argumentos `lwd` e `lty` controlam a espessura e o tipo das linhas, respectivamente.
```{r, cache = TRUE}
data("AirPassengers") # veja esse conjunto de dados com ?datasets
class(AirPassengers)
plot(AirPassengers, ylab = "Número de Passageiros")
# mudando o tipo de linha
plot(AirPassengers, ylab = "Número de Passageiros", lty = "dotted")
# outro tipo
plot(AirPassengers, ylab = "Número de Passageiros", lty = "dotdash")
# mudando a cor e espessura
plot(AirPassengers, ylab = "Número de Passageiros", lty = "dashed", col = "red", lwd = 2)
```
### Cores de símbolos - `col` e `bg`
O argumento `col` define cores para os símbolos. No caso de símbolos de uma única cor, utilizamos apenas este argumento.
Já o argumento `bg` define as cores do preenchimento dos símbolos.
```{r, cache = TRUE}
# o que definimos antes são símbolos que permitem definir cores para preenchimento e linha:
pch.das.spp <- c(21, 23, 25)[as.numeric(spp)]
# temos nosso gráfico com símbolos
plot(Sepalas, Petalas, pch = pch.das.spp)
# vamos adicionar as cores seguindo o mesmo raciocínio
cores.spp <- c("red", "blue", "yellow")[as.numeric(spp)]
cores.spp
plot(Sepalas, Petalas, pch = pch.das.spp, bg = cores.spp)
# podemos mudar a cor da linha desses simbolos (todos para verde pela regra da reciclagem especifico uma única vez)
plot(Sepalas, Petalas, pch = pch.das.spp, bg = cores.spp, col = "green")
# mudando simbolos
nsb <- c("*", "#", "+")[as.numeric(spp)]
plot(Sepalas, Petalas, pch = nsb, bg = cores.spp)
# note que apesar de bg estar especificando cores as cores nao foram adicionadas, porque colocamos no argumento de preenchimento.
# Mudando:
plot(Sepalas, Petalas, pch = nsb, col = cores.spp)
```
### Funções que definem cores
Cores podem ser definidas por palavras ou por códigos.
As funções `colors()` ou `colours()` listam cores pelo nome.
```{r, opts.label='evalF'}
# lista todas as cores disponíveis pelo nome
colors()
# nossa tem 657 cores. Difícil, né?
# reduz para as mais distintas
colors(distinct = TRUE)
# ainda 502
```
```{r, opts.label='evalF'}
# eu posso pegar ou buscar por cores
ascores <- colors(distinct = TRUE)
vl <- grep("blue", ascores)
ascores[vl]
# 60 nomes que contém a palavra azul
# vamos ver todas as coresem umpdf longo
# vamos plotar pizzas coloridas com 10 cores cada
# 4 pizzas por página
```
```{r, opts.label='evalF'}
?pie # veja o help dessa função
```
```{r, opts.label='evalF'}
# abre um PDF
pdf("cores.pdf", width = lcm(29), height = lcm(21))
# vamos dividir o dispositivo em 2 colunas e 3 linhas (e diminuir a margem)
par(mfrow = c(2, 2), mar = c(3, 3, 3, 3), cex = 0.7)
ln <- length(ascores)
ln # sao 502 cores
ceiling(ln / 10) # , entao serao 51 pizzas
# plota cada pizza fazendo uma iteração:
idx <- 0 # o objeto nullo para usar de indice na iteracao para fazer de 10 em 10
for (p in 1:ceiling(ln / 10)) {
de <- idx + 1 # cor do indice idx
ate <- idx + 10 # ate cor do indice idx+10
cls <- ascores[de:ate] # cores da pizza da iteracao p
pie(rep(1, 10), col = cls, labels = cls)
idx <- ate
}
dev.off() # fecha o pdf
```
As funções `rainbow()` ou `terrain.colors()` geram gradientes de cores em um padrão definido.
```{r, cache = TRUE}
# 10 cores do arco-iris
cls <- rainbow(n = 10)
pie(rep(1, 10), col = cls, labels = cls)
# 12 cores do arco-iris com 50% de transparencia
cls <- rainbow(n = 12, alpha = 0.5)
pie(rep(1, 12), col = cls, labels = cls)
# 12 cores do arco-iris, limitando o espectro
cls <- rainbow(n = 12, start = 0.1, end = 0.9)
pie(rep(1, 12), col = cls, labels = cls)
# 10 cores quentes
cls <- heat.colors(n = 10, alpha = 1)
pie(rep(1, 10), col = cls, labels = cls)
# 20 cores topográficas
cls <- topo.colors(n = 20, alpha = 1)
pie(rep(1, 20), col = cls, labels = cls)
# ou melhor
cls <- terrain.colors(n = 20, alpha = 1)
pie(rep(1, 20), col = cls, labels = cls)
```
As funções `rgb()` ou `hsv()` geram qualquer tipo de cor para ser utilizados nos gráficos.
```{r, opts.label='evalF'}
?rgb # veja o help dessa funcao e veja as funcoes sob See Also
```
```{r, cache = TRUE}
# podemos entender melhor fazendo o caminho inverso
defs <- col2rgb("yellow") # extraimos as especificacoes de amarelo (cores primárias ) pela palavra
defs
# sem cor temos preto
cls <- rgb(red = 0, green = 0, blue = 0) # fazemos amarelo
pie(1, col = cls, labels = cls)
# fazemos amarelo
cls <- rgb(red = 255, green = 255, blue = 0, maxColorValue = 255)
pie(1, col = cls, labels = cls)
# tiramos verde
cls <- rgb(red = 255, green = 160, blue = 0, maxColorValue = 255)
pie(1, col = cls, labels = cls)
# tiramos verde e adicionamos azul
cls <- rgb(red = 255, green = 160, blue = 255, maxColorValue = 255)
pie(1, col = cls, labels = cls)
# tiramos azul-escuro (mais perto de 0)
cls <- rgb(red = 0, green = 0, blue = 150, maxColorValue = 255)
pie(1, col = cls, labels = cls)
# tiramos azul
cls <- rgb(red = 0, green = 0, blue = 255, maxColorValue = 255)
pie(1, col = cls, labels = cls)
```
## Funções gráficas de alto nível {#graf-alto-nivel}
Funções gráficas de alto-nível (*highlevel plots*) são as funções que usamos para gerar os gráficos.
Além da função genérica `plot()`, veremos apenas alguns poucos exemplos, mas existem diversas funções gráficas de alto nível, muitas das quais dependem de pacotes específicos.
Existem inúmeras outras funções de alto-nível, algumas do R-base, outras geradas por colaboradores na forma de [pacotes do R](https://cran.r-project.org/web/packages/).
A função `plot()` entende algumas dessas outras funções dos pacotes automaticamente, dependendo da classe do objeto, e você sequer precisa usar o nome específico (veja o exemplo em plot.phylo(), abaixo).
No `?` do pacote graphics, você encontra ajuda para funções gráficas em geral:
```{r, opts.label='evalF'}
demo("graphics") # execute este demostrativo - lembre-se de interagir no console do R para as figuras
?graphics # veja o help dessa função para alguns gráficos
```
### `plot()` - uma função genérica
A função `plot()` é a principal para produção de gráficos porque é uma **função genérica** que irá gerar um gráfico dependendo da [classe do objeto](#classes). Em muitos casos, não precisamos usar outras funções, porque a depender da classe do objeto, esta função automaticamente entenderá o que você precisa.
```{r, opts.label='evalF'}
?plot # veja o help dessa função
```
Suponha que tenhamos um vetor simples e numérico chamado `vv`:
```{r, eval = TRUE, echo = TRUE}
vv <- 1:10
# Qual e a classe desse vetor?
class(vv)
```
Vamos plotá-lo:
```{r, cache = TRUE}
plot(vv)
```
Vamos mudar alguns argumentos da função `plot()`.
Acrescentaremos um tipo diferente de ponto (argumento `pch`), uma cor vermelha para o fundo do ponto (argumento `bg`), um novo texto para o eixo x (argumento `xlab`), um novo texto para o eixo y (argumento `ylab`), e um título para o plot (argumento `main`):
```{r, cache = TRUE}
plot(vv, pch = 21, bg = "red", xlab = "índice do vetor", ylab = "valor do vetor", main = "Plotando um vetor")
```
Vamos trabalhar agora com uma matriz de duas colunas:
```{r, cache = TRUE}
xx <- 1:10 # um vetor
yy <- 10:1 # o mesmo vetor invertido
mm <- cbind(xx, yy) # junta em uma matrix
# Qual a classe dessa matriz?
class(mm)
```
Vamos utilizar a matriz de duas colunas `mm` diretamente como primeiro argumento da função `plot()`:
```{r, cache = TRUE}
plot(mm, xlab = "Eixo X", ylab = "Eixo Y", main = "Plotando uma matriz de 2 colunas")
```
Podemos também especificar separadamente os eixos x e y, utilizando os vetores `xx` e `yy`, utilizados para compor a matriz `mm`:
```{r, cache = TRUE}
# ou poderia especificar diretamente os eixos xx e yy sem usar a matriz
plot(xx, yy, xlab = "Eixo X", ylab = "Eixo Y", main = "Plotando uma matriz de 2 colunas", pch = 21, bg = "purple")
```
Se temos um conjunto de dados e queremos ver a relação entre si de todas as colunas do conjunto, podemos simplesmente usar:
```{r, eval = TRUE, echo = TRUE}
class(iris) # um conjunto de dados no formato data.frame
```
```{r, cache = TRUE}
plot(iris)
# o nome dos eixos está na diagonal dessa figura
```
### `hist()`
Esta importante função serve para visualizar a variação de uma variável apenas.
```{r, opts.label='evalF'}
?hist # veja o help
```
Vamos utilizar apenas a variável `Sepal.Length` do conjunto de dados `iris`:
```{r, eval = TRUE, echo = TRUE}
class(iris$Sepal.Length) # é um vetor
```
```{r, cache = TRUE}
hist(iris$Sepal.Length, xlab = "Comprimento de sépala (cm)", main = "Variação em Iris")
```
Vamos diminuir os espaçamentos entre as barras e colorí-las:
```{r, cache = TRUE}
# diminuindo os espaçamentos entre as barras e colorindo
hist(iris$Sepal.Length, xlab = "Comprimento de sépala (cm)", main = "Variação em Iris", breaks = 20, col = "red")
# note que o eixo y é a frequencia que o valor ocorre, ou seja, corresponde ao número de linhas em iris que tem valor
```
### `boxplot()`
Esta função é importante por mostrar a variação em uma variável qualquer em relação às categorias de um fator.
É uma das melhores formas gráficas para mostrar a distribuição de valores de uma variável em relação às categorias.
```{r, opts.label='evalF'}
?boxplot
```
```{r, cache = TRUE}
# vamos usar o objeto iris
class(iris$Sepal.Length) # é um vetor
class(iris$Species) # é um fator
boxplot(iris$Sepal.Length ~ iris$Species, ylab = "Comprimento da sépala")
# você pode fazer a mesma coisa com a função plot() porque ela é genérica que irá reconhecer que sua fórmula 'valores~fator' pede por um boxplot
plot(iris$Sepal.Length ~ iris$Species, ylab = "Comprimento da sépala", xlab = "") # note que especificamos aqui que o eixo x não tem título (lab)
```
### `barplot()`
Esta função gera um gráfico de barras simples.
```{r, opts.label='evalF'}
?barplot # veja o help dessa função
?VADeaths # veja o help desse conjunto de dados
```
```{r, cache = TRUE}
class(VADeaths)
VADeaths # taxas de mortalidade/1000 habitantes no estado da Virgínia em 1940
rownames(VADeaths) # cada linha é uma classe de idade
colnames(VADeaths) # cada coluna é sexo e cidade ou rural
# com as informações padrão
barplot(VADeaths) # cada cor é uma linha
barplot(VADeaths, beside = TRUE) # lado a lado (cada barra é uma linha)
# vamos colorir diferente, uma para cada linha
rownames(VADeaths)
cores <- rainbow(n = nrow(VADeaths))
cores # uma cor por linha
# essa é a correspondencia:
cbind(rownames(VADeaths), cores)
# plota com essas cores
barplot(VADeaths, beside = TRUE, col = cores)
```
### `plot.phylo()`
O pacote [Ape (Analyses of Phylogenetics and Evolution)](https://cran.r-project.org/web/packages/ape/index.html) [@R-ape] possui uma função para desenhar uma filogenia.
Caso você não tenha instalado o pacote `ape` ainda, faça-o assim:
```{r, opts.label='evalF'}
install.packages("ape")
```
Depois, siga o exemplo abaixo:
```{r, cache = TRUE}
library(ape) # chama o pacote
# uma filogenia hipotética para exemplo
arv <- "(((A:1,B:1):2,C:3):0.5,((D:0.5,E:0.5):1,F:1.5):2);"
# lê essa filogenia para um objeto de classe phylo, que é uma classe para dendrogramas.
phy <- read.tree(text = arv)
class(phy)
# podemos plotar essa filogenia com
plot(phy)
# porque a função plot reconhece
# que objetos de classe "phylo" são árvores
# de fato ela usa a função plot.phylo() para gerar essa figura, que contém argumentos específicos para objetos dessa classe
```
```{r, opts.label='evalF'}
?plot.phylo # veja o help e os argumentos
```
```{r, cache = TRUE}
# portanto posso incluir argumentos de plot.phylo() quando uso a função plot() para plotar um objeto de classe phylo
plot(phy, no.margin = TRUE, tip.color = c(rep("red", 3), rep("blue", 3)))
# seria o mesmo que dizer
plot.phylo(phy, no.margin = TRUE, tip.color = c(rep("red", 3), rep("blue", 3)))
```
### `image()` e `countour()`
```{r, opts.label='evalF'}
# existe um conjunto de dados topográficos na base do R que vamos usar como exemplo
class(volcano) # é uma matriz
dim(volcano) # com 87 linhas e 61 uma colnas
volcano[1:5, 1:5] # os valores são altitude
hist(volcano, breaks = 20) # essa é a distribuição de valores de elevacao
range(volcano) # amplitude de variação
```
```{r, opts.label='evalF'}
# podemos usar algumas funções para visualizar um conjunto de dados que tem essa estrutura (matrix)
?image # veja o help
```
```{r, cache = TRUE}
image(volcano, col = heat.colors(12))
```
```{r, opts.label='evalF'}
?heat.colors # veja opções de gradientes continuos de cores
```
```{r, cache = TRUE}
# vamos mudar isso,
cores <- terrain.colors(12) # 12 categorias de cores
cores # o código é uma cor em HTML
image(volcano, col = cores)
# notem a cratera
```
```{r, opts.label='evalF'}
?contour # veja o help
```
```{r, cache = TRUE}
# outra opção é fazermos os contornos (ou curvas de nível neste caso do vulcão)
contour(volcano)
# vamos mudar o número de níveis para o mesmo usado para as cores
contour(volcano, nlevels = 12)
# vamos juntar essas figuras em uma só
image(volcano, col = cores)
contour(volcano, nlevels = 12, add = TRUE)
# note o argumento add=TRUE que indica para a função de alto-nível
# que ela não deve começar uma nova figura,
# apenas adiciona à uma já criada por outra função de alto-nível
# muitas funções de alto-nível tem esse argumento add, que, portanto, mimetiza o que função gráfica de baixo-nível faz
```
### `map()`
O pacote [maps](https://cran.r-project.org/web/packages/maps/index.html) [@R-maps] fornece funções para desenhar mapas com divisões administrativas.
A função `map()` é uma de alto-nível.
Veremos depois como adicionar sobre esses mapas informação através de funções de baixo-nível.
```{r, opts.label='evalF'}
?maps::map # veja o help
```
Caso você não tenha instalado o pacote `maps` ainda, faça-o assim:
```{r, opts.label='evalF'}
install.packages("maps")
```
Agora, siga o exemplo abaixo: