Accéder au contenu principal

15 questions que tous les utilisateurs de R se posent sur les graphiques

There are different types of R plots, ranging from the basic graph types to complex types of graphs. Here we discover how to create these.
· 15 min lire

Explorez l'IA

explore datacamp's r course library banner

R permet de créer différents types de tracés, des graphiques de base comme les courbes de densité, dot plots, boxplots et nuages de points, jusqu’aux graphes plus complexes sur le plan statistique comme les probability plots.

Vous pouvez ainsi passer de graphiques simples avec peu de personnalisation à des graphiques avancés entièrement personnalisés, y compris interactifs. Pourtant, nos graphiques R ne donnent pas toujours le résultat souhaité : Stack Overflow regorge de questions à ce sujet, avec de nombreux thèmes récurrents.

C’est pourquoi DataCamp a rassemblé les questions les plus fréquentes et leurs meilleures réponses dans un seul article.

Pour vous exercer à créer des graphiques en R, essayez ce cours sur la visualisation de données en R.

Les 15 questions sur les graphiques R

1. Comment tracer un graphique R vide

Ouvrir un nouveau cadre de tracé

Vous pouvez ouvrir un cadre vide et activer le périphérique graphique en R comme suit : 
plot.new()

# Or try out the following command 
# frame()

Remarque : les fonctions plot.new() et frame() définissent un nouveau cadre de tracé sans axes, étiquettes ni contour. Elles indiquent qu’un nouveau graphique va être créé : une nouvelle fenêtre s’ouvre si aucune n’est active, sinon la fenêtre existante est prête à accueillir le nouveau tracé. Plus d’infos ici.

  • x11() peut aussi ouvrir un nouveau périphérique Windows pour le système X Window (version 11) !
  • quartz() lance un pilote graphique pour macOS.

Définir les dimensions de la fenêtre graphique

Vous pouvez aussi utiliser la fonction plot.window() pour fixer les dimensions horizontales et verticales du graphique vide que vous venez d’ouvrir :

plot.new()
pWidth = 3
pHeight = 2
plot.window(c(0,pWidth),
            c(0,pHeight))

Tracer un vrai graphique vide

Vous pouvez produire un graphique vide avec la fonction plot(). Ajoutez ensuite axes, étiquettes et titre avec les fonctions mtext() et title().

# Draw an empty plot
plot(5, 
     5, 
     type="n", 
     axes=FALSE, 
     ann=FALSE, 
     xlim=c(0, 10), 
     ylim = c(0,10))

# Add text to the x-axis
mtext("x-axis", 
      side=1)

# Add text to the y-axis
mtext("y-axis",
      side=2) 

# Add a title
title("An R Plot")

Vous donnez les coordonnées (5,5) au graphique, mais vous ne tracez rien en fixant l’argument type à "n".

Astuce : essayez "p" ou "b" pour voir la différence !

Vous n’ajoutez pas d’annotation, mais vous fixez des limites de 0 à 10 sur les axes x et y.

Enfin, vous pouvez dessiner un cadre autour du tracé avec box() et ajouter des points avec points() :

# Draw an empty plot
plot(5, 
     5, 
     type="n", 
     axes=FALSE, 
     ann=FALSE, 
     xlim=c(0, 10), 
     ylim = c(0,10))

# Add text to the x-axis
mtext("x-axis", 
      side=1)

# Add text to the y-axis
mtext("y-axis",
      side=2) 

# Add a title
title("An R Plot")

#Draw a box
box()

#Put (red) point in the plot at (5,5)
points(5,
       5, 
       col="red") 
points(5, 
       7, 
       col="orange", 
       pch=3, 
       cex=2)
points(c(0, 0, 1), 
       c(2, 4, 6), 
       col="green", 
       pch=4)

Remarque : vous pouvez passer vos x et y sous forme de vecteurs pour tracer plusieurs points d’un coup. L’argument pch choisit le symbole, et cex règle l’échelle du texte et des symboles par rapport à la valeur par défaut.

Astuce : pour voir quel numéro correspond à quel symbole, cliquez ici.

2. Comment définir les étiquettes d’axes et le titre des graphiques R

Les axes des graphiques R figurent parmi les sujets les plus populaires sur Stack Overflow. Les questions sont variées.

Poursuivez la lecture pour découvrir les plus fréquentes repérées par DataCamp !

Nommer les axes (avec exposants ou indices) et ajouter un titre

Vous pouvez facilement nommer les axes et ajouter un titre pour rendre votre graphique plus clair pour votre public.

Ajoutez les arguments main pour le titre principal, sub pour le sous‑titre, xlab pour l’axe des x et ylab pour l’axe des y.

Remarque : pour des exposants ou indices dans le titre, utilisez expression() avec ^ pour l’exposant et des crochets pour l’indice dans l’argument main de plot().

Testez‑le dans le bloc DataCamp Light ci‑dessous :

# The data
x <- seq(0,2*pi,0.1)
y <- sin(x)

# Plot the data
plot(x,
     y,
     main=expression("main title"^2), 
     sub=expression("sub-title"[2]), 
     xlab="x-axis label", 
     ylab="y-axis label")

Vous pouvez aussi afficher des lettres grecques dans les étiquettes d’axes en combinant expression() et paste(). Exécutez :

# The data
x <- seq(0,2*pi,0.1)
y <- sin(x)

# Plot the data
plot(x,
     y,
     xlab = expression(paste("Greek letter ", phi)),
     ylab = expression(paste("Greek letter ",mu)))

Ajuster l’apparence des étiquettes d’axes

Pour modifier l’apparence des étiquettes des axes x et y, utilisez col.lab (couleur) et cex.lab (taille relative au réglage par défaut cex). 
# The data
x <- seq(0,2*pi,0.1)
y <- sin(x)

# Plot the data
plot(x,
     y,
     main=expression("main title"^2), 
     sub=expression("sub-title"[2]), 
     xlab="x-axis label", 
     ylab="y-axis label",
     col.lab="blue",
     cex.lab=0.75)

Pour plus d’informations, consultez cette page.

Supprimer les étiquettes et annotations d’axes

Pour masquer les valeurs des axes, passez xaxt et yaxt à "n" (suppression du tracé des axes). Toute autre valeur tracera l’axe.

Ensuite, mettez ann à FALSE pour retirer les étiquettes. 
# The data
x <- seq(0,2*pi,0.1)
y <- sin(x)

# Plot the data
plot(x,
     y,
     xaxt="n",
     yaxt="n",
     ann=FALSE)

Astuce : si ce n’est pas l’info recherchée, voyez cette page.

Faire pivoter les étiquettes d’axes

Ajoutez l’argument las à la fonction axis() pour orienter les nombres des axes : 
# The data
x <- seq(0,2*pi,0.1)
y <- sin(x)

# Plot the data, no axes
plot(x,
     y, 
     axes=FALSE)

# Draw a box
box()

# Add (modified) axes to the plot
axis(2, 
     las=2)
axis(1, 
     las=0)

Remarque : cela suppose d’abord de tracer sans axes via plot() puis d’ajouter les axes avec axis().

las accepte : 0 (parallèle à l’axe, défaut), 1 (horizontal), 2 (perpendiculaire), 3 (vertical).

Pour en savoir plus sur axis(), continuez ci‑dessous.

Déplacer les axes

Vous voulez déplacer vos axes ? Utilisez axis() pour choisir où dessiner chaque axe. Par exemple, l’axe des x en haut et l’axe des y à droite.

Rappel : avec axis(), 1 = bas, 2 = gauche, 3 = haut, 4 = droite.

Voici comment passer 3 et 4 pour haut et droite : 
# The data
x<-seq(0,2*pi,0.1)
y<-sin(x)

# Plot the data, but don't plot axes or annotations
plot(x,
     y,
     axes=FALSE, 
     ann=FALSE)

# Draw the x-axis above the plot area
axis(3)

# Draw the y-axis to the right of the plot area
axis(4)

# Draw a box
box()

Vous tracez d’abord sans axes ni annotations, puis vous ajoutez les axes souhaités et leur position.

La flexibilité de axis() ne s’arrête pas là ! Voyez la suite.

Astuce : consultez la dernière question pour déplacer le texte des axes avec hjust et vjust.

3. Comment ajouter et ajuster l’espacement des graduations

Modifier l’espacement des graduations

Laisser R décider des graduations peut être frustrant. Voici comment les ajuster.

1. Utiliser axis() pour maîtriser les graduations

Considérez le code suivant : 
# Define the position of tick marks
v1 <- c(0,pi/2,pi,3*pi/2,2*pi)

# Define the labels of tick marks
v2 <- c("0","Pi/2","Pi","3*Pi/2","2*Pi")

# The data
x <- seq(0,2*pi,0.1)
y <- sin(x)

# Plot the data
plot(x,
     y,
     xaxt = "n")

# Add an axis to the plot 
axis(side = 1, 
     at = v1, 
     labels = v2,
     tck=-.05)

Vous définissez d’abord la position des graduations et leurs libellés, puis vous tracez en supprimant l’axe (xax t = "n").

Ensuite :

  • axis() choisit le côté (1 bas, 2 gauche, 3 haut, 4 droite) ;
  • at indique où dessiner les graduations (ici V1) ;
  • labels fournit les libellés (ici V2) ;
  • tck règle la direction/longueur des graduations (valeur négative : sous l’axe).

Astuce : passez une valeur positive à tck pour voir la différence.

Vous pouvez aussi régler la taille (tcl) et l’apparence des libellés (cex.axis, col.axis, font.axis). 
# Define the position of tick marks
v1 <- c(0,pi/2,pi,3*pi/2,2*pi)

# Define the labels of tick marks
v2 <- c("0","Pi/2","Pi","3*Pi/2","2*Pi")

# The data
x <- seq(0,2*pi,0.1)
y <- sin(x)

# Plot the data
plot(x,
     y,
     xaxt = "n")

# Add axis to the plot 
axis(side = 1, 
     at = v1, 
     labels = v2,
     tck=-.1,
     tcl = -0.5,
     cex.axis=1.05,
     col.axis="blue",
     font.axis=5)

2. Utiliser d’autres fonctions pour contrôler les graduations

Vous pouvez aussi utiliser par() et plot() avec l’argument xaxp (positions des graduations extrêmes sur l’axe des x et nombre d’intervalles) :

# The data
x <- seq(0,2*pi,0.1)
y <- sin(x)

# Plot the data
plot(x,
     y,
     xaxp = c(0, 2*pi, 5))

Variante équivalente :

# The data 
x <- seq(0,2*pi,0.1)
y <- sin(x)

# Plot the data 
plot(x, 
     y, 
     xaxt="n")

# Use `par()` to set graphical `xaxp` parameter
par(xaxp= c(0, 2*pi, 2)) 

# Add an axis to the plot 
axis(1)

Remarque : cela ne fonctionne pas en échelle logarithmique. Avec par(xlog=T), la signification des trois valeurs de xaxp change : pour une petite plage, n est négatif, sinon n vaut 1:3 et x1 et x2 sont les plus petites et plus grandes puissances de 10 dans les coordonnées utilisateur, 10 ^ par(“usr”)[1:2].

Exemple : 
n <- 1

# The data
x <- seq(0, 10000, 1)
y <- exp(n)/(exp(n)+x)

# Set graphical parameters `xlog` and `xaxp`
par(xlog=TRUE, 
    xaxp= c(1, 4, 3))

# Pot the data 
plot(x, 
     y, 
     log="x")

Ici, vous utilisez par() : vous mettez xlog à TRUE et fixez xaxp pour les graduations extrêmes et le nombre d’intervalles (min = 1, max = 4, intervalles = 3).

Vous tracez ensuite x et y avec l’argument log pour indiquer l’axe à mettre en log ("x", "y" ou "xy").

Exemple avec les deux axes en log : 
n <- 1

# The data
x <- seq(0, 20, 1)
y <- exp(x)/(x)

# Set graphical parameters `xlog` and `xaxp`
par(xlog=TRUE, 
    xaxp= c(1, 4, 3))
# Set graphical parameters `ylog` and `yaxp`
par(ylog=TRUE, 
    yaxp= c(1, 11, 2)) 

# Plot the data 
plot(x, 
     y, 
     log="xy")

Ajouter des graduations secondaires

Ajoutez rapidement des « petites » graduations avec minor.tick() du package Hmisc : 
# Import `Hmisc` library
library(Hmisc)

# Make a new plot
plot.new()

# Set minor tick mark
minor.tick(nx = 1.5, 
           ny = 2, 
           tick.ratio=0.75)
  • nx définit le nombre d’intervalles entre graduations majeures sur l’axe x (1 = supprime) ;
  • ny fait de même pour l’axe y ;
  • tick.ratio fixe le ratio de longueur petites/grandes graduations (longueur des grandes issue de par(tck=x)).

4. Comment créer deux axes des x ou des y différents

Première option : créez un premier tracé puis utilisez par() avec new=TRUE pour éviter d’effacer le périphérique graphique : 
# Set a seed 
set.seed(101)

# The data
x <- 1:10
y <- rnorm(10)
z <- runif(10, min=1000, max=10000)

# Plot the data
plot(x, y) 

# Don't clean the frame before drawing
par(new = TRUE)

Puis créez le second tracé avec plot() en ajustant notamment type, axes, bty, xlab et ylab :

  • type : passez "l" pour un tracé en lignes ;
  • axes : FALSE pour ne tracer aucun axe ;
  • bty : supprime le cadre autour du graphique ;
  • xlab et ylab : chaînes vides pour ne pas afficher d’étiquettes.

Testez‑le dans le bloc ci‑dessous (le code précédent est déjà chargé dans l’environnement) :

plot(x, 
     z, 
     type = "l", 
     axes = FALSE,
     bty = "n", 
     xlab = "", 
     ylab = "")

Ajoutez ensuite l’axe et le libellé en marge avec axis() et mtext().

Pour ajouter un axe à droite, passez side=4 à axis(). Indiquez at avec des valeurs « belles » couvrant l’étendue de z via pretty(), afin de refléter l’échelle du second graphe.

Essayez ci‑dessous :

axis(side=4, 
     at = pretty(range(z)))
mtext("z", 
      side=4, 
      line=3)

Remarque : side accepte 1 (bas), 2 (gauche), 3 (haut), 4 (droite). line indique la marge utilisée.

Résultat final :

set.seed(101)
x <- 1:10
y <- rnorm(10)
z <- runif(10, min=1000, max=10000)
plot(x, y) 
par(new = TRUE)
plot(x, 
     z, 
     type = "l", 
     axes = FALSE, 
     bty = "n", 
     xlab = "", 
     ylab = "")
axis(side=4, 
     at = pretty(range(z)))
mtext("z", 
      side=4, 
      line=3)

En exercice supplémentaire, construisez un graphique avec deux axes des x différents ! Essayez dans ce bloc :

plot.new()
set.seed(101)
x <- 1:10
y <- rnorm(10)
z <- runif(10, min=1000, max=10000) 
par(mar = c(5, 4, 4, 4) + 0.3)
plot(x, y)
par(new = TRUE)
plot(z, y, type = "l", axes = FALSE, bty = "n", xlab = "", ylab = "")
axis(side=3, at = pretty(range(z)))
mtext("z", side=3, line=3)

Notez que des packages automatisent ces opérations : twoord.plot() (plotrix) et doubleYScale() (latticeExtra) sont pratiques et souvent plus rapides :

# Import `latticeExtra`
library(latticeExtra)

# The data
chol <- read.table(url("http://assets.datacamp.com/blog_assets/chol.txt"), header = TRUE)
Age <- chol$AGE
Chol <- chol$CHOL
Smoke <- chol$SMOKE
State <- chol$MORT

# Create a bivariate scatterplot `a` 
a <- xyplot(Chol ~ Age|State)

# Create a bivariate scatterplot `b` 
b <- xyplot(Smoke ~ Age|State)

# Draw the two plots with different y scales 
doubleYScale(a, b, style1 = 0, style2 = 3, add.ylab2 = TRUE, columns=3)

Remarque : l’exemple ci‑dessus utilise ce jeu de données. Besoin d’un rappel sur l’import de données ou read.table() ? Consultez le tutoriel DataCamp sur l’import de données en R.

5. Comment ajouter ou modifier la légende d’un graphique R

Ajouter et modifier une légende avec R de base

Ajoutez une légende avec legend() : 
# The data
x <- seq(0,pi,0.1)
y1 <- cos(x)
y2 <- sin(x)

# Plot 
plot(c(0,3), c(0,3), type="n", xlab="x", ylab="y")

# Draw lines
lines(x, y1, col="red", lwd=2)
lines(x, y2, col="blue", lwd=2)

# Add legend to plot 
legend("topright", 
       inset=.05, 
       cex = 1, 
       title="Legend", 
       c("Cosinus","Sinus"), 
       horiz=TRUE, 
       lty=c(1,1), 
       lwd=c(2,2), 
       col=c("red","blue"), 
       bg="grey96")

Notez que pt.cex et title.cex ne fonctionnent pas toujours comme prévu. Contournements :

  1. Changer la police du titre/texte via text.font dans legend() :
# The data
x <- seq(0,pi,0.1)
y1 <- cos(x)
y2 <- sin(x)

# Plot 
plot(c(0,3), c(0,3), type="n", xlab="x", ylab="y")

# Draw lines
lines(x, y1, col="red", lwd=2)
lines(x, y2, col="blue", lwd=2)

# Add legend
legend("topright", 
       inset=.05, 
       cex = 1, 
       title="Legend", 
       c("Cosinus","Sinus"), 
       horiz=TRUE, 
       lty=c(1,1), 
       lwd=c(2,2), 
       col=c("red","blue"), 
       bg="grey96",
       text.font=3)
  1. Tracer la légende deux fois avec des valeurs cex différentes
# The data
x <- seq(0,pi,0.1)
y1 <- cos(x)
y2 <- sin(x)

# Plot
plot(c(0,3), c(0,3), type="n", xlab="x", ylab="y")

# Draw lines
lines(x, y1, col="red", lwd=2)
lines(x, y2, col="blue", lwd=2)

# Add subtitles for legend
legend("topright",
       inset=.05,
       cex = 0.75,
       c("Cosinus","Sinus"),
       title="",
       horiz=TRUE,
       lty=c(1,1), 
       lwd=c(2,2), 
       col=c("red","blue"))

# Add title to legend 
legend(2.05, 2.97, 
       inset=.05,
       c("",""),
       title="Legend",
       cex=1.15, 
       bty="n")

Astuce : pour les couleurs disponibles en R, voyez ce PDF très utile.

Ajouter et modifier la légende et les libellés avec ggplot2

Ajouter une légende par défaut dans ggplot2 est simple : 
# Load in `ggplot2`
library(ggplot2)

# Read in the data
chol <- read.table(url("http://assets.datacamp.com/blog_assets/chol.txt"), 
                   header = TRUE)

# Plot the data 
ggplot(chol, aes(x=chol$WEIGHT, 
                 y=chol$HEIGHT)) + 
  geom_point(aes(colour = factor(chol$MORT), 
                 shape=chol$SMOKE)) + 
  xlab("Weight") + 
  ylab("Height")

Puis personnalisez l’apparence de la légende.

Deux approches pour changer titre et libellés dans ggplot2 :

  1. Modifier les « scales » pour définir titres et libellés
Si vous utilisez les esthétiques colour ou shape, changez noms et libellés via scale_color_discrete() et scale_shape_discrete() : 
# Load in `ggplot2`
library(ggplot2)

# Read in data
chol <- read.table(url("http://assets.datacamp.com/blog_assets/chol.txt"), 
                   header = TRUE)

# Plot the data
ggplot(chol, aes(x=chol$WEIGHT, 
                 y=chol$HEIGHT)) + 
  geom_point(aes(colour = factor(chol$MORT), 
                 shape = chol$SMOKE)) + 
  xlab("Weight") + 
  ylab("Height") + 
  theme(legend.position=c(1,0.5),
        legend.justification=c(1,1)) + 
  scale_color_discrete(name ="Condition", 
                       labels=c("Alive", "Dead")) +
  scale_shape_discrete(name="Smoker", 
                       labels=c("Non-smoker", "Sigare", "Pipe" ))

Le tracé peut sembler compressé dans l’onglet Plot de DataCamp Light, ce ne serait pas le cas dans RStudio.

Vous pouvez créer deux légendes si vous utilisez shape dans geom_point() et dans les labels.

Pour placer la légende en bas, définissez legend.position à "bottom". legend.justification permet de positionner la légende dans le tracé.

Astuce : découvrez les différentes scales et leurs options ici.

  1. Modifier le data frame pour mettre les bons niveaux de facteur
Par exemple : 
# Read in data
chol <- read.table(url("http://assets.datacamp.com/blog_assets/chol.txt"), header = TRUE)

# Manipulate the data
levels(chol$SMOKE)[levels(chol$SMOKE)=="Non-smoker"] <- "Non-smoker"
levels(chol$SMOKE)[levels(chol$SMOKE)=="Sigare"] <- "Sigare"
levels(chol$SMOKE)[levels(chol$SMOKE)=="Pipe"] <- "Pipe"
names(chol)[names(chol)=="SMOKE"]  <- "SMOKER"

# Inspect result 
head(chol)

Vous pourrez ensuite utiliser ces nouveaux libellés dans ggplot2 sans lignes de code supplémentaires pour renommer dans le tracé.

Astuce : pour une cheat sheet complète ggplot2, rendez‑vous ici.

6. Comment afficher une grille sur un graphique R

Avec R de base

Pour certains usages, il est utile d’ajouter une grille. Utilisez grid() : 
# Data
x <- c(1,2,3,4,5)
y <- 2*x

# Plot
plot(x,y)

# Grid
grid(10,10)

Avec ggplot2

Le bloc ci‑dessous montre comment forcer l’affichage d’une grille avec ggplot2. Les données chol sont déjà chargées et préparées.

Si vous voulez voir les premières lignes, affichez‑les dans la console R du bloc DataCamp Light :

# Load in `ggplot2`
library(ggplot2)

# Plot data 
ggplot(chol, aes(x=chol$WEIGHT, y=chol$HEIGHT)) + 
  geom_point(aes(colour = factor(chol$MORT), shape = chol$SMOKE)) + 
  xlab("Weight") + 
  ylab("Height") + 
  theme(panel.grid.major = element_line(colour = "grey40"),
        panel.grid.minor = element_line(colour = "grey40"))

Astuce : pour masquer la grille mineure, passez element_blank() à panel.grid.minor.

Pour colorer le fond, ajoutez panel.background = element_rect(fill = "navy"). Exemple ci‑dessous (données chol déjà chargées) :

library(ggplot2)
ggplot(chol, aes(x=chol$WEIGHT, y=chol$HEIGHT)) + 
  geom_point(aes(colour = factor(chol$MORT), shape = chol$SMOKER)) + 
  xlab("Weight") + 
  ylab("Height") + 
  scale_color_discrete(name ="Condition", labels=c("Alive", "Dead")) +
  scale_shape_discrete(name="Smoker", labels=c("Non-smoker", "Sigare", "Pipe" )) +
  theme(legend.position=c(1,0.5),
        legend.justification=c(1,1),
        panel.grid.major = element_line(colour = "grey40"),
        panel.grid.minor = element_line(colour = "grey40"),
        panel.background = element_rect(fill = "navy")
        )

7. Comment tracer un graphique avec un PNG en arrière‑plan

Vous pouvez facilement superposer un graphique sur une image .png grâce au package png. Installez‑le si nécessaire, chargez‑le avec library() et lancez‑vous.

Commencez par charger l’image avec readPNG() en précisant le chemin du fichier.

Astuce : affichez et changez votre répertoire de travail avec les commandes ci‑dessous.

Si l’image est dans votre répertoire de travail, readPNG("picture.png") suffit.

Préparez ensuite la zone de tracé et utilisez par() pour récupérer les paramètres graphiques nécessaires à rasterImage(). L’argument usr définit les bornes utilisateur (ici 1, 3, 2, 4).

Ajoutez une grille puis des lignes :

install.packages("png")
library(png)
image <- readPNG("<path to your picture>")

getwd()
setwd("<path to a folder>")

plot(1:2, type='n', main="Plotting Over an Image", xlab="x", ylab="y")

lim <- par()

rasterImage(image, lim$usr[1], lim$usr[3], lim$usr[2], lim$usr[4])

grid()
lines(c(1, 1.2, 1.4, 1.6, 1.8, 2.0), c(1, 1.3, 1.7, 1.6, 1.7, 1.0), type="b", lwd=5, col="red")

Avec le logo DataCamp, vous obtiendrez par exemple :

library(png)
image <- readPNG("datacamp.png")
plot(1:2, type="n", main="Plotting Over an Image", xlab="x", ylab="y", asp=1)
lim <- par()
rasterImage(image, lim$usr[1], lim$usr[3], lim$usr[2], lim$usr[4])
lines(c(1, 1.2, 1.4, 1.6, 1.8, 2.0), c(1.5, 1.3, 1.7, 1.6, 1.7, 1.0), type="b", lwd=5, col="red")

Plotting over DataCamp logo

Notez que readPNG() attend un fichier .png. Pour des .jpg, utilisez la librairie jpeg.

# Download an image
download.file("https://holtzyan.files.wordpress.com/2015/10/cropped-p1090518.jpg" , destfile="my_image.jpg")

# Load `jpeg` 
library(jpeg)

# Read in the jpg file 
my_image=readJPEG("my_image.jpg")

# Set up a plot area with no plot
plot(1:2, type='n', main="", xlab="x", ylab="y")

# Get the plot information
lim <- par()
rasterImage(my_image, lim$usr[1], lim$usr[3], lim$usr[2], lim$usr[4])
grid()

#Add your plot
lines(c(1, 1.2, 1.4, 1.6, 1.8, 2.0), c(1, 1.3, 1.7, 1.6, 1.7, 1.0), type="b", lwd=5, col="white")

Ici, l’image est d’abord téléchargée puis utilisée, mais vous pouvez tout aussi bien lire un fichier local avec readJPEG().

Exemple issu de la R Graph Gallery, une excellente source d’inspiration avec code et rendu au même endroit.

8. Comment ajuster la taille des points

Avec R de base

Pour modifier la taille des points, utilisez simplement l’argument cex : 
x <- c(1,2,3,4,5)
y <- c(6,7,8,9,10)

plot(x,y,cex=2,col="red")
Rappel : R offre un contrôle encore plus fin via symbols() : 
df <- data.frame(x1=1:10, 
                 x2=sample(10:99, 10), 
                 x3=10:1)
symbols(x=df$x1, 
        y=df$x2, 
        circles=df$x3, 
        inches=1/3, 
        ann=F, 
        bg="steelblue2", 
        fg=NULL)

Ici, les rayons des cercles proviennent de df$x3, et inches contrôle la taille : si positif, la plus grande dimension du symbole prend cette taille en pouces.

Avec ggplot2

Dans un scatterplot ggplot2, ajustez la taille avec size. Les données chol sont chargées : 
library(ggplot2)

ggplot(chol, 
       aes(x=chol$WEIGHT, y=chol$HEIGHT), 
       size = 2) + 
  geom_point()

Vous pouvez aussi passer size à geom_point() :

ggplot(chol, 
       aes(x=chol$WEIGHT, y=chol$HEIGHT)) + 
  geom_point(size = 2)

Le résultat est identique : testez en remplaçant la dernière ligne du bloc par ce code.

9. Comment ajuster une courbe lissée à vos données

La fonction loess() est souvent la solution favorite : elle « ajuste une surface polynomiale déterminée par un ou plusieurs prédicteurs numériques, via un lissage local ».

En bref, vous corrélez y et x dans loess() (1 à 4 prédicteurs), puis vous tracez x et y et ajoutez la courbe prédite :

x <- 1:10
y <- c(2,4,6,8,7,12,14,16,18,20)

#Estimations between data
lo <- loess(y~x)

plot(x,y)

lines(predict(lo))

10. Comment ajouter des barres d’erreur

Tracer des barres d’erreur avec R de base

Mauvaise nouvelle : R ne trace pas directement des barres d’erreur. Bonne nouvelle : vous pouvez les construire sans package additionnel !

Commencez par définir cette fonction qui calcule des statistiques de synthèse :

summarySE <- function(data=NULL, measurevar, groupvars=NULL, na.rm=FALSE,
                      conf.interval=.95, .drop=TRUE) {
    library(plyr)

    # New version of length which can handle NA's: if na.rm==T, don't count them
    length2 <- function (x, na.rm=FALSE) {
        if (na.rm) sum(!is.na(x))
        else       length(x)
    }

    # This does the summary. For each group's data frame, return a vector with
    # N, mean, and sd
    datac <- ddply(data, groupvars, .drop=.drop,
      .fun = function(xx, col) {
        c(N    = length2(xx[[col]], na.rm=na.rm),
          mean = mean   (xx[[col]], na.rm=na.rm),
          sd   = sd     (xx[[col]], na.rm=na.rm)
        )
      },
      measurevar
    )

    # Rename the "mean" column    
    datac <- rename(datac, c("mean" = measurevar))

    datac$se <- datac$sd / sqrt(datac$N)  # Calculate standard error of the mean

    # Confidence interval multiplier for standard error
    # Calculate t-statistic for confidence interval: 
    # e.g., if conf.interval is .95, use .975 (above/below), and use df=N-1
    ciMult <- qt(conf.interval/2 + .5, datac$N-1)
    datac$ci <- datac$se * ciMult

    return(datac)
}

Cette définition provient de cette source et est disponible via la librairie Rmisc.

Calculez ensuite les statistiques sur chol (déjà chargé), puis utilisez‑les pour tracer votre graphique.

Inspectez les données avant de commencer !

#Calculate some statistics for the `chol` dataset
cholc <- summarySE(chol, 
                   measurevar="CHOL", 
                   groupvars=c("MORT",
                               "SMOKER"))
#Plot the data
plot(cholc$N, 
     cholc$CHOL,
     ylim=range(c(cholc$CHOL-cholc$sd, 
                  cholc$CHOL+cholc$sd)),
     pch=19, 
     xlab="Cholesterol Measurements", 
     ylab="Cholesterol Mean +/- SD",
     main="Scatterplot With sd Error Bars"
)

#Draw arrows of a "special" type
arrows(cholc$N, 
       cholc$CHOL-cholc$sd, 
       cholc$N, 
       cholc$CHOL+cholc$sd, 
       length=0.05, 
       angle=90, 
       code=3)

Pour la liste complète des arguments de arrows(), voir ici.

Tracer des barres d’erreur avec ggplot2

Barres d’erreur = erreur standard de la moyenne

Commencez par résumer vos données avec summarySE() (package Rmisc) ou la fonction ci‑dessus. Utilisez ensuite ce data frame pour tracer et dessiner les barres d’erreur (par exemple l’erreur standard).

Par commodité, données et fonction sont chargées :

Sujets

RScience des donnéesVisualisation des données

Contenus associés

Tutoriel

Tableaux Python

Voir plus →