Palette de couleurs personnalisée à l'aide de Python Matplotlib

Utilisez ListedColormap lorsque chaque catégorie doit avoir une couleur distincte, et LinearSegmentedColormap lorsque les valeurs doivent former un dégradé. Ces deux classes de palettes de couleurs de Matplotlib peuvent être transmises aux fonctions de tracé avec l’argument cmap. Ce guide montre également comment examiner une palette intégrée et récupérer ses valeurs RGBA.

Créer une palette de couleurs personnalisée en Python avec Matplotlib

Une palette de couleurs associe des valeurs numériques à des couleurs. Pour des codes de catégorie ou un petit ensemble de couleurs fixes, définissez une ListedColormap. Pour des mesures dont les couleurs doivent se fondre progressivement, définissez une LinearSegmentedColormap. Lorsque vous appliquez l’une ou l’autre, utilisez une normalisation adaptée à la plage des valeurs à colorer ; sinon, les couleurs du graphique risquent de ne pas représenter la plage de données souhaitée.

Accéder aux palettes de couleurs et à leurs valeurs en Python avec la fonction get_cmap() de Matplotlib

La fonction get_cmap() récupère une palette intégrée à partir de son nom. Une palette de couleurs est appelable : transmettez-lui une valeur comprise entre 0 et 1 pour obtenir un tuple RGBA, dont le dernier élément indique l’opacité. Pour examiner plusieurs couleurs échantillonnées, transmettez plutôt une séquence de valeurs. Cet exemple affiche une couleur échantillonnée :

import matplotlib.pyplot as plt

viridis = plt.get_cmap("viridis")
print(viridis(0.56))

(np.float64(0.120081), np.float64(0.622161), np.float64(0.534946), np.float64(1.0))

Pour obtenir une table de correspondance de taille finie, rééchantillonnez la palette avec viridis.resampled(8). Une ListedColormap expose ses entrées par l’intermédiaire de colors ; une palette continue telle que LinearSegmentedColormap s’échantillonne en l’appelant avec des valeurs.

Créer une palette discrète personnalisée en Python avec l’attribut colors de ListedColormap

ListedColormap accepte des noms de couleurs ou des valeurs numériques RGBA. Les valeurs des canaux RGBA sont généralement comprises entre 0 et 1. Lorsque la palette est représentée sous forme de liste, son attribut colors contient ses entrées discrètes. L’exemple autonome ci-dessous crée ces deux formes et applique la palette de noms de couleurs à des codes de catégorie dans un nuage de points. Adaptez categories et la normalisation à vos données.

import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap, Normalize

named_map = ListedColormap(["darkorange", "gold", "lightseagreen"], name="groups")
rgba_map = ListedColormap([
    (0.58, 0.41, 0.27, 1.0),
    (0.00, 0.41, 0.27, 1.0),
    (0.58, 0.00, 0.27, 1.0),
], name="rgba_groups")

x = [1, 2, 3, 4, 5, 6]
y = [1, 4, 2, 5, 3, 6]
categories = [0, 0, 1, 1, 2, 2]
plt.scatter(x, y, c=categories, cmap=named_map, norm=Normalize(0, 2))
plt.colorbar(ticks=[0, 1, 2])
plt.show()

L’appel Normalize(0, 2) répartit les codes de catégorie sur les trois entrées, et les graduations de la barre de couleurs indiquent ces codes. Utilisez rgba_map.colors pour examiner la liste explicite de valeurs RGBA. Si le nombre de couleurs diffère de celui des codes de catégorie, ajustez la palette ou la normalisation afin d’attribuer les couleurs souhaitées à chaque catégorie.

Comment créer une palette segmentée linéaire personnalisée en Python ?

Une LinearSegmentedColormap interpole les canaux de couleur entre des positions spécifiées pour créer un dégradé. Son cdict (dictionnaire de couleurs) contient des clés de canal telles que red, green et blue. Les lignes de chaque canal ont la forme [x, yleft, yright] : x est une position comprise entre 0 et 1, et les autres valeurs indiquent le niveau du canal de part et d’autre de cette position. Les positions doivent être croissantes de 0 à 1. Des valeurs gauche et droite identiques produisent une transition continue au point d’ancrage ; des valeurs différentes décrivent un saut.

Cet exemple autonome crée un dégradé à partir de points d’ancrage et un second avec from_list(), puis affiche chacun sur des données d’exemple. Les titres visibles des graphiques, « Anchors » et « Color list », restent en anglais : « Anchors » désigne le dégradé défini par les points d’ancrage, tandis que « Color list » désigne celui créé avec from_list(). Les figures rendues n’ont pas fait l’objet d’une vérification visuelle.

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.colors import LinearSegmentedColormap

cdict = {
    "red": [(0.0, 0.0, 0.0), (0.5, 0.1, 0.1), (1.0, 1.0, 1.0)],
    "green": [(0.0, 0.0, 0.0), (0.5, 0.8, 0.8), (1.0, 0.2, 0.2)],
    "blue": [(0.0, 0.4, 0.4), (0.5, 0.1, 0.1), (1.0, 0.0, 0.0)],
}
anchor_map = LinearSegmentedColormap("anchor_gradient", cdict, N=256)
list_map = LinearSegmentedColormap.from_list(
    "list_gradient", ["navy", "gold", "crimson"], N=256
)

values = np.arange(36).reshape(6, 6)
fig, axes = plt.subplots(1, 2)
for ax, cmap, title in zip(axes, [anchor_map, list_map], ["Anchors", "Color list"]):
    image = ax.imshow(values, cmap=cmap)
    ax.set_title(title)
    fig.colorbar(image, ax=ax)
plt.tight_layout()
plt.show()

Utilisez le constructeur avec dictionnaire lorsque le contrôle des niveaux des canaux ou des points d’ancrage explicites est important. Utilisez LinearSegmentedColormap.from_list() pour créer simplement un dégradé à partir de noms de couleurs ; celles-ci sont interpolées sur toute la palette. N définit la taille de la table de correspondance, et gamma contrôle la mise à l’échelle des positions d’entrée.

Conclusion

Choisissez ListedColormap pour attribuer délibérément des couleurs à des catégories discrètes. Choisissez LinearSegmentedColormap pour un dégradé continu, défini soit avec les points d’ancrage de cdict, soit avec les couleurs de from_list(). Récupérez les palettes intégrées avec get_cmap(), examinez leurs valeurs RGBA échantillonnées, puis transmettez la palette choisie au graphique avec une normalisation adaptée.