Graphique radar en R : diagrammes en toile d’araignée avec le package fmsb

Formatez les données, tracez radarchart(), colorez les polygones, et superposez ou facettez plusieurs groupes

Créez un graphique radar (diagramme en toile d’araignée) en R avec le package fmsb. Formatez les données avec les lignes d’en-tête max/min requises, tracez radarchart(), colorez et remplissez les polygones, personnalisez la grille et les étiquettes d’axes, et comparez plusieurs groupes sur un même graphique ou dans une grille de petits multiples.

Date de publication

27 juin 2026

Modifié

7 juillet 2026

AstucePoints clés
  • Un graphique radar (diagramme en toile d’araignée) compare un ou plusieurs cas selon plusieurs variables quantitatives, un axe par variable.
  • En R, l’outil de référence est fmsb::radarchart() — un graphique en base-graphics, sans ggplot2.
  • fmsb attend une forme de données précise : ligne 1 = le maximum de chaque axe, ligne 2 = le minimum, puis une ligne par cas. Cet en-tête est le plus gros piège.
  • Colorez la ligne avec pcol, le remplissage avec pfcol (utilisez scales::alpha() pour la transparence), et stylisez la toile avec cglcol / cglty / axislabcol / caxislabels.
  • Tracez les groupes superposés avec une légende pour une comparaison rapide, ou en petits multiples (un panneau chacun) quand vous en avez plus de trois.

Introduction

Vous avez une poignée de cas — étudiants, produits, joueurs, segments d’enquête — chacun noté sur le même ensemble de variables, et vous voulez une seule image qui montre le profil de chaque cas d’un coup d’œil : fort ici, faible là. Cette image est un graphique radar, aussi appelé diagramme en toile d’araignée ou graphique en étoile. Chaque variable obtient son propre axe rayonnant depuis le centre, et un cas est dessiné comme un polygone reliant ses valeurs à travers les axes.

En R, la voie la plus directe est fmsb::radarchart(). C’est une fonction en base-graphics (pas ggplot2), elle dessine donc vite et prend des arguments simples. La seule chose qui déroute tout le monde est la forme des données : fmsb a besoin du maximum et du minimum de chaque axe comme les deux premières lignes des données, au-dessus de vos cas réels. Réussissez cela et le reste n’est que du style. Cette leçon construit un graphique d’un seul cas jusqu’à une grille de petits multiples, en couvrant les couleurs, la grille, les étiquettes d’axes et les comparaisons multi-groupes.

Installez-le une fois :

install.packages("fmsb")

Les données

Nous utiliserons les notes d’examen de trois étudiants sur neuf matières, chacune notée de 0 à 20. Les colonnes sont les variables (les axes) ; les lignes sont les cas (les polygones). C’est du R de base et autonome, donc vous pouvez copier n’importe quel bloc et l’exécuter seul.

exam_scores <- data.frame(
  row.names   = c("Student.1", "Student.2", "Student.3"),
  Biology     = c(7.9, 3.9, 9.4),
  Physics     = c(10,  20,  0),
  Maths       = c(3.7, 11.5, 2.5),
  Sport       = c(8.7, 20,  4),
  English     = c(7.9, 7.2, 12.4),
  Geography   = c(6.4, 10.5, 6.5),
  Art         = c(2.4, 0.2, 9.8),
  Programming = c(0,   0,   20),
  Music       = c(20,  20,  20)
)
exam_scores
          Biology Physics Maths Sport English Geography Art Programming Music
Student.1     7.9      10   3.7   8.7     7.9       6.4 2.4           0    20
Student.2     3.9      20  11.5  20.0     7.2      10.5 0.2           0    20
Student.3     9.4       0   2.5   4.0    12.4       6.5 9.8          20    20

Chaque ligne est le profil d’un étudiant ; chaque colonne est une matière qui deviendra un axe sur le graphique.

Le format de données fmsb : les lignes d’en-tête max/min

C’est l’étape que tout le monde rate, alors faites-la délibérément. radarchart() ne peut pas déduire l’échelle de chaque axe à partir de vos données — il faut que vous indiquiez le maximum et le minimum de chaque variable, comme les deux premières lignes du tableau de données, au-dessus de vos cas :

  • Ligne 1 = la valeur maximale de chaque axe (le bord extérieur de la toile).
  • Ligne 2 = la valeur minimale de chaque axe (le centre).
  • Ligne 3 et suivantes = vos cas réels.

Nos notes vont de 0 à 20, donc chaque axe obtient un max de 20 et un min de 0. Construisez ce tableau à deux lignes et liez-le par-dessus avec rbind() :

# Row 1 = max of each axis, row 2 = min of each axis
max_min <- data.frame(
  Biology = c(20, 0), Physics = c(20, 0), Maths       = c(20, 0),
  Sport   = c(20, 0), English = c(20, 0), Geography   = c(20, 0),
  Art     = c(20, 0), Programming = c(20, 0), Music    = c(20, 0)
)
rownames(max_min) <- c("Max", "Min")

# Stack the ranges on top of the data
df <- rbind(max_min, exam_scores)
df
          Biology Physics Maths Sport English Geography  Art Programming Music
Max          20.0      20  20.0  20.0    20.0      20.0 20.0          20    20
Min           0.0       0   0.0   0.0     0.0       0.0  0.0           0     0
Student.1     7.9      10   3.7   8.7     7.9       6.4  2.4           0    20
Student.2     3.9      20  11.5  20.0     7.2      10.5  0.2           0    20
Student.3     9.4       0   2.5   4.0    12.4       6.5  9.8          20    20

df a maintenant les lignes d’en-tête Max et Min suivies des trois étudiants — exactement la forme que radarchart() veut. Les noms de colonnes doivent correspondre entre max_min et vos données, sinon la liaison désalignera les axes.

Un graphique radar de base

Avec l’en-tête en place, dessiner un cas tient en une ligne. Extrayez le Max, le Min, et le cas que vous voulez dans un petit tableau et passez-le à radarchart(). C’est notre figure phare.

library(fmsb)

# Max, Min, and the one case to plot
student1 <- df[c("Max", "Min", "Student.1"), ]
radarchart(student1)

A radar chart in R drawn with the fmsb package, an azure polygon over a grey grid of nine exam-subject axes showing Student 1's profile.

Le polygone trace les notes de l’étudiant 1 à travers les neuf matières. Vous pouvez lire le profil directement dessus — fort en Musique et Physique, faible en Programmation et Art. Sans style, radarchart() utilise ses réglages par défaut sobres ; les sections suivantes le rendent prêt à publier.

Couleurs : ligne, remplissage et transparence

Trois arguments contrôlent le polygone : pcol (la couleur de la ligne), pfcol (la couleur de remplissage), et plwd / plty (largeur et type de ligne). Un remplissage plein masque la grille, alors adoucissez-le avec scales::alpha(), qui ajoute un canal de transparence à n’importe quelle couleur.

library(fmsb)
library(scales)

student1 <- df[c("Max", "Min", "Student.1"), ]

radarchart(
  student1,
  pcol  = "#3a86d4",                 # line colour
  pfcol = scales::alpha("#3a86d4", 0.5),  # fill, 50% transparent
  plwd  = 2, plty = 1                # solid line, width 2
)

A radar chart of Student 1 with an azure outline and a semi-transparent azure fill, so the grey grid lines show through the polygon.

alpha("#3a86d4", 0.5) renvoie l’azur de la marque à 50 % d’opacité, donc le polygone se lit clairement et la grille derrière lui reste visible. Pour supprimer entièrement le contour, utilisez plty = 0 (ou plty = "blank").

La grille et les étiquettes d’axes

radarchart() dessine une toile de lignes de grille et une échelle d’axe. Contrôlez-les avec les arguments cgl* (concentric grid line) et d’axe :

  • cglcol / cglty / cglwd — couleur, type et largeur des lignes de grille.
  • axistype = 1 active les étiquettes de l’axe central.
  • axislabcol — couleur de ces nombres d’axe (le défaut est un bleu criard ; le gris est plus calme).
  • caxislabels — les étiquettes à imprimer le long de l’axe central (ici, l’échelle 0–20).
  • vlabels / vlcex — renommer les axes et dimensionner leur police.
library(fmsb)
library(scales)

student1 <- df[c("Max", "Min", "Student.1"), ]

op <- par(mar = c(1, 2, 2, 1))   # trim the margins
radarchart(
  student1,
  axistype = 1,
  # Polygon
  pcol = "#3a86d4", pfcol = scales::alpha("#3a86d4", 0.5),
  plwd = 2, plty = 1,
  # Grid web
  cglcol = "grey", cglty = 1, cglwd = 0.8,
  # Axis labels
  axislabcol = "grey", caxislabels = c(0, 5, 10, 15, 20),
  vlcex = 0.9,
  title = "Student 1"
)

A polished radar chart of Student 1 with a light grey web, grey axis numbers labelled 0, 5, 10, 15, 20, and an azure semi-transparent polygon.

par(op)

par(mar = ...) réduit les marges du graphique pour que le tracé remplisse le panneau ; nous sauvegardons les anciens réglages dans op et les restaurons après. caxislabels = c(0, 5, 10, 15, 20) imprime une échelle lisible le long d’un rayon, et axislabcol = "grey" adoucit le bleu par défaut pour qu’il s’accorde à la toile.

Plusieurs groupes sur un même graphique

Pour comparer des cas, passez plusieurs lignes à la fois (toujours avec l’en-tête Max/Min) et donnez à pcol / pfcol une couleur par cas. Ajoutez ensuite une legend() pour que les lecteurs sachent quel polygone est qui. Utilisez un ensemble de remplissages adapté au daltonisme à faible alpha pour que les polygones qui se chevauchent restent lisibles.

library(fmsb)
library(scales)

# All three students (df already has the Max/Min header on top)
cols <- c("#3a86d4", "#e7b800", "#fc4e07")

op <- par(mar = c(2, 2, 2, 2))
radarchart(
  df,
  axistype = 1,
  pcol  = cols,
  pfcol = scales::alpha(cols, 0.3),
  plwd  = 2, plty = 1,
  cglcol = "grey", cglty = 1, cglwd = 0.8,
  axislabcol = "grey", caxislabels = c(0, 5, 10, 15, 20),
  vlcex = 0.9
)
# rownames(df)[-(1:2)] drops the Max/Min rows, leaving the case names
legend(
  x = "bottom", legend = rownames(df)[-(1:2)], horiz = TRUE,
  bty = "n", pch = 20, col = cols,
  text.col = "black", cex = 1, pt.cex = 1.5
)

A radar chart overlaying three students in azure, amber and red semi-transparent polygons over a grey nine-axis web, with a horizontal legend below.

par(op)

Chaque étudiant est un polygone ; le remplissage scales::alpha(cols, 0.3) laisse tous les trois transparaître là où ils se chevauchent. rownames(df)[-(1:2)] retire les lignes d’en-tête Max/Min pour que la légende ne liste que les cas. La superposition fonctionne bien pour jusqu’à trois groupes — au-delà, les polygones s’emmêlent.

Petits multiples : un panneau par groupe

Avec plus de trois cas, un graphique superposé devient illisible. La réponse plus claire est les petits multiples — un panneau par cas, dessiné dans une grille avec par(mfrow = ...). Bouclez sur les cas, en passant à chaque fois l’en-tête Max/Min plus ce seul cas.

library(fmsb)
library(scales)

cols   <- c("#3a86d4", "#e7b800", "#fc4e07")
cases  <- rownames(df)[-(1:2)]   # the three student names

op <- par(mar = c(1, 1, 2, 1))
par(mfrow = c(1, 3))             # 1 row, 3 columns

for (i in seq_along(cases)) {
  radarchart(
    df[c("Max", "Min", cases[i]), ],
    axistype = 1,
    pcol = cols[i], pfcol = scales::alpha(cols[i], 0.5),
    plwd = 2, plty = 1,
    cglcol = "grey", cglty = 1, cglwd = 0.8,
    axislabcol = "grey", caxislabels = c(0, 5, 10, 15, 20),
    vlcex = 0.8,
    title = cases[i]
  )
}

Three small radar charts side by side, one per student, each an azure, amber or red polygon, titled Student 1, Student 2 and Student 3.

par(op)

par(mfrow = c(1, 3)) divise le périphérique en trois panneaux ; la boucle dessine un étudiant dans chacun, en découpant df[c("Max", "Min", cases[i]), ] pour que chaque panneau conserve les mêmes lignes d’en-tête. Restaurez toujours la disposition avec par(op) ensuite, sinon le graphique suivant hérite de la grille.

L’alternative ggplot : ggradar

Si vous préférez rester dans la grammaire des graphiques, le package ggradar construit un graphique radar comme un objet ggplot2 que vous pouvez thématiser comme n’importe quel autre graphique. Il n’est pas montré exécuté ici (il n’est pas sur CRAN — vous l’installez depuis GitHub), mais la recette est standard :

# install.packages("devtools")
devtools::install_github("ricardo-bion/ggradar")
library(ggradar)

# ggradar wants one row per group, values rescaled to 0-1, the group name
# in the first column, and no separate Max/Min header rows.
plot_df <- data.frame(group = rownames(exam_scores), exam_scores / 20)
ggradar(
  plot_df,
  values.radar = c("0", "10", "20"),
  grid.min = 0, grid.mid = 0.5, grid.max = 1
)

ggradar attend une forme différente de fmsb : le nom du groupe comme première colonne, les valeurs redimensionnées à 0–1, et aucune ligne d’en-tête Max/Min (vous définissez l’échelle avec grid.min/grid.mid/ grid.max à la place). Utilisez fmsb pour un graphique en base-graphics rapide avec un contrôle total ; tournez-vous vers ggradar quand vous voulez un objet ggplot à thématiser et combiner.

Essayez en direct

Modifiez les données ou les couleurs et appuyez sur Run — le graphique se redessine dans votre navigateur.

🟢 Avec un agent IA

Demandez à Prova « les axes de mon graphique radar sont tous à la mauvaise échelle — qu’est-ce qui ne va pas dans mes données ? » — elle répond avec du code R que vous pouvez exécuter, donc la correction est reproductible. The runtime is the judge. Demander à Prova →

Problèmes courants

Le polygone est écrasé ou l’échelle semble fausse — vous avez oublié les lignes max/min. radarchart() lit la ligne 1 comme le maximum et la ligne 2 comme le minimum de chaque axe. Si vous passez vos cas sans ces deux lignes d’en-tête, il traite vos deux premiers cas comme l’échelle et tout le reste s’effondre. Liez toujours un tableau Max/Min par-dessus en premier avec rbind().

La légende liste Max et Min. rownames(df) inclut les deux lignes d’en-tête. Retirez-les avec rownames(df)[-(1:2)] pour que la légende ne montre que vos cas.

Le remplissage masque la grille. Un pfcol plein recouvre la toile. Enveloppez la couleur dans scales::alpha(colour, 0.5) (ou moins) pour que la grille transparaisse, et baissez davantage l’alpha quand vous superposez plusieurs groupes.

Questions fréquentes

Installez et chargez le package fmsb, mettez en forme vos données avec le maximum de chaque axe en ligne 1 et le minimum en ligne 2 (au-dessus de vos cas), puis appelez radarchart(df). Ajoutez pcol/pfcol pour les couleurs et caxislabels pour l’échelle d’axe.

radarchart() ne peut pas deviner la plage de chaque axe à partir de vos valeurs, alors vous l’indiquez explicitement : ligne 1 = le maximum (le bord extérieur) et ligne 2 = le minimum (le centre). Chaque ligne ultérieure est tracée par rapport à cette échelle. Omettez-les et le graphique interprète à tort vos deux premiers cas comme l’échelle.

Passez plusieurs lignes de cas à la fois (en gardant l’en-tête Max/Min) et donnez à pcol/pfcol une couleur par cas, par exemple pfcol = scales::alpha(c("#3a86d4", "#fc4e07"), 0.3). Ajoutez une legend() en utilisant rownames(df)[-(1:2)] pour les étiqueter. Pour plus de trois groupes, dessinez plutôt des petits multiples.

fmsb::radarchart() est un graphique en base-graphics qui a besoin de lignes d’en-tête Max/Min explicites. ggradar construit plutôt un objet ggplot2 : il veut le nom du groupe dans la première colonne, les valeurs redimensionnées à 0–1, et aucune ligne d’en-tête (vous définissez l’échelle avec grid.min/grid.max). Utilisez fmsb pour un contrôle rapide ; ggradar quand vous voulez un ggplot thématisable.

Utilisez pcol pour la ligne et pfcol pour le remplissage. Adoucissez le remplissage avec scales::alpha(colour, 0.5) pour que la grille transparaisse, et stylisez la toile avec cglcol (couleur de la grille) et axislabcol (couleur des nombres d’axe). Passez des vecteurs à pcol/pfcol pour colorer plusieurs groupes à la fois.

Testez vos connaissances

À partir du df construit dans cette leçon (l’en-tête Max/Min plus trois étudiants), dessinez un seul graphique radar superposant l’étudiant 1 et l’étudiant 2 qui : les colore en azur et ambre, remplit chacun à alpha = 0.4, utilise une grille grise et des étiquettes d’axes grises avec l’échelle 0, 5, 10, 15, 20, et ajoute une légende horizontale.

# df already has Max, Min, Student.1, Student.2, Student.3
two <- df[c("Max", "Min", "Student.1", "Student.2"), ]
# Your radarchart() + legend() here

Passez two à radarchart(), donnez deux couleurs à pcol et pfcol = scales::alpha(cols, 0.4), définissez cglcol = "grey", axislabcol = "grey" et caxislabels = c(0, 5, 10, 15, 20), puis appelez legend() avec c("Student.1", "Student.2").

library(fmsb)
library(scales)

two  <- df[c("Max", "Min", "Student.1", "Student.2"), ]
cols <- c("#3a86d4", "#e7b800")

radarchart(
  two,
  axistype = 1,
  pcol = cols, pfcol = scales::alpha(cols, 0.4),
  plwd = 2, cglcol = "grey", cglty = 1,
  axislabcol = "grey", caxislabels = c(0, 5, 10, 15, 20)
)
legend(
  "bottom", legend = c("Student.1", "Student.2"),
  horiz = TRUE, bty = "n", pch = 20, col = cols
)

Garder les lignes Max/Min fixe l’échelle 0–20 ; les deux vecteurs de couleurs et le remplissage alpha permettent aux deux polygones de se lire là où ils se chevauchent.

Vérification rapide. Vous appelez radarchart(exam_scores) directement sur le tableau des trois étudiants — sans lignes Max/Min — et le graphique a l’air faux. Pourquoi ?

radarchart() lit la ligne 1 comme les maxima d’axe et la ligne 2 comme les minima d’axe. Sans un en-tête Max/Min il traite l’étudiant 1 et l’étudiant 2 comme l’échelle, donc l’étudiant 3 est le seul cas réellement tracé — et par rapport à la mauvaise plage. Liez toujours un tableau Max/Min par-dessus en premier avec rbind().

Conclusion

fmsb::radarchart() est la façon directe de dessiner un graphique radar (toile d’araignée) en R : mettez en forme les données avec une ligne Max et une ligne Min au-dessus de vos cas, puis stylisez avec pcol/pfcol (plus scales::alpha() pour la transparence), cglcol pour la grille, et caxislabels pour l’échelle d’axe. Superposez jusqu’à trois groupes avec une légende, ou utilisez par(mfrow = ...) pour les petits multiples au-delà. Pour une figure native ggplot, ggradar est l’alternative — souvenez-vous juste qu’il veut une forme de données différente.

Leçons connexes

Cette page vous a-t-elle été utile ?

Prêt à passer à la vitesse supérieure ?

Essayez sur vos propres données avec Prova — the runtime is the judge.Ouvrir Prova →

Recevez les nouvelles leçons R & Python par e-mail

Pratique, reproductible, sans spam. Désinscription à tout moment.

Double opt-in. Nous ne partageons jamais votre e-mail.

Partager cette pageXLinkedInRedditHN
Note

Cette leçon est reproductible : chaque figure a été produite par le code affiché, exécuté lors de la génération du site (si elles s’affichent, le code fonctionne). Modifiez n’importe quel bloc et appuyez sur Run pour les reproduire en direct. The runtime is the judge.

Réutilisation

Citation

BibTeX
@online{2026,
  author = {},
  title = {Graphique radar en R : diagrammes en toile d’araignée avec le
    package fmsb},
  date = {2026-06-27},
  url = {https://www.datanovia.com/learn/data-visualization/radar-chart-in-r},
  langid = {fr}
}
Veuillez citer ce travail comme suit :
“Graphique radar en R : diagrammes en toile d’araignée avec le package fmsb.” 2026. June 27. https://www.datanovia.com/learn/data-visualization/radar-chart-in-r.