Superposer une image sur un graphique Matplotlib

Beginner

This tutorial is from open-source community. Access the source code

Introduction

En visualisation de données, il peut arriver que vous souhaitiez ajouter un logo, une marque d'eau ou d'autres éléments d'image à vos graphiques. Ce tutoriel montre comment superposer une image sur un graphique Matplotlib en la plaçant devant le contenu du graphique et en la rendant semi-transparente.

Vous apprendrez à utiliser la méthode figimage de la classe matplotlib.figure.Figure pour positionner une image sur votre graphique, ainsi que la méthode imread du module matplotlib.image pour charger les données d'image.

À la fin de ce tutoriel, vous serez en mesure de créer des visualisations de qualité professionnelle avec des superpositions d'images personnalisées, utiles pour la marque, la mise en place de marques d'eau ou pour améliorer l'attrait visuel de vos présentations de données.

Conseils pour la machine virtuelle (VM)

Une fois que la machine virtuelle a démarré, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook et accéder à Jupyter Notebook pour pratiquer.

click-notebook
Parfois, vous devrez peut-être attendre quelques secondes que Jupyter Notebook finisse de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant votre apprentissage, n'hésitez pas à demander de l'aide à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Création d'un Jupyter Notebook et importation des bibliothèques nécessaires

Dans la première cellule de votre notebook, entrez le code suivant pour importer les bibliothèques nécessaires :

import matplotlib.pyplot as plt
import numpy as np
import matplotlib.cbook as cbook
import matplotlib.image as image

Comprenons ce que chaque bibliothèque fait :

  • matplotlib.pyplot (alias plt) : Une collection de fonctions qui font fonctionner matplotlib comme MATLAB, offrant une interface pratique pour créer des graphiques.
  • numpy (alias np) : Un package fondamental pour le calcul scientifique en Python, que nous utiliserons pour la manipulation de données.
  • matplotlib.cbook : Une collection de fonctions utilitaires pour matplotlib, y compris des fonctions pour obtenir des données d'exemple.
  • matplotlib.image : Un module pour les fonctionnalités liées aux images dans matplotlib, que nous utiliserons pour lire et afficher des images.

Exécutez la cellule en cliquant sur le bouton "Run" en haut du notebook ou en appuyant sur Shift+Enter.

libraries-imported

L'exécution de cette cellule devrait se terminer sans aucun affichage, ce qui indique que toutes les bibliothèques ont été importées avec succès.

Chargement et examen de l'image

Maintenant que nous avons importé nos bibliothèques, nous devons charger l'image que nous souhaitons superposer sur notre graphique. Matplotlib propose quelques images d'exemple que nous pouvons utiliser pour pratiquer.

  1. Créez une nouvelle cellule dans votre notebook et entrez le code suivant :
## Load the sample image
with cbook.get_sample_data('logo2.png') as file:
    im = image.imread(file)

## Display information about the image
print(f"Image shape: {im.shape}")
print(f"Image data type: {im.dtype}")

## Display the image
plt.figure(figsize=(4, 4))
plt.imshow(im)
plt.axis('off')  ## Hide axis
plt.title('Matplotlib Logo')
plt.show()

Ce code effectue les opérations suivantes :

  • Utilise cbook.get_sample_data() pour charger une image d'exemple nommée 'logo2.png' depuis la collection de données d'exemple de Matplotlib.
  • Utilise image.imread() pour lire le fichier image dans un tableau NumPy.
  • Affiche des informations sur les dimensions et le type de données de l'image.
  • Crée une figure et affiche l'image à l'aide de plt.imshow().
  • Masque les graduations et les étiquettes de l'axe avec plt.axis('off').
  • Ajoute un titre à la figure.
  • Affiche la figure à l'aide de plt.show().
  1. Exécutez la cellule en appuyant sur Shift+Enter.

La sortie devrait afficher des informations sur l'image et montrer le logo de Matplotlib. La forme de l'image indique les dimensions de l'image (hauteur, largeur, canaux de couleur), et le type de données nous indique comment les données de l'image sont stockées.

image-info

Cette étape est importante car elle nous aide à comprendre l'image que nous utiliserons comme superposition. Nous pouvons voir son apparence et ses dimensions, ce qui sera utile pour décider comment la positionner sur notre graphique.

Création d'un graphique de base avec des données aléatoires

Avant d'ajouter notre superposition d'image, nous devons créer un graphique qui servira de base à notre visualisation. Créons un simple diagramme à barres en utilisant des données aléatoires.

  1. Créez une nouvelle cellule dans votre notebook et entrez le code suivant :
## Create a figure and axes for our plot
fig, ax = plt.subplots(figsize=(10, 6))

## Set a random seed for reproducibility
np.random.seed(19680801)

## Generate random data
x = np.arange(30)  ## x-axis values (0 to 29)
y = x + np.random.randn(30)  ## y-axis values (x plus random noise)

## Create a bar chart
bars = ax.bar(x, y, color='#6bbc6b')  ## Green bars

## Add grid lines
ax.grid(linestyle='--', alpha=0.7)

## Add labels and title
ax.set_xlabel('X-axis Label')
ax.set_ylabel('Y-axis Label')
ax.set_title('Bar Chart with Random Data')

## Display the plot
plt.tight_layout()
plt.show()

Ce code effectue les opérations suivantes :

  • Crée une figure et des axes d'une taille spécifique en utilisant plt.subplots().
  • Définit une graine aléatoire pour s'assurer que nous obtenons les mêmes valeurs aléatoires chaque fois que nous exécutons le code.
  • Génère 30 valeurs pour l'axe des x (de 0 à 29) et les valeurs correspondantes pour l'axe des y (x plus du bruit aléatoire).
  • Crée un diagramme à barres avec des barres vertes en utilisant ax.bar().
  • Ajoute des lignes de grille au graphique avec ax.grid().
  • Ajoute des étiquettes pour l'axe des x, l'axe des y et un titre pour le graphique.
  • Utilise plt.tight_layout() pour ajuster l'espacement pour un meilleur aspect.
  • Affiche le graphique en utilisant plt.show().
  1. Exécutez la cellule en appuyant sur Shift+Enter.

La sortie devrait afficher un diagramme à barres avec des barres vertes représentant les données aléatoires. L'axe des x montre des entiers de 0 à 29, et l'axe des y montre les valeurs correspondantes avec du bruit aléatoire ajouté.

Ce graphique sera la base sur laquelle nous superposerons notre image à l'étape suivante. Remarquez comment nous avons stocké l'objet figure dans la variable fig et l'objet axe dans la variable ax. Nous aurons besoin de ces variables pour ajouter notre superposition d'image.

Superposition de l'image sur le graphique

Maintenant que nous avons créé notre graphique de base, superposons l'image dessus. Nous utiliserons la méthode figimage pour ajouter l'image à la figure, et nous la rendrons semi-transparente afin que le graphique en dessous reste visible.

  1. Créez une nouvelle cellule dans votre notebook et entrez le code suivant :
## Create a figure and axes for our plot (same as before)
fig, ax = plt.subplots(figsize=(10, 6))

## Set a random seed for reproducibility
np.random.seed(19680801)

## Generate random data
x = np.arange(30)  ## x-axis values (0 to 29)
y = x + np.random.randn(30)  ## y-axis values (x plus random noise)

## Create a bar chart
bars = ax.bar(x, y, color='#6bbc6b')  ## Green bars

## Add grid lines
ax.grid(linestyle='--', alpha=0.7)

## Add labels and title
ax.set_xlabel('X-axis Label')
ax.set_ylabel('Y-axis Label')
ax.set_title('Bar Chart with Image Overlay')

## Load the image
with cbook.get_sample_data('logo2.png') as file:
    im = image.imread(file)

## Overlay the image on the plot
## Parameters:
## - im: the image data
## - 25, 25: x and y position in pixels from the bottom left
## - zorder=3: controls the drawing order (higher numbers are drawn on top)
## - alpha=0.5: controls the transparency (0 = transparent, 1 = opaque)
fig.figimage(im, 25, 25, zorder=3, alpha=0.5)

## Display the plot
plt.tight_layout()
plt.show()

Ce code combine ce que nous avons fait dans les étapes précédentes et ajoute la méthode figimage pour superposer notre image sur le graphique. Voici une explication des paramètres de figimage :

  • im : Les données de l'image sous forme de tableau NumPy.
  • 25, 25 : Les positions x et y en pixels à partir du coin inférieur gauche de la figure.
  • zorder=3 : Contrôle l'ordre de dessin. Les nombres plus élevés sont dessinés au-dessus des éléments avec des nombres plus bas.
  • alpha=0.5 : Contrôle la transparence de l'image. Une valeur de 0 est complètement transparente, et 1 est complètement opaque.
  1. Exécutez la cellule en appuyant sur Shift+Enter.

La sortie devrait montrer le même diagramme à barres que précédemment, mais maintenant avec le logo de Matplotlib superposé dans le coin inférieur gauche. Le logo devrait être semi-transparent, permettant au graphique en dessous de rester visible.

  1. Expérimentons avec différentes positions et niveaux de transparence. Créez une nouvelle cellule et entrez le code suivant :
## Create a figure and axes for our plot
fig, ax = plt.subplots(figsize=(10, 6))

## Set a random seed for reproducibility
np.random.seed(19680801)

## Generate random data
x = np.arange(30)
y = x + np.random.randn(30)

## Create a bar chart
bars = ax.bar(x, y, color='#6bbc6b')
ax.grid(linestyle='--', alpha=0.7)
ax.set_xlabel('X-axis Label')
ax.set_ylabel('Y-axis Label')
ax.set_title('Bar Chart with Centered Image Overlay')

## Load the image
with cbook.get_sample_data('logo2.png') as file:
    im = image.imread(file)

## Get figure dimensions
fig_width, fig_height = fig.get_size_inches() * fig.dpi

## Calculate center position (this is approximate)
x_center = fig_width / 2 - im.shape[1] / 2
y_center = fig_height / 2 - im.shape[0] / 2

## Overlay the image at the center with higher transparency
fig.figimage(im, x_center, y_center, zorder=3, alpha=0.3)

## Display the plot
plt.tight_layout()
plt.show()

Ce code place l'image au centre de la figure avec un niveau de transparence plus élevé (alpha = 0,3), la rendant plus adaptée comme filigrane.

  1. Exécutez la cellule en appuyant sur Shift+Enter.

La sortie devrait montrer le diagramme à barres avec le logo centré et plus transparent que précédemment, créant un effet de filigrane.

Création d'une fonction réutilisable pour les superpositions d'images

Pour rendre notre code plus réutilisable, créons une fonction qui peut ajouter une superposition d'image à n'importe quelle figure Matplotlib. De cette façon, nous pouvons facilement appliquer le même effet à différents graphiques.

  1. Créez une nouvelle cellule dans votre notebook et entrez le code suivant :
def add_image_overlay(fig, image_path, x_pos=25, y_pos=25, alpha=0.5, zorder=3):
    """
    Add an image overlay to a matplotlib figure.

    Parameters:
    -----------
    fig : matplotlib.figure.Figure
        The figure to add the image to
    image_path : str
        Path to the image file
    x_pos : int
        X position in pixels from the bottom left
    y_pos : int
        Y position in pixels from the bottom left
    alpha : float
        Transparency level (0 to 1)
    zorder : int
        Drawing order (higher numbers are drawn on top)

    Returns:
    --------
    fig : matplotlib.figure.Figure
        The figure with the image overlay
    """
    ## Load the image
    with cbook.get_sample_data(image_path) as file:
        im = image.imread(file)

    ## Add the image to the figure
    fig.figimage(im, x_pos, y_pos, zorder=zorder, alpha=alpha)

    return fig

## Example usage: Create a scatter plot with an image overlay
fig, ax = plt.subplots(figsize=(10, 6))

## Set a random seed for reproducibility
np.random.seed(19680801)

## Generate random data for a scatter plot
x = np.random.rand(50) * 10
y = np.random.rand(50) * 10

## Create a scatter plot
ax.scatter(x, y, s=100, c=np.random.rand(50), cmap='viridis', alpha=0.7)
ax.grid(linestyle='--', alpha=0.7)
ax.set_xlabel('X-axis Label')
ax.set_ylabel('Y-axis Label')
ax.set_title('Scatter Plot with Image Overlay')

## Add the image overlay using our function
add_image_overlay(fig, 'logo2.png', x_pos=50, y_pos=50, alpha=0.4)

## Display the plot
plt.tight_layout()
plt.show()

Ce code définit une fonction appelée add_image_overlay qui :

  • Prend en paramètres la figure, le chemin de l'image, la position, la transparence et l'ordre de dessin (z-order).
  • Charge l'image spécifiée.
  • Ajoute l'image à la figure en utilisant figimage.
  • Retourne la figure modifiée.

Après avoir défini la fonction, nous démontrons son utilisation en créant un nuage de points avec des données aléatoires et en ajoutant le logo de Matplotlib en superposition.

  1. Exécutez la cellule en appuyant sur Shift+Enter.

La sortie devrait montrer un nuage de points avec des points positionnés et colorés aléatoirement, et le logo de Matplotlib superposé à la position (50, 50) avec une opacité de 40 %.

  1. Essayons un autre exemple avec un graphique linéaire. Créez une nouvelle cellule et entrez le code suivant :
## Example usage: Create a line plot with an image overlay
fig, ax = plt.subplots(figsize=(10, 6))

## Generate data for a line plot
x = np.linspace(0, 10, 100)
y = np.sin(x)

## Create a line plot
ax.plot(x, y, linewidth=2, color='#d62728')
ax.grid(linestyle='--', alpha=0.7)
ax.set_xlabel('X-axis Label')
ax.set_ylabel('Y-axis Label')
ax.set_title('Sine Wave with Image Overlay')
ax.set_ylim(-1.5, 1.5)

## Add the image overlay using our function
## Place it in the bottom right corner
fig_width, fig_height = fig.get_size_inches() * fig.dpi
with cbook.get_sample_data('logo2.png') as file:
    im = image.imread(file)
    x_pos = fig_width - im.shape[1] - 50  ## 50 pixels from the right edge

add_image_overlay(fig, 'logo2.png', x_pos=x_pos, y_pos=50, alpha=0.6)

## Display the plot
plt.tight_layout()
plt.show()

Ce code crée un graphique linéaire montrant une onde sinusoïdale et ajoute le logo de Matplotlib dans le coin inférieur droit du graphique.

  1. Exécutez la cellule en appuyant sur Shift+Enter.

La sortie devrait montrer un graphique linéaire d'une onde sinusoïdale avec le logo de Matplotlib superposé dans le coin inférieur droit avec une opacité de 60 %.

Ces exemples démontrent comment notre fonction add_image_overlay peut être utilisée pour ajouter facilement des superpositions d'images à différents types de graphiques, en faisant d'elle un outil polyvalent pour personnaliser les visualisations.

Résumé

Dans ce tutoriel, vous avez appris à superposer des images sur des graphiques Matplotlib pour créer des filigranes, des logos ou d'autres éléments visuels qui améliorent vos visualisations. Voici un résumé de ce que nous avons couvert :

  1. Importation de bibliothèques : Nous avons commencé par importer les bibliothèques nécessaires pour travailler avec les graphiques Matplotlib et les images.

  2. Chargement et examen d'images : Nous avons appris à charger des images à l'aide de la fonction imread et à inspecter leurs propriétés.

  3. Création de graphiques de base : Nous avons créé différents types de graphiques (diagrammes à barres, nuages de points et graphiques linéaires) pour servir de base à nos superpositions d'images.

  4. Superposition d'images : Nous avons utilisé la méthode figimage pour placer des images sur nos graphiques, en contrôlant leur position, leur transparence et leur ordre de dessin.

  5. Création d'une fonction réutilisable : Nous avons développé une fonction réutilisable pour faciliter l'ajout de superpositions d'images à n'importe quelle figure Matplotlib.

Les compétences que vous avez acquises dans ce tutoriel peuvent être appliquées à :

  • L'ajout de filigranes aux graphiques pour la protection des droits d'auteur
  • L'inclusion de logos pour le branding dans les visualisations
  • La création d'éléments de fond personnalisés pour des graphiques esthétiquement agréables
  • La combinaison d'images avec des visualisations de données pour des présentations et des rapports

Vous pouvez continuer à expérimenter avec différents types de graphiques, d'images, de positions et de niveaux de transparence pour créer des visualisations uniques et de qualité professionnelle qui répondent à vos besoins spécifiques.