Produire un graphique de surface tridimensionnel avec MatPlotLib

Introduction

Parmi les outils à disposition pour la visualisation 3D, deux fonctions se distinguent particulièrement lorsqu'il s'agit de représenter des surfaces : plot_wireframe et plot_surface. Ces deux fonctions, issues du module mplot3d de Matplotlib, sont fréquemment utilisées pour visualiser des données en trois dimensions, notamment dans des domaines tels que la simulation numérique, l'analyse géospatiale, ou l'étude de fonctions mathématiques complexes.

La fonction plot_wireframe permet de créer des graphiques en treillis ou en fil de fer, montrant uniquement la structure de grille d’une surface 3D. Ce type de représentation est particulièrement utile lorsqu’on souhaite avoir un aperçu de la structure générale d’une surface sans entrer dans les détails de sa texture ou de ses couleurs.

D'autre part, la fonction plot_surface offre une représentation beaucoup plus riche et détaillée en créant des graphiques de surface 3D avec un rendu solide. Elle permet de remplir l'espace entre les grilles, de jouer avec les couleurs et les ombrages pour représenter des variations de valeurs sur la surface. Cette fonction est particulièrement utile lorsque l’on souhaite présenter un rendu plus réaliste ou mettre en évidence des détails spécifiques de la surface étudiée.

Ainsi, selon le contexte et les objectifs de votre analyse, le choix entre plot_wireframe et plot_surface vous permettra de privilégier soit une visualisation simplifiée et épurée, soit une représentation plus riche et plus détaillée de vos données tridimensionnelles.

# from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np

x, y = np.meshgrid(np.linspace(-5, 5, 100), np.linspace(-5, 5, 100))
z = np.sin(np.sqrt(x**2 + y**2))

fig = plt.figure(figsize=(14, 7))

# Premier sous-graphique de gauche (fils de fer)
ax1 = fig.add_subplot(1, 2, 1, projection="3d")
ax1.plot_wireframe(x, y, z)
ax1.set_title("Graphique en fils de fer")
print("A titre d'information :", type(ax1))

# Second sous-graphique (surface)
ax2 = fig.add_subplot(1, 2, 2, projection="3d")
ax2.plot_surface(x, y, z, cmap="viridis")
ax2.set_title("Graphique en surface")

plt.show()

A titre d'information : <class 'mpl_toolkits.mplot3d.axes3d.Axes3D'>

L'outil np.meshgrid

« np.meshgrid » est une fonction de la bibliothèque NumPy, qui est souvent utilisée pour créer des grilles de coordonnées à partir de deux ou plusieurs tableaux unidimensionnels. Cela est particulièrement utile pour l'évaluation de fonctions sur un quadrillage de points 2D ou 3D et est souvent utilisé en graphiques et en traitement d'image.

Imaginez que vous ayez un ensemble de valeurs x et un ensemble de valeurs y, et que vous souhaitiez créer un ensemble de points (x, y) couvrant toutes les combinaisons possibles de ces valeurs. C'est exactement ce que fait « np.meshgrid ». Il prend deux ou plusieurs tableaux unidimensionnels et produit des grilles de coordonnées 2D ou 3D.

Voici un exemple simple :

import numpy as np

# Deux tableaux unidimensionnels
x = np.array([1, 2, 3])
y = np.array([4, 5])

# Utilisation de np.meshgrid
X, Y = np.meshgrid(x, y)

# Affichage des  tableaux produits
print("X grid:")
print(X)

print("Y grid:")
print(Y)

X grid:
[[1 2 3]
 [1 2 3]]
Y grid:
[[4 4 4]
 [5 5 5]]

Exemple d'utilisation de la fonction plot_wireframe

Cet exemple crée un graphique en 3D qui montre une surface sous forme de grille de maillage, où la hauteur de chaque point est déterminée par le produit de ses coordonnées X et Y.

import numpy as np
import matplotlib.pyplot as plt

# Produit de la grille de maillage.
x, y = np.meshgrid(np.linspace(-5, 5, 20), np.linspace(-5, 5, 20))
z = x * y

# Tracé de la surface en fils de fer.
fig = plt.figure(figsize=(7, 7))
ax = plt.axes(projection="3d")
ax.plot_wireframe(x, y, z, color="r")

plt.show()

Comme vu dans un tuto précédent, vous pouvez afficher votre graphique avec un backend Qt. Lorsque vous utilisez un backend interactif comme %matplotlib qt, vous pouvez contrôler le point de vue sur un graphique 3D directement avec la souris. Voici comment procéder :

• Pour faire pivoter le graphique 3D : cliquez et faites glisser le graphique avec le bouton gauche de la souris enfoncé. En déplaçant la souris, vous modifiez les angles d'élévation et azimutal de la vue.

• Pour effectuer un zoom avant ou arrière : cliquez en gardez enfoncé le bouton droit de la souris et faites glisser le graphique.

• Pour déplacer le graphique : cliquez en gardez enfoncé la molette de la souris et faites glisser le graphique.

%matplotlib qt

import numpy as np
import matplotlib.pyplot as plt

# Produit de la grille de maillage.
x, y = np.meshgrid(np.linspace(-5, 5, 20), np.linspace(-5, 5, 20))
z = x * y

# Tracé de la surface en fils de fer.
fig = plt.figure(figsize=(7, 7))
ax = plt.axes(projection="3d")
ax.plot_wireframe(x, y, z, color="r")

plt.show()

%matplotlib inline

Exemples d'utilisation de la fonction plot_surface

Ce premier exemple simule une surface 3D et l'affiche dans MPL.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm


def fct(x, y):
    return np.sin(x) + np.cos(x+y)


# On produit une surface en 3D grâce à l'outil np.mesgrid.
x = np.linspace(0, 5, 100)
y = np.linspace(0, 5, 100)
x, y = np.meshgrid(x, y)

z = fct(x, y)

# Tracé de la surface.
fig = plt.figure(figsize=(7, 7))
axes = plt.axes(projection="3d")
axes.plot_surface(x, y, z, cmap="coolwarm")

plt.show()

Ce second exemple propose de visualiser une sphère colorée en 3D.

import matplotlib.pyplot as plt
import numpy as np

u = np.linspace(0, 2 * np.pi, 100)
v = np.linspace(0, np.pi, 50)
x = 10 * np.outer(np.cos(u), np.sin(v))
y = 10 * np.outer(np.sin(u), np.sin(v))
z = 10 * np.outer(np.ones(np.size(u)), np.cos(v))

fig = plt.figure(figsize=(7, 7))
ax = plt.axes(projection="3d")
ax.plot_surface(x, y, z, cmap='cool')

plt.show()

Ce troisième exemple se propose d'afficher la surface d'un tore coloré.

import matplotlib.pyplot as plt
import numpy as np

theta = np.linspace(0, 2 * np.pi, 100)
phi = np.linspace(0, 2 * np.pi, 100)
theta, phi = np.meshgrid(theta, phi)
R = 2
r = 1

x = (R + r * np.cos(theta)) * np.cos(phi)
y = (R + r * np.cos(theta)) * np.sin(phi)
z = r * np.sin(theta)

fig = plt.figure(figsize=(7, 7))
ax = plt.axes(projection="3d")
ax.plot_surface(x, y, z, cmap='magma')

plt.show()

Et enfin, ce dernier exemple propose une animation d'une tore en rotation en 3D. Un backend de type Qt est bien entendu requis.

%matplotlib qt

import matplotlib.pyplot as plt
import numpy as np

theta = np.linspace(0, 2 * np.pi, 100)
phi = np.linspace(0, 2 * np.pi, 100)
theta, phi = np.meshgrid(theta, phi)
R = 2
r = 1

x = (R + r * np.cos(theta)) * np.cos(phi)
y = (R + r * np.cos(theta)) * np.sin(phi)
z = r * np.sin(theta)

fig = plt.figure(figsize=(10, 6))
ax = fig.add_subplot(111, projection='3d')

for i in range(100):
    ax.cla()
    ax.plot_surface(x, y, z, cmap='twilight')
    ax.view_init(elev=10., azim=i * 4)
    plt.pause(0.05)

plt.show()