Créer des remplissages de polygones 3D pour des graphiques en ligne

Introduction

Dans ce tutoriel, nous allons apprendre à créer des polygones qui remplissent l'espace sous un graphique en ligne dans un tracé 3D à l'aide de la bibliothèque Matplotlib de Python. Les polygones seront semi-transparents, créant une sorte d'effet de 'vitrail déchiqueté'.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder au carnet Jupyter pour pratiquer.

Parfois, vous devrez peut-être attendre quelques secondes pour que le carnet Jupyter ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations du carnet Jupyter.

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

Importez les bibliothèques requises

Nous allons commencer par importer les bibliothèques nécessaires.

import math
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.collections import PolyCollection

Définissez la fonction du polygone sous le graphique

Ensuite, nous définissons une fonction polygon_under_graph(x, y) qui construit la liste de sommets qui définit le polygone remplissant l'espace sous le graphique en ligne (x, y). Cette fonction suppose que x est dans l'ordre croissant.

def polygon_under_graph(x, y):
    """
    Construit la liste de sommets qui définit le polygone remplissant l'espace sous
    le graphique en ligne (x, y). Cela suppose que x est dans l'ordre croissant.
    """
    return [(x[0], 0.), *zip(x, y), (x[-1], 0.)]

Créez le tracé 3D

Nous allons maintenant créer un tracé 3D à l'aide de Matplotlib.

ax = plt.figure().add_subplot(projection='3d')

Définissez les tableaux x et lambda

Nous définissons les tableaux x et lambda en utilisant respectivement les fonctions linspace et range.

x = np.linspace(0., 10., 31)
lambdas = range(1, 9)

Calculez les sommets et les couleurs de face

Nous calculons les sommets et les couleurs de face en utilisant les fonctions vectorize et colormaps de Matplotlib.

## verts[i] est une liste de paires (x, y) définissant le polygone i.
gamma = np.vectorize(math.gamma)
verts = [polygon_under_graph(x, l**x * np.exp(-l) / gamma(x + 1))
         for l in lambdas]
facecolors = plt.colormaps['viridis_r'](np.linspace(0, 1, len(verts)))

Créez les polygones et ajoutez-les au tracé

Nous créons les polygones à l'aide de la fonction PolyCollection de Matplotlib et les ajoutons au tracé.

poly = PolyCollection(verts, facecolors=facecolors, alpha=.7)
ax.add_collection3d(poly, zs=lambdas, zdir='y')

Définissez les limites et les étiquettes du tracé

Enfin, nous définissons les limites et les étiquettes du tracé à l'aide de la fonction set.

ax.set(xlim=(0, 10), ylim=(1, 9), zlim=(0, 0.35),
       xlabel='x', ylabel=r'$\lambda$', zlabel='probability')

Affichez le tracé

Nous affichons le tracé à l'aide de la fonction show.

plt.show()

Sommaire

Dans ce tutoriel, nous avons appris à créer des polygones qui remplissent l'espace sous un graphique en ligne dans un tracé 3D à l'aide de la bibliothèque Matplotlib de Python. Nous avons utilisé la fonction PolyCollection pour créer les polygones et défini les limites et les étiquettes du tracé à l'aide de la fonction set.