Marche aléatoire en 3D animée avec Matplotlib

Introduction

Dans ce laboratoire, nous allons apprendre à créer un graphique d'un mouvement aléatoire en 3D animé à l'aide de la bibliothèque Matplotlib en Python. Nous allons créer un graphique en 3D et simuler un mouvement aléatoire avec 40 particules qui se déplacent aléatoirement dans l'espace 3D.

Conseils sur la VM

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

Parfois, vous devrez peut-être attendre quelques secondes pour que le Notebook Jupyter ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations du Notebook 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églerons rapidement le problème pour vous.

Importation des bibliothèques requises

Nous commençons par importer les bibliothèques requises. Nous utiliserons numpy pour générer des nombres aléatoires et matplotlib pour créer le graphique.

import matplotlib.pyplot as plt
import numpy as np
import matplotlib.animation as animation

Définition de la fonction de mouvement aléatoire

Nous définissons une fonction qui génère un mouvement aléatoire avec un nombre donné de pas et une taille maximale de pas. La fonction prend deux entrées : num_steps est le nombre total de pas dans le mouvement aléatoire et max_step est la taille maximale de chaque pas. Nous utilisons numpy.random pour générer des nombres aléatoires pour les pas et numpy.cumsum pour calculer la somme cumulative des pas pour obtenir la position finale.

def random_walk(num_steps, max_step=0.05):
    """Retourne un mouvement aléatoire en 3D sous forme d'un tableau (num_steps, 3)."""
    start_pos = np.random.random(3)
    steps = np.random.uniform(-max_step, max_step, size=(num_steps, 3))
    walk = start_pos + np.cumsum(steps, axis=0)
    return walk

Définition de la fonction de mise à jour

Nous définissons une fonction qui met à jour le graphique pour chaque trame de l'animation. La fonction prend trois entrées : num est le numéro de la trame actuelle, walks est une liste de tous les mouvements aléatoires et lines est une liste de toutes les lignes dans le graphique. Pour chaque ligne et mouvement, nous mettons à jour les données pour les coordonnées x, y et z de la ligne jusqu'au numéro de trame actuel. Nous utilisons line.set_data() et line.set_3d_properties() pour mettre à jour les coordonnées x-y et z respectivement.

def update_lines(num, walks, lines):
    for line, walk in zip(lines, walks):
        ## REMARQUE : il n'y a pas de.set_data() pour les données en 3 dimensions...
        line.set_data(walk[:num, :2].T)
        line.set_3d_properties(walk[:num, 2])
    return lines

Générer des mouvements aléatoires

Nous générons 40 mouvements aléatoires avec 30 pas chacun à l'aide de la fonction random_walk() définie précédemment. Nous stockons tous les mouvements aléatoires dans une liste appelée walks.

## Données : 40 mouvements aléatoires sous forme de tableaux (num_steps, 3)
num_steps = 30
walks = [random_walk(num_steps) for index in range(40)]

Créer un graphique en 3D

Nous créons un graphique en 3D à l'aide de matplotlib. Nous ajoutons une ligne vide pour chaque mouvement aléatoire au graphique. Nous définissons les limites des axes x, y et z entre 0 et 1.

## Attacher l'axe 3D à la figure
fig = plt.figure()
ax = fig.add_subplot(projection="3d")

## Créer des lignes initialement sans données
lines = [ax.plot([], [], [])[0] for _ in walks]

## Définir les propriétés des axes
ax.set(xlim3d=(0, 1), xlabel='X')
ax.set(ylim3d=(0, 1), ylabel='Y')
ax.set(zlim3d=(0, 1), zlabel='Z')

Créer une animation

Nous créons une animation à l'aide de la classe FuncAnimation de matplotlib.animation. Nous passons l'objet figure, la fonction de mise à jour, le nombre total de trames (qui est égal au nombre de pas dans les mouvements aléatoires), la liste de tous les mouvements aléatoires et la liste de toutes les lignes en tant qu'arguments au constructeur FuncAnimation.

## Création de l'objet Animation
ani = animation.FuncAnimation(
    fig, update_lines, num_steps, fargs=(walks, lines), interval=100)

Afficher l'animation

Enfin, nous affichons l'animation à l'aide de plt.show().

plt.show()

Sommaire

Nous avons appris à créer un graphique animé de mouvement aléatoire en 3D à l'aide de la bibliothèque Matplotlib en Python. Nous avons généré des mouvements aléatoires et mis à jour le graphique pour chaque trame de l'animation. Cette technique peut être utilisée pour visualiser le mouvement des particules, la diffusion et d'autres processus stochastiques dans l'espace 3D.