2.1 Procédure de création d’un graphique

Un programme pour créer un graphique avec le système graphique de base en R se décompose typiquement en 3 étapes, les suivantes :

1. La configuration des paramètres graphiques (au besoin) :
   • énoncé par ou layout.
2. L’initialisation d’un graphique :
   • fonction de base : plot (choisit un graphique pertinent à produire selon ce qu’elle reçoit en entrée),
   • ou fonction pour un type spécifique graphiques : pairs, matplot, pie, barplot, dotchart, mosaicplot, hist, boxplot, qqnorm, qqplot, curve, etc.
3. L’ajout séquentiel d’éléments au graphique (au besoin) :
   • fonctions d’ajouts à un graphique déjà initialisé :
     • points, matpoints, lines, matlines, abline, segments, arrows, rect, polygon, legend, text, mtext, title, axis, box, qqline, etc.;
     • matplot, barplot, hist, boxplot, curve avec l’argument add = TRUE.

Lorsque les paramètres graphiques sont modifiés avec un appel à la fonction par au début du programme, une bonne pratique est d’ajouter aussi à la fin du programme une commande pour redonner aux paramètres graphiques leurs valeurs par défaut.

La mise en forme et les annotations du graphique (p. ex. titre et noms d’axe) sont déterminées par les paramètres graphiques ainsi que par des arguments des fonctions graphiques. Avec un peu de patience et quelques lignes de code, il est possible d’arriver à contrôler parfaitement l’apparence du graphique.

Voici un exemple de programme créant un graphique avec le système graphique de base en R.

# 1. Configuration de paramètres graphiques
par_default <- par(bty = 'n')

# 2. Initialisation d'un graphique (contenant ici des diagrammes en boîtes)
plot(
  stations ~ mag_catego, data = quakes, 
  lwd = 1.5, outline = FALSE,
  main = "Nombres de stations ayant rapporté les séismes\nselon leurs classes de magnitude",
  xlab = "classe de magnitude",
  ylab = "nombre de stations"
)

# 3. Ajout séquentiel d'éléments au graphique
# Ajout de diagrammes de dispersion 1D par région
stripchart(
  stations ~ mag_catego, data = quakes, subset = region == "Ouest",
  method = "jitter", jitter = 0.3, add = TRUE, vertical = TRUE, 
  col = rgb(1,0,0,0.2), pch = 20
)
stripchart(
  stations ~ mag_catego, data = quakes, subset = region == "Est",
  method = "jitter", jitter = 0.3, add = TRUE, vertical = TRUE,
  col = rgb(0,0,1,0.2), pch = 20
)
# Ajout d'une légende
legend(
  x = "bottomright", bty = "n",
  col = c(rgb(1,0,0,0.5), rgb(0,0,1,0.5)), pch = 20,
  legend = c("Ouest", "Est"), title = "région"
)

# Réattribution des valeurs par défaut aux paramètres graphiques modifiés
par(par_default)

Les prochaines sections présentent les concepts à connaître pour suivre la procédure de création de graphique avec le système graphique de base en R et contiennent beaucoup d’exemples. Cependant, la matière n’est pas couverte dans le même ordre que les étapes de la procédure. Même si dans le code de création d’un graphique la configuration des paramètres est l’étape 1, il faut d’abord savoir créer un graphique pour que cette étape ait du sens. De plus, la configuration des paramètres graphique est une étape facultative. Parfois, les valeurs par défaut des paramètres font l’affaire.

Ainsi, nous allons d’abord étudier la principale fonction du système graphique de base en R, soit la fonction plot. Dans un deuxième temps, nous ferons un survol de plusieurs autres fonctions de création de graphiques. Ensuite, les arguments et paramètres graphiques qui permettent de contrôler les annotations et la mise en forme seront présentés. Pour terminer la couverture des étapes de la procédure de création, il ne restera plus qu’à parler des fonctions d’ajouts d’éléments à un graphique.

Les exemples présentés seront simple au début, mais se complexifient au fil de la section.

2.2 Fonction générique plot

La principale fonction graphique en R est la fonction plot. En fait, plot est une fonction générique. Il existe plusieurs méthodes associées à cette fonction générique. Pour afficher la liste des méthodes plot chargées dans notre session R, il faut soumettre la commande suivante.

methods(plot)

##  [1] plot.acf*           plot.data.frame*    plot.decomposed.ts* plot.default       
##  [5] plot.dendrogram*    plot.density*       plot.ecdf           plot.factor*       
##  [9] plot.formula*       plot.function       plot.hclust*        plot.histogram*    
## [13] plot.HoltWinters*   plot.isoreg*        plot.lm*            plot.medpolish*    
## [17] plot.mlm*           plot.ppr*           plot.prcomp*        plot.princomp*     
## [21] plot.profile.nls*   plot.raster*        plot.spec*          plot.stepfun       
## [25] plot.stl*           plot.table*         plot.ts             plot.tskernel*     
## [29] plot.TukeyHSD*     
## see '?methods' for accessing help and source code

Si nous donnons en entrée à la fonction plot un vecteur en argument x, c’est la méthode plot.default qui est utilisée. Cette méthode trace un diagramme de dispersion.

La fonction plot choisit la méthode à utiliser en fonction de la classe de l’objet assigné à son premier argument (x). C’est une caractéristique « orientée objet » du langage R. Nous reviendrons sur ce concept plus tard. Pour l’instant, il suffit de comprendre que les différentes méthodes produisent différents résultats et acceptent différents arguments. En fait, ces méthodes font souvent appels à d’autres fonctions de création de graphique.

L’annexe contient une panoplie d’exemples de graphiques pouvant être produits avec la fonction générique plot, selon les objets qui lui sont donnés en entrée. Voici ici un résumé des possibilités couvertes dans ces exemples.

2.3 Différentes fonctions graphiques

En explorant les capacités de la fonction générique plot, nous découvrons plusieurs fonctions de création de graphiques. Ces fonctions permettent de créer des graphiques de différents types.

Voici un résumé des principaux types de graphiques pouvant être créés dans le système graphique de base en R, suivi d’exemples.

Représentations d’une variable (observations stockées dans x) :

Représentation d’une expression mathématique : curve(expr, ...)

Représentations de deux variables (observations stockées dans x et y) :

Représentation de plus de trois variables numériques :

• matrice de diagrammes de dispersion : pairs( ~ x + y + z, ...)
• diagrammes de dispersion superposés : matplot(matriceX, matriceY, ...)

plot(
  x = quakes$mag, y = quakes$stations,
  xlab = "magnitude du séisme", 
  ylab = "nombre de stations rapportant le séisme"
)

pairs( ~ depth + mag + stations, data = quakes)

quakes_large <- reshape(
  data = quakes,
  direction = "wide",
  idvar = c("lat", "long", "depth"),
  timevar = "region",
  v.names = c("mag", "stations"),
  sep = "_"
)
matplot(
  x = quakes_large[, c("mag_Est", "mag_Ouest")], 
  y = quakes_large[, c("stations_Est", "stations_Ouest")], 
  pch = 2:1, col = c("blue", "green"),
  xlab = "magnitude du séisme", 
  ylab = "nombre de stations rapportant le séisme"
)

mean_stations_per_mag <- aggregate(stations ~ mag, data = quakes, FUN = mean)
plot(
  stations ~ mag, 
  data = mean_stations_per_mag,
  type = "l",
  xlab = "magnitude du séisme", 
  ylab = "nombre de stations rapportant le séisme"
)

pie(x = table(quakes$mag_catego), main = "Fréquences des modalités de magnitude de séismes")

barplot(
  height = table(quakes$mag_catego), 
  horiz = TRUE,
  xlab = "fréquence",
  ylab = "modalité de magnitude"
)

quakes_freq <- xtabs(~ region + mag_catego, data = quakes)
quakes_freq

##        mag_catego
## region    4   5   6
##   Ouest 151  49   5
##   Est   651 144   0

barplot(
  height = quakes_freq,
  legend.text = TRUE,
  xlab = "modalité de magnitude",
  ylab = "fréquence"
)

barplot(
  height = quakes_freq, 
  legend.text = TRUE, 
  beside = TRUE,
  xlab = "modalité de magnitude",
  ylab = "fréquence"
)

dotchart(
  x = quakes_freq[2:1, 3:1], 
  bg = "grey", 
  xlab = "Fréquence",
  ylab = "Région par modalité de magnitude"
)
# L'ordre des lignes et des colonnes de quakes_freq est ajusté pour
# assurer la présentations des fréquences dans l'ordre désiré.

mosaicplot(
  x = quakes_freq[, 3:1],
  color = TRUE,
  main = "Fréquences croisées",
  xlab = "région",
  ylab = "modalité de magnitude"  
)
# L'ordre des colonnes de quakes_freq est ajusté pour
# assurer la présentations des fréquences dans l'ordre désiré.

hist(
  x = quakes$mag,
  main = "Distribution empirique de la magnitude",
  xlab = "magnitude",
  ylab = "fréquence"
)

stats <- hist(x = quakes$mag, plot = FALSE)
stats

## $breaks
##  [1] 4.0 4.2 4.4 4.6 4.8 5.0 5.2 5.4 5.6 5.8 6.0 6.2 6.4
## 
## $counts
##  [1] 191 186 208 163 101  72  41  23   8   5   1   1
## 
## $density
##  [1] 0.955 0.930 1.040 0.815 0.505 0.360 0.205 0.115 0.040 0.025 0.005 0.005
## 
## $mids
##  [1] 4.1 4.3 4.5 4.7 4.9 5.1 5.3 5.5 5.7 5.9 6.1 6.3
## 
## $xname
## [1] "quakes$mag"
## 
## $equidist
## [1] TRUE
## 
## attr(,"class")
## [1] "histogram"

boxplot(x = quakes$mag, ylab = "magnitude")

boxplot(mag ~ region, data = quakes, xlab = "région", ylab = "magnitude")

plot(
  x = density(quakes$mag),
  main = "Distribution empirique de la magnitude",
  xlab = "magnitude",
  ylab = "densité à noyau"
)

qqnorm(
  y = quakes$mag,
  main = "Diagramme quantile-quantile normal",
  xlab = "qantiles théoriques normaux",
  ylab = "quantiles empiriques de la magnitude"
)

qqplot(
  x = quakes$stations, y = quakes$mag,
  main = "Diagramme quantile-quantile empirique",
  xlab = "quantiles empiriques du nombre de stations",
  ylab = "quantiles empiriques de la magnitude"
)

curve(expr = log)

curve(expr = x^2 + 5*x - 25, from = -23, to = 18, n = 200)

x <- seq(from = -23, to = 18, length = 200)
plot(x = x, y = x^2 + 5*x - 25, type = "l")

2.4 Modification de l’ordre des niveaux d’un facteur

Lorsqu’un facteur est représenté dans un graphique, ses niveaux (ou modalités) sont présentés en respectant leur ordre dans les attributs (métadonnées) du facteur. Par exemple, dans les diagrammes en boîtes juxtaposés créés précédemment (et repris ci-dessous), le niveau Ouest du facteur region de quakes est présenté avant le niveau Est (même si selon l’ordre alphabétique, Est vient avant Ouest).

boxplot(mag ~ region, data = quakes, xlab = "région", ylab = "magnitude")

Cet ordre est utilisé, car il s’agit de l’ordre officiel des niveaux de ce facteur.

levels(quakes$region)

## [1] "Ouest" "Est"

Si nous voulions voir apparaître dans le graphique les niveaux du facteur dans un autre ordre, il faudrait aller modifier les attributs du facteur, comme nous avons appris à le faire dans les notes sur les structures de données en R. Voici un exemple.

quakes_modif <- quakes
quakes_modif$region <- factor(quakes_modif$region, levels = c("Est", "Ouest"))
boxplot(mag ~ region, data = quakes_modif, xlab = "région", ylab = "magnitude")

2.5 Arguments et paramètres graphiques

Les fonctions vues jusqu’à présent possèdent toutes des arguments pour contrôler la mise en forme et les annotations des graphiques. La liste complète de ces arguments varient d’une fonctions à l’autre, mais certains arguments sont communs à presque toutes les fonctions graphiques. Nous allons voir ici les arguments les plus utiles.

Les arguments permettant de contrôler la mise en forme sont appelés paramètres graphiques. La plupart peuvent être spécifiés soit dans l’appel à la fonction graphique, soit dans un appel à la fonction par. Par contre, certains paramètres graphiques peuvent uniquement être fixés avec par.

Un paramètre graphique fourni dans un appel à une fonction graphique est effectif seulement pour le graphique produit, alors qu’un paramètre graphique fourni dans un appel à par reste effectif jusqu’à ce que nous le modifions de nouveau. Alors, avant de modifier des paramètres graphiques avec par, il est bon d’enregistrer les valeurs par défaut des paramètres, comme suit,

all_par_default <- par(no.readonly = TRUE)

afin de pouvoir facilement réattribuer ces valeurs par défaut aux paramètres, comme suit,

par(all_par_default)

à la fin des nos commandes pour produire un graphique. L’objet all_par_default est une liste contenant les valeurs par défaut de tous les paramètres graphiques modifiables. Il est aussi possible d’enregistrer seulement les valeurs des paramètres graphiques modifiés par un appel à la fonction par en l’accompagnant d’une assignation. Les valeurs enregistrées sont celles que prenaient les paramètres avant d’être modifiés. Par exemple, l’objet par_default obtenu ainsi :

par_default <- par(mar = c(1, 1, 2, 1))

contient uniquement la valeur par défaut du paramètre mar.

par_default

## $mar
## [1] 5.1 4.1 4.1 2.1

La valeur initiale du paramètre mar est réactivée comme suit.

par(par_default)

Notons que les changements apportés aux paramètres graphiques ne sont pas conservés lors de la fermeture de la session R. À l’ouverture d’une session R, les paramètres graphiques prennent donc toujours leurs valeurs par défaut.

Voici deux tableaux résumant les arguments et paramètres graphiques les plus communs :

La liste de tous les paramètres graphiques R est bien plus longue que ça. Il en existe plus de soixante-dix, tous documentés dans la fiche d’aide de la fonction par.

L’utilisation de certains de ces arguments a déjà été illustré dans les exemples précédents. Voici un exemple supplémentaire dans lequel quelques éléments de la mise en forme sont modifiés dans le diagramme de dispersion de la variable stations en fonction de la variable mag

plot(
  x = quakes$mag,
  y = quakes$stations,
  main = "1000 séismes près de Fidji",
  xlab = "magnitude du séisme",
  ylab = "nombre de stations rapportant le séisme",
  font.lab = 3,     # nom d'axes en italique
  font.main = 4,    # titre en gras italique
  cex.axis = 0.8,   # étiquettes des axes plus petites
  bty = "n"         # pas de cadre autour de la zone graphique
)

Remarquons que les accents ne causent pas de problèmes dans le titre et les noms d’axes.

Nous pouvons aussi modifier certains paramètres graphiques par un appel à la fonction par comme suit.

par_default <- par(font.lab = 3, font.main = 4, cex.axis = 0.8, bty="n")
plot(
  x = quakes$mag, y = quakes$stations,
  main = "1000 séismes près de Fidji",
  xlab = "magnitude du séisme", 
  ylab = "nombre de stations rapportant le séisme"
)
par(par_default)

Utiliser la fonction par est pratique si nous avons plusieurs graphiques à produire avec les mêmes paramètres.

colors()

##  [1] "white"         "aliceblue"     "antiquewhite"  "antiquewhite1" "antiquewhite2"
##  [6] "antiquewhite3" "antiquewhite4" "aquamarine"    "aquamarine1"   "aquamarine2"  
## [11] "aquamarine3"   "aquamarine4"   "azure"         "azure1"        "azure2"       
##  [ reached getOption("max.print") -- omitted 642 entries ]

opacite <- rgb(red = 0, green = 33/255, blue = 78/255, alpha = seq(from = 0, to = 1, by = 0.1))

palette()

## [1] "black"   "#DF536B" "#61D04F" "#2297E6" "#28E2E5" "#CD0BBC" "#F5C710" "gray62"

palette(hcl.colors(20))

palette("default")

2.6 Ajout d’éléments à un graphique

Nous pouvons ajouter des éléments étape par étape à un graphique en R, en appelant les unes après les autres des fonctions graphiques. Le tableau suivant présente les principales fonctions graphiques qui ajoutent des éléments à un graphique initialisé.

Aussi, certaines fonctions de création de graphique peuvent devenir des fonctions d’ajout d’éléments à un graphique grâce à l’argument add. C’est la cas notamment des fonctions suivantes : matplot, barplot, hist, boxplot et curve.

En donnant la valeur TRUE à l’argument add lors de l’appel d’une de ces fonctions, elle ajoute des éléments au graphique de la fenêtre graphique active au lieu de créer un nouveau graphique.

plot(
  stations ~ mag, data = quakes,
  xlab = "magnitude du séisme", 
  ylab = "nombre de stations rapportant le séisme"
)

# Ajustement et ajout d'une droite de régression
lm_out <- lm(stations ~ mag, data = quakes) 
abline(lm_out)

# Calcul des médianes de stations par modalité de mag_catego
out_agg <- aggregate(stations ~ mag_catego, data = quakes, FUN = median)
out_agg$mag_catego <- as.numeric(out_agg$mag_catego)

boxplot(
  stations ~ mag_catego, data = quakes,
  xlab = "modalité de magnitude", 
  ylab = "nombre de stations"
)
lines(x = out_agg, lty = 6, lwd = 2, col = 4)

matplot(
  x = quakes_large[, c("mag_Est", "mag_Ouest")], 
  y = quakes_large[, c("stations_Est", "stations_Ouest")], 
  pch = 2:1, col = c("blue", "green"),
  xlab = "magnitude du séisme", 
  ylab = "nombre de stations rapportant le séisme"
)
legend(
  x = "topleft",
  legend = c("Est", "Ouest"),
  pch = 2:1, col = c("blue", "green"),
  title = "région"
)

# Initialisation de l'histogramme
hist(
  x = quakes$mag, freq = FALSE,
  main = "Densité empirique des magnitudes\ndans le jeu de données quakes",
  xlab = "magnitude", ylab = "densité"
)

# Ajout de la courbe de densité à noyau
lines(density(quakes$mag), xlim = range(quakes$mag))

# Ajout de courbes de densité théoriques avec paramètres estimés à partir des données
moy <- mean(quakes$mag)
et <- sd(quakes$mag)
curve(
  dnorm(x, mean = moy, sd = et), 
  add = TRUE, col = "red", xlim = c(3.5, 7)
)
curve(
  dlnorm(x, meanlog = mean(log(quakes$mag)), sdlog = sd(log(quakes$mag))), 
  add = TRUE, col = "blue", xlim = c(3.5, 7)
)
curve(
  dgamma(x, shape = moy^2/et^2, rate = moy/et^2), 
  add = TRUE, col = "green", xlim = c(3.5, 7)
)

# Ajout d'une légende
legend(
  x = "topright", bty = "n", 
  col = c("black", "red", "blue", "green"), lty = 1,
  legend = c("Densité à noyau", "Densité normale", "Densité log-normale", "Densité Gamma")
)

2.7 Possibilités graphiques spécifiques

curve(
  expr = sin, from = -4, to = 4, 
  main = "Fonction sinus",
  xlab = expression(theta),
  ylab = expression(sin~(theta)),
  xaxt = "n"  # pour omettre la création automatique de l'axe des x   
)
axis(         # pour créer manuellement l'axe des x  
  side = 1,
  at = c(-pi, -pi/2, 0, pi/2, pi),
  labels = expression(-pi, -pi/2, 0, pi/2, pi)
)

curve(
  expr = x^2 + 5*x - 25, 
  from = -23, to = 18, n = 200,
  main = "Fonction polynomiale de degré deux",
  ylab = expression(paste(x^2, "+ 5x - 25"))
)

# Initialisation de l'histogramme
hist(
  x = quakes$mag, freq = FALSE,
  main = "Densité empirique des magnitudes\ndans le jeu de données quakes",
  xlab = "magnitude", ylab = "densité"
)

# Ajout de la courbe de densité à noyau
lines(density(quakes$mag), xlim = range(quakes$mag))

# Ajout de courbes de densité théoriques avec paramètres estimés à partir des données
moy <- mean(quakes$mag)
et <- sd(quakes$mag)
curve(
  dnorm(x, mean = moy, sd = et), 
  add = TRUE, col = "red", xlim = c(3.5, 7)
)
curve(
  dlnorm(x, meanlog = mean(log(quakes$mag)), sdlog = sd(log(quakes$mag))), 
  add = TRUE, col = "blue", xlim = c(3.5, 7)
)
curve(
  dgamma(x, shape = moy^2/et^2, rate = moy/et^2), 
  add = TRUE, col = "green", xlim = c(3.5, 7)
)

# Ajout d'une légende
legend(
  x = "topright", bty = "n",
  col = c("black", "red", "blue", "green"), lty = 1,
  legend = c(
    "Densité à noyau", 
    expression(
      paste(
        "N", 
        bgroup("(",list(mu == bar(x), sigma^2 == s[x]^2),")")
      )
    ), 
    expression(
      paste(
        "Log-N", 
        bgroup("(",list(mu == bar(y), sigma^2 == s[y]^2),")"), 
        " avec ", 
        y == ln(x)
      )
    ), 
    expression(
      paste(
        "Gamma", 
        bgroup("(",list(alpha == bar(x)^2/s[x]^2, beta == bar(x)/s[x]^2),")")
      )
    )
  )
)

expression(
  paste(
    "Log-N", 
    bgroup("(",list(mu == bar(y), sigma^2 == s[y]^2),")"), 
    " avec ", 
    y == ln(x)
  )
)

plot(
  stations ~ mag, data = quakes,
  xlab = "magnitude du séisme", 
  ylab = "nombre de stations rapportant le séisme"
)

# Ajustement et ajout d'une droite de régression
lm_out <- lm(stations ~ mag, data = quakes) 
abline(lm_out)

# Ajout de la valeur du R carré ajusté
lm_out_R2 <- round(summary(lm_out)$r.squared, 3)
text(
  x = 6, y = 15, 
  label = substitute(
    exp = paste(R^2, " = ", valeur_R2), 
    env = list(valeur_R2 = lm_out_R2)
  )
)

text(
  x = 6, y = 15, 
  label = bquote(R^2 == .(lm_out_R2))
)

# Modification du paramètre graphique mfrow de façon à diviser la
# fenêtre graphique en 4 sous-fenêtres sur une grille 2 par 2
par_default <- par(mfrow = c(2, 2))

# Graphique dans la première sous-fenêtre
hist(
  x = quakes$mag, freq = FALSE, 
  main = "", xlab = "magnitude", ylab = "densité", 
)

# Graphique dans la deuxième sous-fenêtre
plot(
  x = density(quakes$mag), 
  main = "", xlab = "magnitude", ylab = "densité"
)

# Graphique dans la troisième sous-fenêtre
boxplot(x = quakes$mag, horizontal = TRUE, xlab = "magnitude")

# Graphique dans la quatrième sous-fenêtre
qqnorm(
  y = quakes$mag, 
  main = "", xlab = "quantiles théoriques normaux", ylab = "quantiles empiriques"
)
qqline(quakes$mag)

# Réattribution des valeurs par défaut aux paramètres graphiques
par(par_default)

layout(matrix(c(1, 2, 3, 3), nrow = 2), widths = c(3, 2))
layout.show(n = 3)

# Configuration des sous-fenêtres
layout(matrix(c(1, 2, 3, 3), nrow = 2), widths = c(3, 2))

# Graphique dans la première sous-fenêtre
hist(
  x = quakes$mag, freq = FALSE, 
  main = "", xlab = "magnitude", ylab = "densité", 
)

# Graphique dans la deuxième sous-fenêtre
boxplot(x = quakes$mag, horizontal = TRUE, xlab = "magnitude")

# Graphique dans la troisième sous-fenêtre
qqnorm(
  y = quakes$mag, 
  main = "", xlab = "quantiles théoriques normaux", ylab = "quantiles empiriques"
)
qqline(quakes$mag)

# Réattribution de la valeur par défaut de layout
layout(matrix(1))

# Enregistrement des valeurs par défaut aux paramètres graphiques
all_par_default <- par(no.readonly = TRUE)

# Configuration des sous-fenêtres
layout(matrix(c(1, 2, 3, 3), nrow = 2), widths = c(3, 2))

# Pour créer un espace pour le titre global (dans la marge externe)
par(oma = c(0, 0, 3, 0))

# Graphique dans la première sous-fenêtre
par(mar = c(3.1, 4.1, 2.1, 2.1), cex.main = 1)
hist(x = quakes$mag, freq = FALSE, main = "Histogramme", ylab = "densité")

# Graphique dans la deuxième sous-fenêtre
par(mar = c(5.1, 4.1, 2.1, 2.1))
boxplot(
  x = quakes$mag, horizontal = TRUE, 
  main = "Diagramme en boîte", xlab = "magnitude"
)

# Graphique dans la troisième sous-fenêtre
qqnorm(
  y = quakes$mag, 
  main = "Diagramme quantile-quantile",
  xlab = "quantiles théoriques normaux", 
  ylab = "quantiles empiriques de la magnitude" 
)
qqline(quakes$mag)

# Ajout du titre global dans la marge externe
mtext(
  text = "Densité empirique des magnitudes dans le jeu de données quakes",
  outer = TRUE, cex = 1.2, line = 1.5
)

# Réattribution des valeurs par défaut aux paramètres graphiques
par(all_par_default)
layout(matrix(1))

2.8 Aspects techniques

Créer un graphique en R signifie soumettre un programme R qui génère le graphique. Pour produire de nouveau le même graphique, il suffit de conserver le programme permettant de générer le graphique et de le soumettre de nouveau dans la console. Le fait de produire le graphique par un programme plutôt que par un menu dans lequel nous sélectionnons des options permet d’automatiser le travail et de sauver du temps lorsque nous avons à produire plusieurs graphiques similaires.

par("din")

# ou
dev.size()

## [1] 7 5

windows(width = 10, height = 7.5)

# Ouverture de la connexion avec un fichier
png("test.png")

# Code pour créer le graphique
plot(x = quakes$mag, y = quakes$stations)
# potentiellement plusieurs lignes de code ici

# Fermeture de la connexion avec le fichier
dev.off()

# Calcul des fréquences
freq_mag_catego <- table(quakes$mag_catego)
# Production du diagramme à barres
out_barplot <- barplot(
  height = freq_mag_catego, 
  xlab = "modalité de magnitude",
  ylab = "fréquence",
)
out_barplot

##      [,1]
## [1,]  0.7
## [2,]  1.9
## [3,]  3.1

# Ajout d'annotations textuelles (valeurs des fréquences représentées)
text(
  x = out_barplot,      # coordonnées en x (centres des bâtons) tirées de out_barplot
  y = freq_mag_catego,  # coordonnées en y (hauteurs des bâtons) tirées de freq_mag_catego
  labels = freq_mag_catego,
  pos = c(1, 1, 3)      # annotations positionnée sous la coordonnée pour les 2 premiers
)                       # bâtons, mais au dessus de la coordonnée pour le dernier bâton

2.9 Point de vue

La fonction générique plot choisit un bon type de graphique à produire selon le nombre et la nature des variables reçues en entrée.

Sinon, les fonctions graphiques de base en R font très peu de choix pour l’utilisateur.

Les graphiques initialisés sont typiquement minimalistes. Nous y ajoutons ce que nous voulons. Et les possibilités sont nombreuses.

• Avantage : Nous avons le plein contrôle sur l’apparence du graphique.
• Désavantage : Il faut parfois travailler fort pour arriver à nos fins.

par_default <- par(mfrow = c(1,2))
plot(stations ~ mag, data = quakes, subset = region == "Ouest", main = "Region Ouest")
plot(stations ~ mag, data = quakes, subset = region == "Est", main = "Region Est")
par(par_default)

plot(
  stations ~ mag, data = quakes, 
  pch = as.numeric(region), col = as.numeric(region) + 2
)

# Initialisation d'un graphique vide, mais avec les bonnes étendues
plot(stations ~ mag, data = quakes, type = "n")
# Ajout des points pour la région Ouest
points(stations ~ mag, data = quakes, subset = region == "Ouest", pch = 1, col = 3)
# Ajout des points pour la région Est
points(stations ~ mag, data = quakes, subset = region == "Est", pch = 2, col = 4)

par_default <- par(pty = "s")  # pty = "s" permet d'avoir une région graphique carrée
plot(
  lat ~ long, data = quakes,
  asp = 1,  # asp = 1 permet d'avoir des axes sur la même échelle, 
  # ce qui est préférable ici, car les variables sont des coordonnées géographiques
  cex = 3*(mag - min(mag))/(max(mag) - min(mag)) + 1, pch = 20,
  # la taille du symbole dépend de la valeur de la variable mag
  col = ifelse(region == "Ouest", rgb(1, 0, 0, 0.3), rgb(0, 0, 1, 0.3))
  # la couleur du symbole dépend du facteur région
  # des couleurs transparentes sont utilisées
)
par(par_default)

5.1 Graphiques 3D

L’utilisation de 3D pour la représentation de données catégoriques est à éviter, car elle nuit à la lisibilité du graphique [5]. Les graphiques 3D peuvent cependant être utiles pour visualiser une surface.

x <- y <- seq(from = -1, to = 1, length = 100)
grille <- expand.grid(x = x, y = y)
z <- grille$x^2 + grille$y^2
persp(x = x, y = y, z =  matrix(z, ncol = length(x)), zlab = "z")

5.2 Graphiques interactifs

Un graphique interactif est un graphique qui n’est pas statique (une image fixe), mais qui est plutôt capable d’interagir avec la personne qui l’observe. Les graphiques produits par le package rgl peuvent donc être qualifiés d’interactifs.

La forme la plus simple et usuelle d’interaction est de fournir de l’information supplémentaire lorsque la souris est placée sur certains éléments du graphique. Une forme plus avancée d’interaction est de modifier certains éléments du graphique en fonction de choix fait par l’observateur, par exemple via des boutons ou un menu cliquable.

Ce genre de graphique se visualise typiquement dans un navigateur internet. Il s’intègre facilement à un document HTML (comme une page web), mais pas à un document PDF puisque ce type de document est statique.

Les tutoriels suivants, réalisés par d’anciens étudiants de ce cours, portaient sur des packages R pour la création de graphiques interactifs. Pour voir des exemples de graphiques interactifs, vous pouvez allez consulter ces tutoriels. Le package abordé dans le premier tutoriel de cette liste est particulièrement intéressant. Il permet de créer facilement en R des graphiques Plotly (https://plot.ly/), une application web de production de graphiques interactifs très populaire.

• package plotly mentionné ci-dessus :
  https://stt4230.rbind.io/tutoriels_etudiants/hiver_2018/plotly/
• package googleVis pour créer des Google charts :
  https://stt4230.rbind.io/tutoriels_etudiants/hiver_2018/googlevis/
• package highcharter basé sur la librairie JavaScript Highcharts, pour produire divers graphiques interactifs :
  https://stt4230.rbind.io/tutoriels_etudiants/hiver_2018/highcharter/
• package ggiraph pour rendre des graphiques ggplot2 interactifs :
  https://stt4230.rbind.io/tutoriels_etudiants/hiver_2018/ggiraph/
• packagedygraphs, basé sur la librairie JavaScript du même nom, pour produire des graphiques temporels interactifs : https://stt4230.rbind.io/tutoriels_etudiants/hiver_2019/dygraphs/

Mentionnons en terminant que les applications Shiny, développés par RStudio, permettent aussi de rendre n’importe quel graphique R interactif. Ces applications sont très bien documentées ici : https://shiny.rstudio.com/

5.3 Cartes géographiques

Il est possible de créer des cartes géographiques avec R. Sans entrer dans les détails les références suivantes présentent divers packages R pour la création de cartes :

• package maps (au besoin avec mapdata et mapproj)
• package leaflet : permet de créer des cartes interactives avec la librairie JavaScript du même nom https://leafletjs.com/
  • tutoriel réalisé par un ancien étudiant du cours : https://stt4230.rbind.io/tutoriels_etudiants/hiver_2020/leaflet/
• package cartography : permet de créer différentes représentations cartographiques en R
• package tmap : permet notamment de facilement créer des cartes choroplèthes (cartes géographiques intégrant des couleurs dans des régions selon le niveau d’une variable)
• package ggmap : permet d’intégrer une carte Google Maps (requière un compte sur https://cloud.google.com/maps-platform/ pour avoir accès aux cartes) ou Stamen Maps à un graphique produit avec ggplot2
• package sf : manipulation de données spatiales
• Références mentionnant divers packages R pour la production de cartes géographiques :
  • CRAN task view : https://CRAN.R-project.org/view=Spatial
  • Blogue bilingue (anglais/français) : https://statnmap.com/fr/
  • Chapitre d’un livre web : https://geocompr.robinlovelace.net/adv-map.htm

library(maps)
map(
  database = "world", 
  fill = TRUE, col = "gray90",
  xlim = c(115, 190), ylim = c(-50, 0)
)
points(
  x = quakes$long, y = quakes$lat, 
  pch = 20, col = rgb(0, 0, 1, 0.3)
)