1 - Introduction

Nous avons vu à la séance précédente comment parcourir un jeu de données avec le language R de base.
Rappelons notamment l’usage des fonctions view(), head(), class(), summary(), str(), nrow(), ncol(), levels(), plot(), etc.

Nous avons également vu comment manipuler un jeu de données, avec les fonctions R de base, et avec les fonctions de la bibliothèque dplyr() du tidyverse.

Passons maintenant à la visualisation avec les graphiques.

Tout d’abord rechargeons notre jeu de données :

jdd <- read.csv("data/data_exemple.csv")

2 - Créer un graphique simple avec les commandes R de base

A présent, essayons de visualiser un graphique de la longueur vs la largeur des pièces.
Dans le language R de base, on utilise la fonction plot()

plot(x = jdd$longueur, y = jdd$largeur)

Ici, à l’intérieur de la fonction, on a précisé quels arguments étaient concernés: x et y. Les fonctions comme class(), levels() n’ont qu’un argument, c’est pourquoi nous n’avons pas eu besoin de le préciser.

Un argument est un objet que l’on passera à la fonction pour qu’elle s’exécute. De façon générale, les arguments sont rentrés dans l’ordre chronologique dans lequel ils sont programmés dans la fonction. Voyons voir cela de plus près.

?plot
## Help on topic 'plot' was found in the following packages:
## 
##   Package               Library
##   graphics              /Library/Frameworks/R.framework/Versions/4.2/Resources/library
##   base                  /Library/Frameworks/R.framework/Resources/library
## 
## 
## Using the first match ...

Dans la fiche d’aide, nous pouvons voir que cette fonction nécessite deux arguments au minimum :
x (abscisse) et y (ordonnée).
Il est possible de préciser ou non dans le code quels objets vont dans quels arguments, mais ce n’est pas nécessaire si l’on respecte l’ordre logique avec x d’abord et y ensuite.
Ainsi, la commande suivante aura le même résultat que précédemment

plot(jdd$longueur, jdd$largeur)

Notez ici l’importance de bien séparer chaque argument par une virgule ,. Sans cela il n’est pas possible de passer la commande.

Si la fonction plot() nécessite ces deux arguments pour fonctionner, nous pouvons lui transmettre d’autres arguments annexes permettant d’améliorer la qualité graphique. Par exemple, modifions le titre des axes pour que ce soit plus clair:

plot(
  x = jdd$longueur,             # il est possible de sauter une ligne 
  y = jdd$largeur,              # après chaque virgule ou parenthèse
     xlab = "Longueur (cm)",    # pour faciliter la lecture du code
     ylab = "Largeur (cm)"      # avant de fermer la parenthèse
     )

Précisons ici que les textes entre guillemets (“” ou ’’) seront automatiquement considérés comme des objets de type caractère. Il est d’ailleurs possible de les définir avant de les inclure dans la fonction:

xlabel <- "Longueur (cm)"
ylabel <- "Largeur (cm)"
plot(x = jdd$longueur, y = jdd$largeur,
     xlab = xlabel, ylab = ylabel)

# Ajoutons l'objet du titre avant de l'insérer dans le plot
title <- "Dimension des objets en silex"
plot(x = jdd$longueur, y = jdd$largeur,
     xlab = xlabel, ylab = ylabel, 
     main = title)

Pour aller plus loin, il est possible de colorer les points en fonction d’une catégorie. Essayons avec la catégorie type_fac

jdd$type_fac <- as.factor(jdd$type)

plot(x = jdd$longueur, y = jdd$largeur,
     col = jdd$type_fac, 
     xlab = xlabel, ylab = ylabel,
     main = title)

On peut également changer la forme des points avec l’argument pch. Essayons de faire un graphique avec des formes différentes en fonction du type de silex. NB : N’oublions pas de convertir notre colonne silex en facteur !

jdd$silex_fac <- as.factor(jdd$silex)

plot(x = jdd$longueur, y = jdd$largeur,
     col = jdd$type_fac, 
     pch = c(16, 17, 18)[as.numeric(jdd$silex_fac)], # ici, on assigne les formes
                                                     # 16, 17 et 18 aux levels  
     xlab = xlabel, ylab = ylabel, 
     main = title)

Les points de ce graphe sont trop petits pour être bien visibles. Mais il est possible de modifier leur taille au sein de la fonction plot().

plot(x = jdd$longueur, y = jdd$largeur,
     col = jdd$type_fac, 
     pch = c(16, 17, 18)[as.numeric(jdd$silex_fac)],  
     cex = 1.5,
     xlab = xlabel, ylab = ylabel, 
     main = title)

Vous pouvez également ajouter une légende à votre graphique avec la fonction legend().

plot(x = jdd$longueur, y = jdd$largeur,
     col = jdd$type_fac, 
     pch = c(16, 17, 18)[as.numeric(jdd$silex_fac)],  
     cex = 1.5,
     xlab = xlabel, ylab = ylabel, 
     main = title)

# Commençons par la légende des types de silex 
legend("topleft", # ici préciser la position de la légende
       legend = c("Type A", "Type B", "Type C"), # ici préciser les légendes
       pch = 16:18, # ici préciser les shapes
       horiz = TRUE) # ici, on précise si l'on souhaite que la légende soit horizontale ou verticale

Il est possible d’ajouter plusieurs légendes sur une même figure !

plot(x = jdd$longueur, y = jdd$largeur,
     col = jdd$type_fac, 
     pch = c(16, 17, 18)[as.numeric(jdd$silex_fac)],  
     cex = 1.5,
     xlab = xlabel, ylab = ylabel, 
     main = title)

legend("topleft", 
       legend = c("Type A", "Type B", "Type C"), 
       pch = 16:18, 
       horiz = TRUE) 

# Rajoutons la légende pour les types de pièces 
legend("bottomright",
       legend = levels(jdd$type_fac),
       fill = 1:8, # l'argument "fill" permet de préciser les couleurs sous la forme de rectangles de légende 
       cex = 0.5) # on peut également changer la taille de la légende afin qu'elle prenne moins de place

3 - Enregistrer un graphique

Il existe plusieurs moyens pour enregistrer une figure:
- Le premier est de cliquer sur le bouton Export dans l’onglet Plots. Vous pouvez alors choisir le dossier dans lequel sauvegarder la figure, dont vous pouvez modifier les dimensions manuellement.
- Toutefois, il est parfois utile de sauvegarder directement la figure avec une ligne de code, notamment dans le but de réaliser plusieurs figures similaires de la même taille exactement ! Utiliser la fonction pdf() est plus reproductible et ne complique par le code outre mesure.

Enregistrons notre figure au format pdf de cette manière:

#Il faut tout d'abord créer un fichier pdf vide de la taille voulue
pdf("figures/Figure1.pdf",        # ici on écrit le chemin vers la figure
     width = 4.5, height = 4.5)   # et ici les dimensions de la figure en cm. 

## On écrit la figure dans le pdf
plot(x = jdd$longueur, y = jdd$largeur,
     col = jdd$type_fac, 
     pch = c(16, 17, 18)[as.numeric(jdd$silex_fac)], 
     cex = 1.5,
     xlab = xlabel, ylab = ylabel, 
     main = title)
###(sans oublier les légendes)
legend("topleft", 
       legend = c("Type A", "Type B", "Type C"), 
       pch = 16:18, 
       horiz = TRUE) 
legend("bottomright",
       legend = levels(jdd$type_fac),
       fill = 1:8, 
       cex = 0.5) 

## et on clot l'écriture de la figure dans le pdf

dev.off()