Tracer des lignes horizontales, verticales, à pente et de régression sur un graphique R de base
Ajoutez des lignes droites à un graphique R de base avec abline() : une ligne horizontale (h=), une ligne verticale (v=), une ligne ordonnée à l’origine/pente (a, b) et une droite de régression ajustée (reg = lm()). Plus segments() pour des segments de ligne, lines() pour relier des points, et le style lty/lwd/col.
abline() — aucun package nécessaire.abline(h = ...) trace des lignes horizontales ; abline(v = ...) trace des lignes verticales (passez un vecteur pour en tracer plusieurs).abline(a, b) trace une ligne à partir d’une ordonnée à l’origine et d’une pente ; abline(reg = lm(...)) trace la droite de régression d’un modèle ajusté.lines() et tracez un segment de ligne fini avec segments().col (couleur), lwd (épaisseur) et lty (type : 1 continu, 2 tirets, 3 pointillés).Vous avez un nuage de points ou un histogramme et vous voulez y marquer quelque chose — un seuil, une moyenne, une tendance ajustée. En base R, c’est une seule fonction : abline(). Vous l’appelez après plot() et elle trace une ligne droite sur la figure courante.
abline() couvre quatre tâches en un seul appel : une ligne horizontale (h=), une ligne verticale (v=), une ligne à partir d’une ordonnée à l’origine et d’une pente (a, b), et la droite de régression d’un modèle lm() ajusté (reg=). Pour tout ce qui doit s’arrêter à l’intérieur du graphique plutôt que de le traverser, vous faites appel à segments() ; pour relier une suite de points en un chemin, vous utilisez lines(). Cette leçon les parcourt tous, puis le style col/lwd/lty qui s’applique à chacun d’eux.
Vous préférez la grammaire des graphiques ? ggplot2 ajoute des lignes de référence avec geom_hline()/geom_vline() et une tendance avec geom_smooth() — voir ajouter des lignes dans la série ggplot2.
Un seul appel à abline() prend ceux de ces arguments qui correspondent à la ligne que vous voulez :
abline(a = NULL, b = NULL, h = NULL, v = NULL, reg = NULL, coef = NULL, col, lwd, lty)| Argument | Ce qu’il fait |
|---|---|
h |
Valeur(s) y pour la (les) ligne(s) horizontale(s). Passez un vecteur pour en tracer plusieurs d’un coup. |
v |
Valeur(s) x pour la (les) ligne(s) verticale(s). |
a, b |
Ordonnée à l’origine (a) et pente (b) d’une ligne droite. |
reg |
Un modèle ajusté (p. ex. lm(y ~ x)) — trace sa droite de régression. |
coef |
Un vecteur de longueur 2 c(intercept, slope) — même ligne que a, b. |
col, lwd, lty |
Couleur, épaisseur et type de ligne (1 continu, 2 tirets, 3 pointillés). |
Le reste de la leçon, ce sont ces arguments en pratique.
Le cas de tous les jours : un nuage de points avec sa tendance ajustée par-dessus. Ajustez le modèle avec lm(), tracez les points avec plot(), puis passez le modèle à abline(reg = ...) — elle lit l’ordonnée à l’origine et la pente sur l’ajustement et trace la ligne. Nous utilisons les données intégrées cars (distance de freinage dist en fonction de la vitesse speed).
# Fit the linear model: distance as a function of speed
reg <- lm(dist ~ speed, data = cars)
plot(cars$speed, cars$dist,
xlab = "Speed (mph)", ylab = "Stopping distance (ft)",
pch = 19, col = "gray40")
# Draw the fitted regression line
abline(reg, col = "#3a86d4", lwd = 2)
abline(reg, ...) est le raccourci — en passant l’objet lm comme premier argument, abline() en extrait automatiquement les coefficients. Si vous avez déjà les nombres, abline(coef = coef(reg)) ou abline(a = intercept, b = slope) tracent la même ligne.
abline(h = ...) trace une ligne horizontale à la valeur y que vous donnez. Un usage courant est de marquer une moyenne ou un seuil sur le graphique. Ici, nous ajoutons la distance de freinage moyenne comme référence en tirets.
plot(cars$speed, cars$dist,
xlab = "Speed (mph)", ylab = "Stopping distance (ft)",
pch = 19, col = "gray40")
# Horizontal line at the mean distance
abline(h = mean(cars$dist), col = "#e07b39", lwd = 2, lty = 2)
Passez un vecteur à h pour tracer plusieurs lignes d’un coup — abline(h = c(20, 60, 100)) pose trois références horizontales en un seul appel.
abline(v = ...) est l’image miroir : une ligne verticale à la valeur x que vous donnez. C’est la façon naturelle de marquer un seuil sur un histogramme — par exemple, la moyenne d’une distribution.
set.seed(1234)
x <- rnorm(200)
hist(x, col = "#cfe0f3", border = "white",
main = NULL, xlab = "Value")
# Vertical line at the mean
abline(v = mean(x), col = "#d1495b", lwd = 3, lty = 2)
Comme pour h, un vecteur en trace plusieurs : abline(v = c(-1, 0, 1)) marque trois positions sur l’axe des x.
Lorsque vous connaissez vous-même l’ordonnée à l’origine et la pente, passez-les comme a et b. abline(a = 1, b = 2) trace la ligne y = 1 + 2x. Le cas classique est une référence y = x (a = 0, b = 1) pour comparer deux quantités sur la même échelle.
set.seed(42)
predicted <- runif(40, 0, 10)
observed <- predicted + rnorm(40)
plot(predicted, observed,
xlab = "Predicted", ylab = "Observed",
pch = 19, col = "gray40",
xlim = c(0, 10), ylim = c(0, 10))
# y = x reference line: intercept 0, slope 1
abline(a = 0, b = 1, col = "#3a86d4", lwd = 2)
abline(coef = c(0, 1)) est la même ligne écrite comme un vecteur de coefficients — pratique quand l’ordonnée à l’origine et la pente vivent déjà ensemble dans un même objet.
abline() trace toujours une ligne qui traverse tout le graphique. Pour relier une suite précise de points en un chemin — une tendance que vous avez tracée, une courbe ajustée — utilisez plutôt lines(). Elle prend des vecteurs x et y et les joint dans l’ordre.
x <- 1:20
y <- 2 + 0.5 * x + rnorm(20)
plot(x, y, pch = 19, col = "gray40",
xlab = "x", ylab = "y")
# Connect a smooth sequence on top of the points
lines(x, 2 + 0.5 * x, col = "#3a86d4", lwd = 2)
lines() suit exactement vos x/y, donc elle suit les courbes des données — contrairement à abline(), qui est toujours droite. Triez d’abord vos x si les points ne sont pas déjà en ordre, sinon le chemin fera des zigzags.
segments() trace une ligne finie entre deux points : de (x0, y0) à (x1, y1). Utilisez-la lorsqu’une ligne doit commencer et s’arrêter à l’intérieur du graphique plutôt que de courir d’un bord à l’autre — par exemple, en faisant descendre un repère jusqu’à un axe.
plot(cars$speed, cars$dist,
xlab = "Speed (mph)", ylab = "Stopping distance (ft)",
pch = 19, col = "gray40")
# Highlight one point and drop a segment to the x-axis
i <- which.max(cars$dist)
points(cars$speed[i], cars$dist[i], pch = 19, col = "#d1495b", cex = 1.5)
segments(x0 = cars$speed[i], y0 = 0,
x1 = cars$speed[i], y1 = cars$dist[i],
col = "gray50", lty = 2)
segments() accepte aussi des vecteurs, donc vous pouvez tracer plusieurs segments en un seul appel — passez x0, y0, x1, y1 comme vecteurs parallèles et chaque ligne devient un segment.
Chaque fonction de ligne — abline(), lines(), segments() — prend les trois mêmes arguments de style. col fixe la couleur, lwd l’épaisseur (un multiplicateur ; 1 est la valeur par défaut), et lty le type : 1 continu, 2 tirets, 3 pointillés, 4 point-tiret, 5 tirets longs, 6 deux tirets. Voici plusieurs appels à abline() montrant l’éventail.
plot(NA, xlim = c(0, 10), ylim = c(0, 6),
xlab = "x", ylab = "y")
abline(h = 5, col = "#3a86d4", lwd = 1, lty = 1) # solid
abline(h = 4, col = "#e07b39", lwd = 2, lty = 2) # dashed
abline(h = 3, col = "#5fad56", lwd = 2, lty = 3) # dotted
abline(h = 2, col = "#d1495b", lwd = 3, lty = 4) # dot-dash
abline(h = 1, col = "#9b5de5", lwd = 3, lty = 5) # long-dash
text(0.3, c(5, 4, 3, 2, 1) + 0.25,
c("lty=1 solid", "lty=2 dashed", "lty=3 dotted", "lty=4 dot-dash", "lty=5 long-dash"),
adj = 0, cex = 0.8)
Ces noms fonctionnent aussi comme chaînes de caractères : lty = "dashed" revient à lty = 2. Choisissez ce qui se lit le plus clairement — une ligne de référence en tirets garde un seuil visuellement distinct de votre ligne de données.
Changez le type de ligne, la couleur ou le modèle de régression et appuyez sur Run — cela s’exécute dans votre navigateur via webR, sans installation.
Demandez à Prova « pourquoi ma ligne abline n’apparaît-elle pas sur le graphique ? » — elle répond avec du code base R que vous pouvez exécuter, donc la correction est reproductible. The runtime is the judge. Demander à Prova →
abline() ne trace rien. abline() ajoute au graphique courant, donc vous devez d’abord appeler plot() (ou hist(), boxplot(), …) — l’appeler sur un périphérique vierge sans graphique ouvert ne fait rien. Vérifiez aussi que la valeur est à l’intérieur de l’étendue des axes : abline(h = 1000) sur des données qui plafonnent à 100 trace une ligne hors écran.
La droite de régression est plate ou fausse. Passez l’objet modèle à reg, pas la formule : abline(reg = lm(y ~ x)), pas abline(lm) avec un argument errant. Et rappelez-vous que abline(reg) attend un modèle à un seul prédicteur — pour y ~ x1 + x2, il n’y a pas de ligne droite unique à tracer.
lines() fait des zigzags sur le graphique. lines() joint les points dans l’ordre où ils apparaissent dans vos vecteurs. Si votre x n’est pas trié, le chemin saute d’avant en arrière. Triez d’abord par x (ord <- order(x); lines(x[ord], y[ord])).
Appelez abline() après plot(). Utilisez abline(h = value) pour une ligne horizontale, abline(v = value) pour une ligne verticale, abline(a = intercept, b = slope) pour une ligne à pente, ou abline(reg = lm(y ~ x)) pour une droite de régression. Elle trace sur la figure courante.
Utilisez abline(h = ...) pour l’horizontale et abline(v = ...) pour la verticale, en donnant la valeur y ou x où la ligne doit se trouver. Passez un vecteur — abline(v = c(2, 4, 6)) — pour tracer plusieurs lignes en un seul appel.
Ajustez le modèle avec lm(), tracez le nuage avec plot(), puis appelez abline() sur le modèle : abline(lm(dist ~ speed, data = cars)). abline() lit l’ordonnée à l’origine et la pente sur l’ajustement et trace la ligne à travers les points.
abline() trace une seule ligne droite à travers tout le graphique (depuis h/v/pente/régression). segments() trace une ligne finie entre deux points (x0, y0)–(x1, y1). lines() relie une suite de points x/y dans l’ordre, donc elle peut suivre les courbes des données.
Utilisez lty pour le type (1 continu, 2 tirets, 3 pointillés, 4 point-tiret, 5 tirets longs) et lwd pour l’épaisseur (1 est la valeur par défaut ; plus élevé est plus épais). Ils fonctionnent sur abline(), lines() et segments() de la même manière — p. ex. abline(h = 0, lty = 2, lwd = 2).
Le nuage de points ci-dessous montre la distance de freinage en fonction de la vitesse. Ajoutez deux lignes : la droite de régression ajustée en azur, et une ligne horizontale en tirets à la distance de freinage moyenne en orange.
Ajustez le modèle avec lm(dist ~ speed, data = cars) et passez-le à abline(). Pour la moyenne, utilisez abline(h = mean(cars$dist), ...) avec lty = 2 pour le style en tirets.
abline(lm(dist ~ speed, data = cars), col = "#3a86d4", lwd = 2)
abline(h = mean(cars$dist), col = "#e07b39", lwd = 2, lty = 2)La première lit la pente et l’ordonnée à l’origine sur l’ajustement ; la seconde trace une référence plate à la moyenne.
Vérification rapide. Vous voulez une ligne qui commence et s’arrête à l’intérieur du graphique, pas une qui traverse toute la figure. Quelle fonction utilisez-vous ?
segments(). Elle trace une ligne finie de (x0, y0) à (x1, y1). abline() traverse toujours tout le graphique ; lines() relie une suite de points.
abline() est la fonction unique pour les lignes de référence droites en base R : h= pour l’horizontale, v= pour la verticale, a/b pour ordonnée-à-l’origine-et-pente, et reg= pour une droite de régression ajustée. Quand une ligne doit s’arrêter à l’intérieur du graphique, utilisez segments(), et pour relier un chemin de points, utilisez lines() — toutes stylisées de la même façon avec col, lwd et lty.
geom_hline/geom_vline/geom_smooth si vous préférez la grammaire des graphiques.Prouvez que vous savez le faire. Maîtrisez toute la série R Base Graphics — suivez votre parcours, construisez des projets et obtenez un certificat.
Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.
dès 15 $/mois facturé annuellement
✓ Vous êtes Pro — continuez. The runtime is the judge.
Prêt à passer à la vitesse supérieure ?
Cette leçon est reproductible : chaque figure a été produite par le code montré, exécuté au moment du build (s’ils s’affichent, le code fonctionne), et le bac à sable se réexécute en direct dans votre navigateur. Modifiez n’importe quel bloc et appuyez sur Run. The runtime is the judge.
@online{2026,
author = {},
title = {abline en R : ajouter des lignes droites à un graphique},
date = {2026-06-27},
url = {https://www.datanovia.com/learn/data-visualization/r-base/add-lines},
langid = {fr}
}